A Shuffle where the Permutation set is the Key-Java Implementation

import java.awt.*;
import java.util.*;
import java.io.*;

//*Below is a code to implement the class Logic.
//*It applies a small keey. And prints the shuffled
//*array on the system monitor for the java runner.

//*It is useful in cryptography and in mathematical
//*simulation.

//*It fails to run in some C compilers and it works in
//Java. I have not tried C++ yet. The index function
//is the hard part for the compiler. And the running
//is proof of the applied simulated computer.
//*The algorithm simulates on the simulator of the
//*applied symbol(the computer).

public class Checklist{

                int i;
                int j;

                int dash[]=new int[81];
                int dart1[];

        int keey[]= {1,2,4,5,6,2,3,4,1};

                String outs;

                Integer ut;
                int counter;

                public Checklist() {

System.out.println("initialize start");
         System.out.println("start shuffle");

        Logic lag = new Logic();

                for(j=0;j<81;j++) {
                         dash[j]= j;
                }
//***********************************************************

        dart1 = lag.shuffle( dash, keey);

//***********************************************************
//*The above line calls the shuffle object using the keey
//*as the identity of the shuffle state. A permutation
//*sized symbol set is required to demonstrate the power
//*of the applied Integer Function.

        outs= "damit";

        for( i=0;i<81;i++){
                outs=outs + ",";
                ut = new Integer(dart1[i]);
                outs = outs + ut.toString();
         }

        System.out.println(outs);

} //end of constructor

//********************************************************************

                public static void main(String args[]) {
                        Checklist check = new Checklist();
                }
} //end of class

//*A 256MHz ppentium take three minutes to find the first
//*state. And each keey is only the unitary space. Making
//*the variable h another kind of unitary.
//*The differential can be simulated using the relation of
//*contentless change. A shift of the unit size will always
//*alter the content in the constant fashion. Meaning a
//*certain number represented by the relative size of the
//*array A[]contents will appear the fixed relation with the indicies.

//*Fixed as the differential of the set of the permutation.
//*Meaning the function has the shape.

//*A magnitude of the relative change of contents to index as
//*a relative change itself is the differential.

//*A supercomputer is needed to fully study this unique
//*algorithm. A PC is to slow.

//*I invented it theoretically and claim it unique in output.
//*I have not had the correct computer to validate the claims.

//*The nine dimensions are to allow only the nine set keey.
//*A unitary relation is established.

//*Yes you shuffle using the permutation set as the key. :)
Received on Thu Sep 29 21:53:19 2005