trickl/sort

IntArrayPermutator has 30 methods (exceeds 20 allowed). Consider refactoring.

Open

public class IntArrayPermutator implements Permutator {

  private int[] array;

  /**

File IntArrayPermutator.java has 254 lines of code (exceeds 250 allowed). Consider refactoring.

Open

/*
 * This file is part of the Trickl Open Source Libraries.
 *
 * Trickl Open Source Libraries - http://open.trickl.com/
 *

Method cycle has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public float[] cycle(float[] S, int first, int second, int third, int fourth, int fifth) {

Method cycle has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public <T> T[] cycle(T[] S, int first, int second, int third, int fourth, int fifth) {

Method cycle has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public int[] cycle(int[] S, int first, int second, int third, int fourth, int fifth) {

Method cycle has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public char[] cycle(char[] S, int first, int second, int third, int fourth, int fifth) {

Method cycle has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public short[] cycle(short[] S, int first, int second, int third, int fourth, int fifth) {

Method cycle has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public double[] cycle(double[] S, int first, int second, int third, int fourth, int fifth) {

Method cycle has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public <T> T[] cycle(T[] S, int first, int second, int third, int fourth) {

Method cycle has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public double[] cycle(double[] S, int first, int second, int third, int fourth) {

Method cycle has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public float[] cycle(float[] S, int first, int second, int third, int fourth) {

Method cycle has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public char[] cycle(char[] S, int first, int second, int third, int fourth) {

Method cycle has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public short[] cycle(short[] S, int first, int second, int third, int fourth) {

Method cycle has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

  public int[] cycle(int[] S, int first, int second, int third, int fourth) {

Identical blocks of code found in 2 locations. Consider refactoring.

Open

  @Override
  public float[] cycle(float[] S, int first, int second, int third, int fourth, int fifth) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 10 locations. Consider refactoring.

Open

  @Override
  public int[] cycle(int[] S, int first, int second, int third, int fourth, int fifth) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 10 locations. Consider refactoring.

Open

  @Override
  public <T> T[] cycle(T[] S, int first, int second, int third, int fourth, int fifth) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 10 locations. Consider refactoring.

Open

  @Override
  public short[] cycle(short[] S, int first, int second, int third, int fourth, int fifth) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 10 locations. Consider refactoring.

Open

  @Override
  public double[] cycle(double[] S, int first, int second, int third, int fourth, int fifth) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 10 locations. Consider refactoring.

Open

  @Override
  public char[] cycle(char[] S, int first, int second, int third, int fourth, int fifth) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public int[] cycle(int[] S, int first, int second, int third, int fourth) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public char[] cycle(char[] S, int first, int second, int third, int fourth) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public double[] cycle(double[] S, int first, int second, int third, int fourth) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public <T> T[] cycle(T[] S, int first, int second, int third, int fourth) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public float[] cycle(float[] S, int first, int second, int third, int fourth) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public short[] cycle(short[] S, int first, int second, int third, int fourth) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public short[] cycle(short[] S, int first, int second, int third) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public double[] cycle(double[] S, int first, int second, int third) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public float[] cycle(float[] S, int first, int second, int third) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public char[] cycle(char[] S, int first, int second, int third) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public int[] cycle(int[] S, int first, int second, int third) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public <T> T[] cycle(T[] S, int first, int second, int third) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = array[third];

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public char[] reverse(char[] S, int start, int end) {
    for (int i = start, j = end - 1; i < j; ++i, --j) {
      swap(S, i, j);
    }

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public <T> T[] reverse(T[] S, int start, int end) {
    for (int i = start, j = end - 1; i < j; ++i, --j) {
      swap(S, i, j);
    }

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public double[] reverse(double[] S, int start, int end) {
    for (int i = start, j = end - 1; i < j; ++i, --j) {
      swap(S, i, j);
    }

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public float[] reverse(float[] S, int start, int end) {
    for (int i = start, j = end - 1; i < j; ++i, --j) {
      swap(S, i, j);
    }

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public int[] reverse(int[] S, int start, int end) {
    for (int i = start, j = end - 1; i < j; ++i, --j) {
      swap(S, i, j);
    }

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public short[] reverse(short[] S, int start, int end) {
    for (int i = start, j = end - 1; i < j; ++i, --j) {
      swap(S, i, j);
    }

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public short[] swap(short[] S, int first, int second) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = temp;

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public <T> T[] swap(T[] S, int first, int second) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = temp;

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public float[] swap(float[] S, int first, int second) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = temp;

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public int[] swap(int[] S, int first, int second) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = temp;

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public char[] swap(char[] S, int first, int second) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = temp;

• Read up
  Read up

Similar blocks of code found in 12 locations. Consider refactoring.

Open

  @Override
  public double[] swap(double[] S, int first, int second) {
    int temp = array[first];
    array[first] = array[second];
    array[second] = temp;

• Read up
  Read up