RunSomeSortThread.java

package threads;

import java.lang.reflect.Constructor;

import main.ArrayVisualizer;
import panes.JErrorPane;
import sorts.hybrid.TimSort;
import sorts.templates.Sort;
import utils.Distributions;
import utils.Shuffles;
import utils.StopSort;

/*
 *
MIT License

Copyright (c) 2021 Josiah (Gaming32) Glosson

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
 *
 */

final public class RunSomeSortThread extends MultipleSortThread {
    final Class<? extends Sort> SORT_CLASS = TimSort.class;
    final int                  SORT_LENGTH = 2048;
    final double                SORT_SPEED = 0.75;
    final int                 BUCKET_COUNT = 0;

    public RunSomeSortThread(ArrayVisualizer arrayVisualizer) {
        super(arrayVisualizer);
        this.sortCount = 50;
        this.categoryCount = this.sortCount;
    }

    protected synchronized void runIndividualSort(Sort sort, int bucketCount, int[] array, int defaultLength, double defaultSpeed, boolean slowSort, String shuffleName) throws Exception {
        Delays.setSleepRatio(2.5);

        int sortLength;
        if(slowSort) {
            sortLength = this.calculateLengthSlow(defaultLength, sort.getUnreasonableLimit());
        }
        else {
            sortLength = this.calculateLength(defaultLength);
        }
        if(sortLength != arrayVisualizer.getCurrentLength()) {
            arrayFrame.setLengthSlider(sortLength);
        }

        arrayManager.refreshArray(array, arrayVisualizer.getCurrentLength(), this.arrayVisualizer);

        arrayVisualizer.setHeading(shuffleName + " (Sort " + this.sortNumber + " of " + this.sortCount + ")");

        double sortSpeed = this.calculateSpeed(defaultSpeed, arrayVisualizer.getCurrentLength());
        Delays.setSleepRatio(sortSpeed);

        Timer.enableRealTimer();

        // arrayVisualizer.toggleVisualUpdates(true);
        try {
            sort.runSort(array, arrayVisualizer.getCurrentLength(), bucketCount);
        }
        catch (StopSort e) { }
        catch (Exception e) {
            JErrorPane.invokeErrorMessage(e);
        }
        // arrayVisualizer.toggleVisualUpdates(false);

        arrayVisualizer.endSort();
        Thread.sleep(1000);

        this.sortNumber++;
    }

    protected synchronized Sort createSortInstance() {
        Constructor<? extends Sort> constructor;
        try {
            constructor = SORT_CLASS.getDeclaredConstructor(ArrayVisualizer.class);
        } catch (Exception e) {
            JErrorPane.invokeErrorMessage(e);
            throw new RuntimeException("Class " + SORT_CLASS.getName() + " is not an accessible sort class.");
        }
        try {
            return constructor.newInstance(arrayVisualizer);
        } catch (Exception e) {
            JErrorPane.invokeErrorMessage(e);
            throw new RuntimeException("Unable to initialize class " + SORT_CLASS.getName() + ".");
        }
    }

    protected synchronized void runSort(int[] array, String shuffleName) throws Exception {
        Sort sort = createSortInstance();
        RunSomeSortThread.this.runIndividualSort(sort, BUCKET_COUNT, array, SORT_LENGTH, SORT_SPEED, false, shuffleName);
    }

    @Override
    protected synchronized void executeSortList(int[] array) throws Exception {
        arrayVisualizer.getArrayManager().setDistribution(Distributions.LINEAR); // 1
        arrayVisualizer.getArrayManager().setShuffle(Shuffles.RANDOM);
        RunSomeSortThread.this.runSort(array, "Randomly");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.REVERSE); // 2
        RunSomeSortThread.this.runSort(array, "Backwards");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.ALMOST); // 3
        RunSomeSortThread.this.runSort(array, "Slight Shuffle");

        arrayVisualizer.getArrayFrame().setUniqueSlider(arrayVisualizer.getCurrentLength() / 32); // 4
        arrayVisualizer.getArrayManager().setShuffle(Shuffles.RANDOM);
        RunSomeSortThread.this.runSort(array, "Many Similar (div 32)");

        arrayVisualizer.getArrayFrame().setUniqueSlider(arrayVisualizer.getCurrentLength() / 64); // 5
        arrayVisualizer.getArrayManager().setShuffle(Shuffles.RANDOM);
        RunSomeSortThread.this.runSort(array, "Many Similar (div 64)");

        arrayVisualizer.getArrayFrame().setUniqueSlider(arrayVisualizer.getCurrentLength()); // 6
        arrayVisualizer.getArrayManager().setShuffle(Shuffles.SORTED);
        RunSomeSortThread.this.runSort(array, "Already Sorted");

        arrayVisualizer.getArrayFrame().setUniqueSlider(arrayVisualizer.getCurrentLength()); // 7
        arrayVisualizer.getArrayManager().setShuffle(Shuffles.NAIVE);
        RunSomeSortThread.this.runSort(array, "Naive Randomly");

        arrayVisualizer.getArrayFrame().setUniqueSlider(arrayVisualizer.getCurrentLength()); // 8
        arrayVisualizer.getArrayManager().setShuffle(Shuffles.SHUFFLED_TAIL);
        RunSomeSortThread.this.runSort(array, "Scrambled Tail");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.SHUFFLED_HEAD); // 9
        RunSomeSortThread.this.runSort(array, "Scrambled Head");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.MOVED_ELEMENT); // 10
        RunSomeSortThread.this.runSort(array, "Shifted Element");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.NOISY); // 11
        RunSomeSortThread.this.runSort(array, "Noisy");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.SHUFFLED_ODDS); // 12
        RunSomeSortThread.this.runSort(array, "Scrambled Odds");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.FINAL_MERGE); // 13
        RunSomeSortThread.this.runSort(array, "Final Merge Pass");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.REAL_FINAL_MERGE); // 14
        RunSomeSortThread.this.runSort(array, "Shuffled Final Merge");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.SHUFFLED_HALF); // 15
        RunSomeSortThread.this.runSort(array, "Shuffled Half");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.PARTITIONED); // 16
        RunSomeSortThread.this.runSort(array, "Partitioned");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.SAWTOOTH); // 17
        RunSomeSortThread.this.runSort(array, "Sawtooth Input");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.REV_FINAL_MERGE); // 18
        RunSomeSortThread.this.runSort(array, "Reversed Final Merge");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.REV_SAWTOOTH); // 19
        RunSomeSortThread.this.runSort(array, "Reversed Sawtooth");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.ORGAN); // 20
        RunSomeSortThread.this.runSort(array, "Pipe Organ");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.FINAL_BITONIC); // 21
        RunSomeSortThread.this.runSort(array, "Final Bitonic Pass");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.INTERLACED); // 22
        RunSomeSortThread.this.runSort(array, "Interlaced");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.DOUBLE_LAYERED); // 23
        RunSomeSortThread.this.runSort(array, "Double Layered");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.FINAL_RADIX); // 24
        RunSomeSortThread.this.runSort(array, "Final Radix Pass");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.REC_RADIX); // 25
        RunSomeSortThread.this.runSort(array, "Recursive Final Radix Pass");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.HALF_ROTATION); // 26
        RunSomeSortThread.this.runSort(array, "Half Rotation");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.PARTIAL_REVERSE); // 27
        RunSomeSortThread.this.runSort(array, "Half Reversed");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.BST_TRAVERSAL); // 28
        RunSomeSortThread.this.runSort(array, "Binary Search Tree Traversal");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.INV_BST); // 29
        RunSomeSortThread.this.runSort(array, "Inverted Binary Search Tree");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.LOG_SLOPES); // 30
        RunSomeSortThread.this.runSort(array, "Logarithmic Slopes");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.HEAPIFIED); // 31
        RunSomeSortThread.this.runSort(array, "Heapified Input");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.REV_SMOOTH); // 32
        RunSomeSortThread.this.runSort(array, "Reversed Smooth Heapified Input");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.REV_POPLAR); // 33
        RunSomeSortThread.this.runSort(array, "Reversed Poplar Heapified Input");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.TRI_HEAP); // 34
        RunSomeSortThread.this.runSort(array, "Triangular Heapified Input");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.CIRCLE); // 35
        RunSomeSortThread.this.runSort(array, "First Circle Pass");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.PAIRWISE); // 36
        RunSomeSortThread.this.runSort(array, "Final Pairwise Pass");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.REC_REV); // 37
        RunSomeSortThread.this.runSort(array, "Recursive Reversal");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.GRAY_CODE); // 38
        RunSomeSortThread.this.runSort(array, "Gray Code Fractal");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.SIERPINSKI); // 39
        RunSomeSortThread.this.runSort(array, "Sierpinski Triangle");

        arrayVisualizer.getArrayManager().setDistribution(Distributions.BELL_CURVE); // 40
        arrayVisualizer.getArrayManager().setShuffle(Shuffles.ALREADY);
        RunSomeSortThread.this.runSort(array, "Bell Curve");

        arrayVisualizer.getArrayManager().setDistribution(Distributions.PERLIN_NOISE_CURVE); // 41
        RunSomeSortThread.this.runSort(array, "Perlin Noise Curve");

        arrayVisualizer.getArrayManager().setDistribution(Distributions.PERLIN_NOISE); // 42
        RunSomeSortThread.this.runSort(array, "Perlin Noise");

        arrayVisualizer.getArrayManager().setDistribution(Distributions.LINEAR); // 43
        arrayVisualizer.getArrayManager().setShuffle(Shuffles.TRIANGULAR);
        RunSomeSortThread.this.runSort(array, "Triangular Input");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.QSORT_BAD); // 44
        RunSomeSortThread.this.runSort(array, "Quicksort Adversary");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.PDQ_BAD); // 45
        RunSomeSortThread.this.runSort(array, "PDQ Adversary");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.GRAIL_BAD); // 46
        RunSomeSortThread.this.runSort(array, "Grailsort Adversary");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.SHUF_MERGE_BAD); // 47
        RunSomeSortThread.this.runSort(array, "Shuffle Merge Adversary");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.BIT_REVERSE); // 48
        RunSomeSortThread.this.runSort(array, "Bit Reversal");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.BLOCK_RANDOMLY); // 49
        RunSomeSortThread.this.runSort(array, "Randomly w/ Blocks");

        arrayVisualizer.getArrayManager().setShuffle(Shuffles.BLOCK_REVERSE); // 50
        RunSomeSortThread.this.runSort(array, "Block Reversal");
    }

    @Override
    protected synchronized void runThread(int[] array, int current, int total, boolean runAllActive) throws Exception {
        if(arrayVisualizer.isActive())
            return;

        Sounds.toggleSound(true);
        arrayVisualizer.setSortingThread(new Thread() {
            @Override
            public void run() {
                try{
                    if(runAllActive) {
                        RunSomeSortThread.this.sortNumber = current;
                        RunSomeSortThread.this.sortCount = total;
                    }
                    else {
                        RunSomeSortThread.this.sortNumber = 1;
                    }

                    arrayManager.toggleMutableLength(false);

                    Sort tempSort = createSortInstance();

                    arrayVisualizer.setCategory(tempSort.getRunAllSortsName());

                    RunSomeSortThread.this.executeSortList(array);

                    if(!runAllActive) {
                        arrayVisualizer.setCategory("Run " + tempSort.getRunAllSortsName());
                        arrayVisualizer.setHeading("Done");
                    }

                    arrayManager.toggleMutableLength(true);
                }
                catch (Exception e) {
                    JErrorPane.invokeErrorMessage(e);
                }
                Sounds.toggleSound(false);
                arrayVisualizer.setSortingThread(null);
            }
        });

        arrayVisualizer.runSortingThread();
    }
}