Sign upLogin

trickl/sort

View on GitHub
Star
src/main/java/com/trickl/math/StandardPermutator.java

Summary

Maintainability
F
5 days
Test Coverage

StandardPermutator has 30 methods (exceeds 20 allowed). Consider refactoring.
Open

public class StandardPermutator implements Permutator {

  /**
   * {@inheritDoc}
   *
Severity: Minor
Found in src/main/java/com/trickl/math/StandardPermutator.java - About 3 hrs to fix

    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) {
    Severity: Minor
    Found in src/main/java/com/trickl/math/StandardPermutator.java - About 45 mins to fix

      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) {
      Severity: Minor
      Found in src/main/java/com/trickl/math/StandardPermutator.java - About 45 mins to fix

        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) {
        Severity: Minor
        Found in src/main/java/com/trickl/math/StandardPermutator.java - About 45 mins to fix

          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) {
          Severity: Minor
          Found in src/main/java/com/trickl/math/StandardPermutator.java - About 45 mins to fix

            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) {
            Severity: Minor
            Found in src/main/java/com/trickl/math/StandardPermutator.java - About 45 mins to fix

              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) {
              Severity: Minor
              Found in src/main/java/com/trickl/math/StandardPermutator.java - About 45 mins to fix

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

                  public int[] cycle(int[] S, int first, int second, int third, int fourth) {
                Severity: Minor
                Found in src/main/java/com/trickl/math/StandardPermutator.java - About 35 mins to fix

                  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) {
                  Severity: Minor
                  Found in src/main/java/com/trickl/math/StandardPermutator.java - About 35 mins to fix

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

                      public double[] cycle(double[] S, int first, int second, int third, int fourth) {
                    Severity: Minor
                    Found in src/main/java/com/trickl/math/StandardPermutator.java - About 35 mins to fix

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

                        public float[] cycle(float[] S, int first, int second, int third, int fourth) {
                      Severity: Minor
                      Found in src/main/java/com/trickl/math/StandardPermutator.java - About 35 mins to fix

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

                          public char[] cycle(char[] S, int first, int second, int third, int fourth) {
                        Severity: Minor
                        Found in src/main/java/com/trickl/math/StandardPermutator.java - About 35 mins to fix

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

                            public short[] cycle(short[] S, int first, int second, int third, int fourth) {
                          Severity: Minor
                          Found in src/main/java/com/trickl/math/StandardPermutator.java - About 35 mins to fix

                            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) {
    float temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 1 other location - About 1 hr to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 332..342

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 117.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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) {
    short temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 9 other locations - About 1 hr to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 300..309
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 316..325
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 349..358
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 365..374
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 381..390
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 304..313
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 337..346
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 353..362
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 369..378

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 101.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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 = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 9 other locations - About 1 hr to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 300..309
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 316..325
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 349..358
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 365..374
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 381..390
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 288..297
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 304..313
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 337..346
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 369..378

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 101.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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) {
    char temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 9 other locations - About 1 hr to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 300..309
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 316..325
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 349..358
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 365..374
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 381..390
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 288..297
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 337..346
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 353..362
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 369..378

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 101.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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) {
    double temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 9 other locations - About 1 hr to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 300..309
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 316..325
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 349..358
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 365..374
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 381..390
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 288..297
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 304..313
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 353..362
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 369..378

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 101.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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) {
    T temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 9 other locations - About 1 hr to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 300..309
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 316..325
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 349..358
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 365..374
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 381..390
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 288..297
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 304..313
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 337..346
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 353..362

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 101.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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) {
    double temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 1 hr to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 210..218
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 225..233
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 240..248
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 255..263
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 270..278
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 285..293
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 198..206
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 213..221
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 228..236
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 258..266
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 273..281

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 84.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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) {
    char temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 1 hr to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 210..218
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 225..233
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 240..248
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 255..263
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 270..278
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 285..293
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 198..206
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 228..236
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 243..251
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 258..266
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 273..281

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 84.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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) {
    float temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 1 hr to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 210..218
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 225..233
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 240..248
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 255..263
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 270..278
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 285..293
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 198..206
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 213..221
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 243..251
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 258..266
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 273..281

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 84.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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) {
    short temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 1 hr to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 210..218
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 225..233
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 240..248
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 255..263
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 270..278
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 285..293
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 213..221
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 228..236
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 243..251
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 258..266
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 273..281

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 84.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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 = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 1 hr to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 210..218
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 225..233
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 240..248
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 255..263
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 270..278
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 285..293
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 198..206
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 213..221
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 228..236
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 243..251
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 273..281

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 84.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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) {
    T temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 1 hr to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 210..218
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 225..233
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 240..248
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 255..263
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 270..278
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 285..293
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 198..206
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 213..221
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 228..236
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 243..251
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 258..266

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 84.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

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

                              @Override
  public double[] cycle(double[] S, int first, int second, int third) {
    double temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 55 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 126..133
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 140..147
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 154..161
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 168..175
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 182..189
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 196..203
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 114..121
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 128..135
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 142..149
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 170..177
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 184..191

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 67.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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 = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 55 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 126..133
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 140..147
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 154..161
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 168..175
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 182..189
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 196..203
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 114..121
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 128..135
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 142..149
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 156..163
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 184..191

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 67.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

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

                              @Override
  public short[] cycle(short[] S, int first, int second, int third) {
    short temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 55 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 126..133
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 140..147
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 154..161
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 168..175
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 182..189
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 196..203
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 128..135
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 142..149
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 156..163
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 170..177
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 184..191

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 67.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

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

                              @Override
  public char[] cycle(char[] S, int first, int second, int third) {
    char temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 55 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 126..133
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 140..147
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 154..161
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 168..175
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 182..189
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 196..203
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 114..121
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 142..149
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 156..163
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 170..177
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 184..191

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 67.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

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

                              @Override
  public float[] cycle(float[] S, int first, int second, int third) {
    float temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 55 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 126..133
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 140..147
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 154..161
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 168..175
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 182..189
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 196..203
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 114..121
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 128..135
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 156..163
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 170..177
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 184..191

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 67.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

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

                              @Override
  public <T> T[] cycle(T[] S, int first, int second, int third) {
    T temp = S[first];
    S[first] = S[second];
    S[second] = S[third];
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 55 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 126..133
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 140..147
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 154..161
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 168..175
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 182..189
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 196..203
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 114..121
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 128..135
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 142..149
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 156..163
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 170..177

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 67.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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);
    }
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 40 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 397..403
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 410..416
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 423..429
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 436..442
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 449..455
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 462..468
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 385..391
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 398..404
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 424..430
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 437..443
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 450..456

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 52.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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);
    }
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 40 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 397..403
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 410..416
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 423..429
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 436..442
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 449..455
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 462..468
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 385..391
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 398..404
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 411..417
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 424..430
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 450..456

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 52.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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);
    }
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 40 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 397..403
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 410..416
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 423..429
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 436..442
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 449..455
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 462..468
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 385..391
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 398..404
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 411..417
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 424..430
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 437..443

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 52.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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);
    }
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 40 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 397..403
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 410..416
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 423..429
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 436..442
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 449..455
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 462..468
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 398..404
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 411..417
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 424..430
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 437..443
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 450..456

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 52.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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);
    }
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 40 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 397..403
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 410..416
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 423..429
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 436..442
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 449..455
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 462..468
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 385..391
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 398..404
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 411..417
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 437..443
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 450..456

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 52.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            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);
    }
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 40 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 397..403
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 410..416
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 423..429
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 436..442
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 449..455
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 462..468
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 385..391
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 411..417
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 424..430
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 437..443
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 450..456

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 52.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

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

                              @Override
  public float[] swap(float[] S, int first, int second) {
    float temp = S[first];
    S[first] = S[second];
    S[second] = temp;
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 40 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 48..54
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 61..67
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 74..80
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 87..93
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 100..106
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 113..119
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 36..42
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 49..55
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 62..68
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 88..94
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 101..107

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 50.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

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

                              @Override
  public <T> T[] swap(T[] S, int first, int second) {
    T temp = S[first];
    S[first] = S[second];
    S[second] = temp;
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 40 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 48..54
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 61..67
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 74..80
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 87..93
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 100..106
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 113..119
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 36..42
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 49..55
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 62..68
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 75..81
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 88..94

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 50.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

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

                              @Override
  public short[] swap(short[] S, int first, int second) {
    short temp = S[first];
    S[first] = S[second];
    S[second] = temp;
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 40 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 48..54
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 61..67
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 74..80
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 87..93
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 100..106
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 113..119
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 49..55
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 62..68
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 75..81
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 88..94
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 101..107

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 50.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

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

                              @Override
  public int[] swap(int[] S, int first, int second) {
    int temp = S[first];
    S[first] = S[second];
    S[second] = temp;
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 40 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 48..54
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 61..67
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 74..80
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 87..93
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 100..106
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 113..119
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 36..42
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 49..55
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 62..68
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 75..81
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 101..107

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 50.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

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

                              @Override
  public char[] swap(char[] S, int first, int second) {
    char temp = S[first];
    S[first] = S[second];
    S[second] = temp;
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 40 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 48..54
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 61..67
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 74..80
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 87..93
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 100..106
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 113..119
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 36..42
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 62..68
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 75..81
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 88..94
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 101..107

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 50.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

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

                              @Override
  public double[] swap(double[] S, int first, int second) {
    double temp = S[first];
    S[first] = S[second];
    S[second] = temp;
                            Severity: Major
                            Found in src/main/java/com/trickl/math/StandardPermutator.java and 11 other locations - About 40 mins to fix
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 48..54
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 61..67
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 74..80
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 87..93
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 100..106
                            src/main/java/com/trickl/math/IntArrayPermutator.java on lines 113..119
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 36..42
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 49..55
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 75..81
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 88..94
                            src/main/java/com/trickl/math/StandardPermutator.java on lines 101..107

                            Duplicated Code

                            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                            Tuning

                            This issue has a mass of 50.

                            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                            Refactorings

                            Further Reading

                            There are no issues that match your filters.

                            Category
                            Status