Exemple #1
0
        public FactoryEDO87(Type_Map map, bool[] pinc) : base(87, map, pinc)
        {
            commas    = new Comma[6];
            pumps     = new Pump[6];
            commas[0] = new Comma(this, new int[] { 5, -6, 0 });
            pumps[0]  = new Pump(commas[0]);
            commas[1] = new Comma(this, new int[] { 2, 15, 0 });
            pumps[1]  = new Pump(commas[1]);
            commas[2] = new Comma(this, new int[] { -2, 1, -2, 1 });
            pumps[2]  = new Pump(commas[2]);
            commas[3] = new Comma(this, new int[] { 1, -1, -1, -1 });
            pumps[3]  = new Pump(commas[3]);
            commas[4] = new Comma(this, new int[] { -2, -4, 0, 1 });
            pumps[4]  = new Pump(commas[4]);
            commas[5] = new Comma(this, new int[] { -3, 1, -1, -1, 1 });
            pumps[5]  = new Pump(commas[5],
                                 // new int[] {0, 28, 45, 19, 66, 15, 51 });
                                 new int[] { 0, 28, 45, 19, 66, 15, 51 });
            pumpStructure = new PumpStructureRandom(this);
            //PumpStructure b87 = new PumpStructureBig(this, 3);
            //pumpStructure = new PumpStructureSum(this, a87, b87);

            /*
             * scale = new bool[29];
             * for(int i = 0; i<5; i++)
             * {
             *  scale[(7 * i) % 29] = true;
             * }
             */
            /*
             * scale = new bool[3];
             * scale[0] = true;
             * scale[1] = true;
             */

            dichotomy        = new bool[3, edo];
            dichotomy[0, 0]  = true;
            dichotomy[0, 51] = true;
            dichotomy[0, 36] = true;
            dichotomy[0, 28] = true;
            dichotomy[0, 59] = true;
            dichotomy[0, 23] = true;
            dichotomy[0, 64] = true;
            dichotomy[0, 15] = true;
            dichotomy[0, 72] = true;
        }
Exemple #2
0
        public override int pattern(int loc)
        {
            int pitch = 0;
            int rsize = factory.map.row_size;
            int chunk = factory.map.size / rsize;

            int big   = loc / chunk;
            int small = loc % rsize;

            if (big > rsize / 4 &&
                big < (3 * rsize) / 4)
            {
                Pump pump = factory.pumps[pumpi];
                pitch = pump.sequence[(small * pump.sequence.Length) / rsize];
            }

            return(pitch);
        }
Exemple #3
0
        public FactoryEDO43(Type_Map map, bool[] pinc) : base(43, map, pinc)
        {
            commas = new Comma[2];
            pumps  = new Pump[2];

            pumpStructure = new PumpStructureNull(this);


            dichotomy        = new bool[1, edo];
            dichotomy[0, 0]  = true;
            dichotomy[0, 18] = true;
            dichotomy[0, 25] = true;
            dichotomy[0, 14] = true;
            dichotomy[0, 29] = true;
            dichotomy[0, 11] = true;
            dichotomy[0, 32] = true;
            dichotomy[0, 7]  = true;
            dichotomy[0, 36] = true;
        }
Exemple #4
0
        public FactoryEDO32(Type_Map map, bool[] pinc) : base(32, map, pinc)
        {
            commas    = new Comma[1];
            pumps     = new Pump[1];
            commas[0] = new Comma(this, new int[] { 6, -5, 0 });
            pumps[0]  = new Pump(commas[0],
                                 new int[] { 22, 31, 8, 17, 26, 3 });
            pumpStructure = new PumpStructureSimple(this, 0);


            for (int i = 0; i < edo; i++)
            {
                scale[i] = false;
            }

            for (int i = 0; i < 18; i++)
            {
                scale[(i * 9) % 32] = true;
            }
        }
Exemple #5
0
        public FactoryEDO12(Type_Map map, bool[] pinc) : base(12, map, pinc)
        {
            commas    = new Comma[2];
            pumps     = new Pump[2];
            commas[0] = new Comma(this, new int[] { 4, -1 });
            pumps[0]  = new Pump(commas[0], new int[] { 0, 7, 2, 9, 4 });
            commas[1] = new Comma(this, new int[] { 0, 3 });
            pumps[1]  = new Pump(commas[1]);

            pumpStructure = new PumpStructureRandom(this);

            /*
             * for (int i = 0; i < edo; i++)
             * {
             *  scale[i] = false;
             * }
             *
             * for (int i = 0; i < 7; i++)
             * {
             *  scale[(5 + 7 * i) % edo] = true;
             * }
             */

            augmented    = new bool[4];
            augmented[0] = true;
            augmented[1] = true;

            dichotomy        = new bool[1, edo];
            dichotomy[0, 0]  = true;
            dichotomy[0, 7]  = true;
            dichotomy[0, 5]  = true;
            dichotomy[0, 4]  = true;
            dichotomy[0, 8]  = true;
            dichotomy[0, 3]  = true;
            dichotomy[0, 9]  = true;
            dichotomy[0, 2]  = true;
            dichotomy[0, 10] = true;
        }
Exemple #6
0
        public FactoryEDO50(Type_Map map, bool[] pinc) : base(50, map, pinc)
        {
            commas = new Comma[2];
            pumps  = new Pump[2];

            commas[1] = new Comma(this, new int[] { 4, -1, 0 });
            pumps[1]  = new Pump(commas[1],
                                 new int[] { 37, 16, 45, 24, 3 });

            pumpStructure = new PumpStructureRandom(this);

            //scale = new bool[25];

            for (int i = 0; i < edo; i++)
            {
                scale[i] = false;
            }


            for (int i = 0; i < 19; i++)
            {
                scale[(29 * i) % scale.Length] = true;
            }

            dichotomy        = new bool[2, edo];
            dichotomy[0, 0]  = true;
            dichotomy[0, 29] = true;
            dichotomy[0, 21] = true;
            dichotomy[0, 16] = true;
            dichotomy[0, 34] = true;
            dichotomy[0, 37] = true;
            dichotomy[0, 13] = true;

            dichotomy[1, 0]  = true;
            dichotomy[1, 29] = true;
            dichotomy[1, 21] = true;
        }
Exemple #7
0
        public void olFactoryEDO5(int e, Type_Map tmap)
        {
            map = tmap;



            int ccnt = 3;

            comma3 = new int[ccnt];
            comma5 = new int[ccnt];
            comma7 = new int[ccnt];

            scale = new bool[edo];
            for (int i = 0; i < edo; i++)
            {
                scale[i] = true;
            }

            pumpStructure = new PumpStructureNull(this);
            switch (edo)
            {
            case 10:
                comma3[0]     = 4;
                comma5[0]     = 2;
                comma3[1]     = 1;
                comma5[1]     = -2;
                commas        = new Comma[2];
                pumps         = new Pump[2];
                commas[0]     = new Comma(this, new int[] { 4, -2, -1 });
                pumps[0]      = new Pump(commas[0]);
                commas[1]     = new Comma(this, new int[] { 4, 2, 0 });
                pumps[1]      = new Pump(commas[1]);
                pumpStructure = new PumpStructureSimple(this, 0);
                break;

            case 12:
                comma3[0] = 4;
                comma5[0] = -1;
                comma3[1] = 0;
                comma5[1] = 3;
                commas    = new Comma[2];
                pumps     = new Pump[2];
                commas[0] = new Comma(this, new int[] { 4, -1, 0 });
                pumps[0]  = new Pump(commas[0]);
                commas[1] = new Comma(this, new int[] { 0, 3, 0 });
                pumps[1]  = new Pump(commas[1]);
                PumpStructure a = new PumpStructureSimple(this, 0);
                PumpStructure b = new PumpStructureBig(this, 1);
                pumpStructure = new PumpStructureSum(this, a, b);
                break;

            case 15:
                commas        = new Comma[2];
                pumps         = new Pump[2];
                commas[0]     = new Comma(this, new int[] { 5, 0, 0 });
                pumps[0]      = new Pump(commas[0]);
                commas[1]     = new Comma(this, new int[] { 0, 3, 0 });
                pumps[1]      = new Pump(commas[1]);
                pumpStructure = new PumpStructureSimple(this, 0);
                break;

            case 22:
                comma3[0]     = 4;
                comma5[0]     = 2;
                comma3[1]     = 1;
                comma5[1]     = -5;
                commas        = new Comma[3];
                pumps         = new Pump[3];
                commas[0]     = new Comma(this, new int[] { 4, 2, 0 });
                pumps[0]      = new Pump(commas[0]);
                commas[1]     = new Comma(this, new int[] { 1, -5, 0 });
                pumps[1]      = new Pump(commas[1]);
                commas[2]     = new Comma(this, new int[] { 5, -3, 0 });
                pumps[2]      = new Pump(commas[2]);
                pumpStructure = new PumpStructureSimple(this, 2);
                break;

            case 34:


                break;

            case 41:
                commas    = new Comma[4];
                pumps     = new Pump[4];
                commas[0] = new Comma(this, new int[] { -2, 2, 0, -1 });
                pumps[0]  = new Pump(commas[0]);
                commas[1] = new Comma(this, new int[] { 6, 1, -6 });
                commas[2] = new Comma(this, new int[] { -5, 0, 0, 2 });
                commas[3] = new Comma(this, new int[] { 2, -5, 3 });
                //pumps[1] = new Pump(commas[1], new int[] { 27, 36, 4, 13, 22, 31, 40 });
                pumps[1] = new Pump(commas[3], new int[]
                                    { 0, 28, 20, 7, 31, 18, 10, 38, 21, 8 });

                pumpStructure = new PumpStructureSimple(this, 1);

                for (int i = 0; i < edo; i++)
                {
                    scale[i] = false;
                }

                /*
                 * for (int i = 0; i < 14; i++)
                 * {
                 *  scale[(9 * i) % edo] = true;
                 * }
                 */

                scale[0]  = true;
                scale[7]  = true;
                scale[8]  = true;
                scale[10] = true;
                scale[17] = true;
                scale[18] = true;
                scale[20] = true;
                scale[21] = true;
                scale[28] = true;
                scale[30] = true;
                scale[31] = true;
                scale[38] = true;
                scale[39] = true;



                /*
                 * scale[0] = true;
                 * scale[7] = true;
                 * scale[12] = true;
                 * scale[19] = true;
                 * scale[24] = true;
                 * scale[29] = true;
                 * scale[36] = true;
                 */
                /*
                 * scale = new bool[24];
                 * scale[0] = true;
                 * scale[3] = true;
                 * scale[6] = true;
                 * scale[9] = true;
                 * scale[13] = true;
                 * scale[17] = true;
                 * scale[20] = true;
                 */
                break;

            case 50:
                commas        = new Comma[3];
                pumps         = new Pump[3];
                commas[1]     = new Comma(this, new int[] { 4, -1, 0 });
                pumps[1]      = new Pump(commas[1]);
                pumpStructure = new PumpStructureSimple(this, 1);
                break;

            case 53:


                break;

            case 65:
                commas    = new Comma[4];
                pumps     = new Pump[4];
                commas[0] = new Comma(this, new int[] { 15, 10 });
                pumps[0]  = new Pump(commas[0], new int[]
                                     { 0, 38, 11, 32, 5, 26, 64, 37, 58, 31, 52, 25, 63, 19, 57, 13, 51,
                                      24, 45, 18, 39, 12, 50, 6, 44 });

                pumpStructure = new PumpStructureSimple(this, 0);

                scale = new bool[13];

                for (int i = 0; i < 5; i++)
                {
                    scale[(6 * i) % 13] = true;
                }
                break;

            case 72:
                commas    = new Comma[4];
                pumps     = new Pump[4];
                commas[0] = new Comma(this, new int[] { -5, 0, 0, 2 });
                pumps[0]  = new Pump(commas[0]);
                commas[1] = new Comma(this, new int[] { 0, -3, 3, -1 });
                pumps[1]  = new Pump(commas[1]);
                commas[2] = new Comma(this, new int[] { -2, -2, 1, 0 });
                pumps[2]  = new Pump(commas[2]);
                commas[3] = new Comma(this, new int[] { 5, -6 });
                pumps[3]  = new Pump(commas[3], new int[] { 0, 19, 38, 57, 4, 23, 42 });

                //PumpStructure a12 = new PumpStructureBig(this, 0);
                //PumpStructure b12 = new PumpStructureSimple(this, 2);
                //pumpStructure = // a;
                //  new PumpStructureSum(this, a12, b12);
                pumpStructure = new PumpStructureSimple(this, 3);

                scale     = new bool[19];
                scale[0]  = true;
                scale[4]  = true;
                scale[8]  = true;
                scale[11] = true;
                scale[15] = true;

                break;

            case 84:

                commas    = new Comma[1];
                pumps     = new Pump[1];
                commas[0] = new Comma(this, new int[] { 3, 7 });
                pumps[0]  = new Pump(commas[0], new int[]
                                     { 0, 27, 54, 19, 46, 73, 38, 65, 8, 35 });

                pumpStructure = new PumpStructureSimple(this, 0);
                for (int i = 0; i < edo; i++)
                {
                    scale[i] = false;
                }

                for (int i = 0; i < 13; i++)
                {
                    scale[(35 + 19 * i) % edo] = true;
                }
                break;

            case 140:
                comma3[0] = 0;
                comma5[0] = 3;
                comma7[0] = 5;
                comma3[1] = 5;
                comma5[1] = -6;

                for (int i = 0; i < edo; i++)
                {
                    scale[i] = false;
                }
                for (int i = 0; i < 32; i++)
                {
                    scale[(13 * i) % edo] = true;
                }

                break;

            case 159:
                commas = new Comma[3];
                pumps  = new Pump[3];


                commas[0] = new Comma(this, new int[] { 0, 0, 9, 6 });
                pumps[0]  = new Pump(commas[0]);

                pumpStructure = new PumpStructureSimple(this, 0);
                break;

            case 270:
                commas        = new Comma[3];
                pumps         = new Pump[3];
                commas[0]     = new Comma(this, new int[] { 6, 4, -3, -3 });
                pumps[0]      = new Pump(commas[0]);
                commas[1]     = new Comma(this, new int[] { 9, -8, 4, -2 });
                pumps[1]      = new Pump(commas[1]);
                commas[2]     = new Comma(this, new int[] { 3, -2, 1, -2 });
                pumps[2]      = new Pump(commas[2]);
                pumpStructure = new PumpStructureSimple(this, 2);

                for (int i = 0; i < edo; i++)
                {
                    scale[i] = false;
                }
                for (int i = 0; i < 44; i++)
                {
                    scale[(43 * i) % edo] = true;
                }


                break;

            default:

                break;
            }

            icnt = 5 * edo;
        }
Exemple #8
0
        public FactoryEDO342(Type_Map map, bool[] pinc) : base(342, map, pinc)
        {
            build_dichotomy(11);

            commas    = new Comma[4];
            pumps     = new Pump[4];
            commas[0] = new Comma(this, new int[] { 2, 2, -7, 4 });
            pumps[0]  = new Pump(commas[0]);

            commas[1] = new Comma(this, new int[] { 8, 1 });
            pumps[1]  = new Pump(commas[1], new int[]
                                 { 0, 142, 284, 84, 226, 26, 168, 310, 110 });
            commas[2] = new Comma(this, new int[] { -4, -3, -2, 2 });
            pumps[2]  = new Pump(commas[2], new int[]
                                 { 0, 142, 32, 98, 240, 55, 197, 87, 153, 310, 110 });

            commas[3] = new Comma(this, new int[] { 3, 0, 0, -6 });
            pumps[3]  = new Pump(commas[3]);

            PumpStructure a342 = new PumpStructureSimple(this, 1);
            PumpStructure b342 = new PumpStructureBig(this, 2);

            pumpStructure = new PumpStructureSimple(this, 2);

            /*
             * scale = new bool[114];
             * for(int i = 0; i < 5; i++)
             * {
             *  scale[(i * 43) % 114] = true;
             * }
             */

            /*
             * for (int i = 0; i < edo; i++)
             * {
             *  scale[i] = false;
             * }
             *
             * scale[0] = true;
             * scale[11] = true;
             * scale[32] = true;
             * scale[44] = true;
             * scale[55] = true;
             * scale[66] = true;
             * scale[87] = true;
             * scale[98] = true;
             * scale[110] = true;
             * scale[131] = true;
             * scale[142] = true;
             * scale[153] = true;
             * scale[174] = true;
             * scale[186] = true;
             * scale[197] = true;
             * scale[208] = true;
             * scale[229] = true;
             * scale[240] = true;
             * scale[252] = true;
             * scale[263] = true;
             * scale[284] = true;
             * scale[287] = true;
             * scale[298] = true;
             * scale[310] = true;
             * scale[331] = true;
             */
            /*
             * for (int i = 0; i < 24; i++)
             * {
             *  scale[(71 * i) % edo] = true;
             * }
             */
            /*
             * dichotomy = new bool[edo];
             *
             * dichotomy[0] = true;
             * dichotomy[200] = true;
             * dichotomy[142] = true;
             * dichotomy[58] = true;
             * dichotomy[284] = true;
             * dichotomy[43] = true;
             * dichotomy[299] = true;
             * dichotomy[157] = true;
             * dichotomy[185] = true;
             */
        }
Exemple #9
0
        public FactoryEDO118(Type_Map map, bool[] pinc) : base(118, map, pinc)
        {
            commas    = new Comma[4];
            pumps     = new Pump[4];
            commas[0] = new Comma(this, new int[] { 8, 1, 0 });
            pumps[0]  = new Pump(commas[0]
                                 , new int[]
                                 { 89, 40, 109, 60, 11, 80, 31, 100, 51 }
                                 );
            commas[1] = new Comma(this, new int[] { 2, 15, 0 });
            pumps[1]  = new Pump(commas[1]);
            commas[2] = new Comma(this, new int[] { 6, -14, 0 });
            pumps[2]  = new Pump(commas[2], new int[]
                                 { 0, 80, 42, 73, 35, 66, 28, 59, 21, 101, 14, 94, 7, 87 });
            commas[3] = new Comma(this, new int[] { 14, -13, 0 });

            int[] pkp = new int[14];
            for (int i = 0; i < 14; i++)
            {
                pkp[i] = ((14 + i) * 31) % 118;
            }

            pumps[3] = new Pump(commas[3], pkp);
            //new int[]
            //{0, 31, 62, 93, 6, 37, 68, 99, 12, 43, 74, 105, 18, 49 });

            //PumpStructure a118 = new PumpStructureSimple(this, 1);
            //PumpStructure b118 = new PumpStructureBig(this, 2);
            //pumpStructure = new PumpStructureSum(this, a118, b118);
            pumpStructure = new PumpStructureRandom(this);

            /*
             * for (int i = 0; i < edo; i++)
             * {
             *  scale[i] = false;
             * }
             * for (int i = 0; i < 17; i++)
             * {
             *  scale[(69 * i) % edo] = true;
             * }
             */

            /*
             * for (int i = 0; i < 42; i++)
             * {
             *  scale[(31 * i) % edo] = true;
             * }
             */

            /*
             * scale = new bool[59];
             * for (int i = 0; i < 17; i++)
             * {
             *  scale[(7 * i) % 59] = true;
             * }
             */
            /*
             * scale[0] = true;
             * scale[6] = true;
             * scale[12] = true;
             * scale[18] = true;
             * scale[25] = true;
             */

            dichotomy         = new bool[2, edo];
            dichotomy[0, 0]   = true;
            dichotomy[0, 69]  = true;
            dichotomy[0, 49]  = true;
            dichotomy[0, 38]  = true;
            dichotomy[0, 80]  = true;
            dichotomy[0, 31]  = true;
            dichotomy[0, 87]  = true;
            dichotomy[0, 18]  = true;
            dichotomy[0, 100] = true;
            dichotomy[0, 20]  = true;
            dichotomy[0, 98]  = true;

            dichotomy[1, 0]  = true;
            dichotomy[1, 69] = true;
            dichotomy[1, 49] = true;
        }
Exemple #10
0
        public FactoryEDO34(Type_Map map, bool[] pinc) : base(34, map, pinc)
        {
            commas    = new Comma[3];
            pumps     = new Pump[4];
            commas[0] = new Comma(this, new int[] { 4, 2, 0 });
            pumps[0]  = new Pump(commas[0], new int[] { 23, 9, 20, 6, 26, 3 });
            commas[1] = new Comma(this, new int[] { 5, -6, 0 });
            pumps[1]  = new Pump(commas[1]);
            pumps[2]  = new Pump(commas[0], new int[] { 0, 20, 6, 17, 3, 23 });

            int[] path = new int[9];
            for (int i = 0; i < 9; i++)
            {
                path[i] = (10 + i * 11) % 34;
            }
            commas[2]     = new Comma(this, new int[] { -1, 8, 0 });
            pumps[3]      = new Pump(commas[0], path);
            pumpStructure = new PumpStructureRandom(this);

            /*
             * for (int i = 0; i < edo; i++)
             * {
             *  scale[i] = false;
             * }
             *
             * for(int i = 0; i<19; i++)
             * {
             *  scale[(i * 11) % edo] = true;
             * }
             */
            /*
             * scale[0] = true;
             * scale[3] = true;
             * scale[6] = true;
             * scale[17] = true;
             * scale[20] = true;
             * scale[23] = true;
             */

            /*
             * scale = new bool[17];
             * for (int i = 0; i < 6; i++)
             * {
             *  scale[(20 * i) % 17] = true;
             * }
             */

            dichotomy        = new bool[1, edo];
            dichotomy[0, 0]  = true;
            dichotomy[0, 9]  = true;
            dichotomy[0, 25] = true;
            dichotomy[0, 11] = true;
            dichotomy[0, 23] = true;
            dichotomy[0, 14] = true;
            dichotomy[0, 20] = true;
            // dichotomy[0, 31] = true;
            // dichotomy[0, 3] = true;
            dichotomy[0, 28] = true;
            dichotomy[0, 6]  = true;
            dichotomy[0, 29] = true;
            dichotomy[0, 5]  = true;
        }
Exemple #11
0
        public FactoryEDO31(Type_Map map, bool[] pinc) : base(31, map, pinc)
        {
            commas = new Comma[11];
            pumps  = new Pump[11];


            commas[0] = new Comma(this, new int[] { 0, 5, -2 });
            pumps[0]  = new Pump(commas[0], new int[]
                                 { 9, 3, 24, 14, 4, 25, 19 });
            commas[1] = new Comma(this, new int[] { 4, -1, 0 });
            pumps[1]  = new Pump(commas[1]);
            commas[2] = new Comma(this, new int[] { 3, 7, 0 });
            pumps[2]  = new Pump(commas[2]);
            commas[3] = new Comma(this, new int[] { 1, 0, 3 });
            pumps[3]  = new Pump(commas[3]);
            commas[4] = new Comma(this, new int[] { 2, 2, -1 });
            pumps[4]  = new Pump(commas[4], new int[] { 0, 18, 28, 15, 25 });
            commas[5] = new Comma(this, new int[] { 3, 1, -2, -1 });
            pumps[5]  = new Pump(commas[5]);
            commas[6] = new Comma(this, new int[] { 4, -3, -1, 1 });
            pumps[6]  = new Pump(commas[6]);
            commas[7] = new Comma(this, new int[] { 2, -3, 1 });
            pumps[7]  = new Pump(commas[7], new int[] { 0, 8, 16, 24 });
            commas[8] = new Comma(this, new int[] { 3, 4, -5 });
            pumps[8]  = new Pump(commas[8]);
            commas[9] = new Comma(this, new int[] { -1, 8, 0 });
            pumps[9]  = new Pump(commas[9]);
            // , new int[] {0, 18, 8, 29, 19, 6, 27, 17, 30, 20, 10 });

            commas[10] = new Comma(this, new int[] { 1, 5, 1 });
            pumps[10]  = new Pump(commas[9], new int[] { 0, 21, 11, 1, 14, 4, 25 });
            //PumpStructure a = new PumpStructureSimple(this, 1);
            //PumpStructure b = new PumpStructureBig(this, 9);
            pumpStructure = new PumpStructureRandom(this);


            for (int i = 0; i < edo; i++)
            {
                scale[i] = false;
            }

            for (int i = 0; i < 13; i++)
            {
                scale[(10 * i) % edo] = true;
            }


            build_dichotomy(9);

            dichotomy = new bool[4][];
            for (int i = 0; i < 4; i++)
            {
                dichotomy[i] = new bool[edo];
            }
            dichotomy[0][0]  = true;
            dichotomy[0][18] = true;
            dichotomy[0][13] = true;
            dichotomy[0][8]  = true;
            dichotomy[0][23] = true;
            dichotomy[0][10] = true;
            dichotomy[0][21] = true;
            dichotomy[0][5]  = true;
            dichotomy[0][26] = true;


            dichotomy[0][15] = true;
            dichotomy[0][16] = true;
            dichotomy[0][25] = true;
            dichotomy[0][6]  = true;
            dichotomy[0][24] = true;
            dichotomy[0][7]  = true;


            dichotomy[1][0]  = true;
            dichotomy[1][6]  = true;
            dichotomy[1][25] = true;
            dichotomy[1][18] = true;
            dichotomy[1][12] = true;
            dichotomy[1][19] = true;

            dichotomy[2][0]  = true;
            dichotomy[2][6]  = true;
            dichotomy[2][25] = true;
            dichotomy[2][10] = true;
            dichotomy[2][4]  = true;
            dichotomy[2][27] = true;

            dichotomy[3][0]  = true;
            dichotomy[3][18] = true;
            dichotomy[3][13] = true;

            /*
             * dichotomy[3][22] = true;
             * dichotomy[3][7] = true;
             * dichotomy[3][11] = true;
             * dichotomy[3][27] = true;
             * dichotomy[3][2] = true;
             * dichotomy[3][6] = true;
             *
             * dichotomy[4][30] = true;
             * dichotomy[4][1] = true;
             * dichotomy[4][17] = true;
             * dichotomy[4][19] = true;
             * dichotomy[4][12] = true;
             * dichotomy[4][28] = true;
             */

            /*
             * dichotomy[8] = true;
             *
             * dichotomy[15] = true;
             *
             * dichotomy[27] = true;
             * dichotomy[29] = true;
             * dichotomy[20] = true;
             * dichotomy[25] = true;
             * dichotomy[19] = true;
             */


            /*
             * for (int i = 0; i < 12; i++)
             * {
             *  scale[(18 * i) % edo] = true;
             * }
             */

            /*
             * scale = new bool[4];
             * for(int i=0; i<2; i++)
             * {
             *  scale[(1*i) % scale.Length] = true;
             * }
             */

            /*
             * scale = new bool[18];
             * scale[0] = true;
             * scale[5] = true;
             * scale[10] = true;
             * scale[13] = true;
             */
        }
Exemple #12
0
        public FactoryEDO27(Type_Map map, bool[] pinc) : base(27, map, pinc)
        {
            commas    = new Comma[6];
            pumps     = new Pump[6];
            commas[0] = new Comma(this, new int[] { 2, -3, 1 });
            pumps[0]  = new Pump(commas[0], new int[]
                                 { 14, 21, 1 });
            commas[1] = new Comma(this, new int[] { 5, -1, -2 });
            pumps[1]  = new Pump(commas[1]);
            commas[2] = new Comma(this, new int[] { 0, -3, 0 });
            pumps[2]  = new Pump(commas[2]);
            commas[3] = new Comma(this, new int[] { 9, -1 });
            pumps[3]  = new Pump(commas[3], new int[]
                                 { 9, 20, 4, 15, 26, 10, 21, 5, 16, 0 });
            commas[4] = new Comma(this, new int[] { -1, 5, -5 });
            pumps[4]  = new Pump(commas[4], new int[]
                                 { 0, 13, 26, 12, 25, 11 });
            commas[5] = new Comma(this, new int[] { -2, 0, -1 });
            pumps[5]  = new Pump(commas[5], new int[]
                                 { 0, 11, 22 });

            //pumpStructure = new PumpStructureSimple(tpumps[3] = new Pump(commas[3], new int[]
            pumpStructure = new PumpStructureSimple(this, 3);
            //PumpStructure b27 = new PumpStructureBig(this, 5);

            //pumpStructure = new PumpStructureSum(this, a27, b27);


            for (int i = 0; i < edo; i++)
            {
                scale[i] = false;
            }

            /*
             * scale[0] = true;
             * scale[2] = true;
             * scale[9] = true;
             * scale[11] = true;
             * //scale[16] = true;
             * scale[18] = true;
             * //scale[22] = true;
             * scale[20] = true;
             */


            for (int i = 0; i < 17; i++)
            {
                scale[(6 + 16 * i) % edo] = true;
            }


            dichotomy = new bool[1, edo];

            dichotomy[0, 0]  = true;
            dichotomy[0, 11] = true;
            dichotomy[0, 16] = true;
            dichotomy[0, 9]  = true;
            dichotomy[0, 18] = true;
            dichotomy[0, 20] = true;
            dichotomy[0, 7]  = true;
        }
Exemple #13
0
        public FactoryEDO19(Type_Map map, bool[] pinc) : base(19, map, pinc)
        {
            commas    = new Comma[3];
            pumps     = new Pump[3];
            commas[0] = new Comma(this, new int[] { 4, -1, 0 });
            pumps[0]  = new Pump(commas[0]);
            commas[1] = new Comma(this, new int[] { 1, -5, 0 });
            pumps[1]  = new Pump(commas[1], new int[]
                                 { 5, 18, 10, 4, 17, 11 });
            commas[2] = new Comma(this, new int[] { 3, 4 });
            pumps[2]  = new Pump(commas[1], new int[]
                                 { 0, 6, 12, 4, 10, 2, 8 });
            pumpStructure = new PumpStructureRandom(this);

            /*
             * pumpStructure = new PumpStructureArray(this, new int[,]
             *  {{12,  0, 10,  8,  6,  4,  2, 14, 16 },
             *   {8,  16, 14,  2, 10, 12,  0,  6,  4 },
             *   {4,   2,  6,  0, 14, 16, 10, 12,  8 },
             *   {16, 14,  4, 12,  2,  0,  6,  8, 10 },
             *   {2,   6,  8, 14,  4, 10, 12, 16,  0 },
             *   {10, 12,  0,  6, 16,  8, 14,  4,  2 },
             *   {14, 10, 12,  4,  8,  2, 16,  0,  6},
             *   {6,   4,  2, 16,  0, 14,  8, 10, 12 },
             *   {0,   8, 16, 10, 12,  6,  4,  2, 14 } });
             */

            /*
             * for (int i = 0; i < edo; i++)
             * {
             *  scale[i] = false;
             * }
             *
             * for (int i = 0; i < 10; i++)
             * {
             *  scale[(2 * i) % edo] = true;
             * }
             */

            dichotomy        = new bool[1, edo];
            dichotomy[0, 0]  = true;
            dichotomy[0, 8]  = true;
            dichotomy[0, 11] = true;
            dichotomy[0, 6]  = true;
            dichotomy[0, 13] = true;
            dichotomy[0, 5]  = true;
            dichotomy[0, 14] = true;
            dichotomy[0, 3]  = true;
            dichotomy[0, 16] = true;


            diatonic = new bool[19];
            for (int i = 0; i < 7; i++)
            {
                diatonic[(11 * i) % 19] = true;
            }


            chromatic = new bool[19];
            for (int i = 0; i < 12; i++)
            {
                chromatic[(11 * i) % 19] = true;
            }


            negri = new bool[19];
            for (int i = 0; i < 10; i++)
            {
                negri[(2 * i) % 19] = true;
            }
        }
Exemple #14
0
        public FactoryEDO171(Type_Map map, bool[] pinc) : base(171, map, pinc)
        {
            build_dichotomy2(9);

            commas = new Comma[10];
            pumps  = new Pump[10];

            //comma3[0] = 19;
            //comma5[0] = -19;
            //comma7[0] = 0;
            commas[0] = new Comma(this, new int[] { 1, 2, -4 });
            pumps[0]  = new Pump(commas[0]
                                 //  , new int[]
                                 //{0, 33, 66, 99, 154, 38, 71 }
                                 );
            commas[1] = new Comma(this, new int[] { 0, 3, 5 });
            pumps[1]  = new Pump(commas[1], new int[]
                                 { 0, 33, 66, 99, 44, 77, 22, 55 });
            //{44, 66, 88, 110, 132, 154, 5, 27, 49, 71, 93, 115 });
            commas[2] = new Comma(this, new int[] { 7, -4, -1 });

            int ofs = 26 * 36;

            pumps[2] = new Pump(commas[2], new int[]
                                { 66, 111, 40, 85, 130, 59, 104, 33 });
            //{33, 133, 78, 7, 123, 52, 168, 97, 42, 142, 71, 0 });
            //{ 129, 74, 3, 103, 48, 148, 77, 22, 122, 67, 167, 96});


            /*
             *  {
             *      (0+ofs)%edo,
             *      (126+ofs)%edo,
             *      (26+ofs)%edo,
             *      (152+ofs)%edo,
             *      (52+ofs)%edo,
             *      (7+ofs)%edo,
             *      (78+ofs)%edo,
             *      (33+ofs)%edo,
             *  });
             */
            commas[3] = new Comma(this, new int[] { 9, 0, -9 });
            pumps[3]  = new Pump(commas[3]);
            commas[4] = new Comma(this, new int[] { -8, -1, 0 });
            pumps[4]  = new Pump(commas[4], new int[]
                                 { 90, 19, 119, 48, 148, 77, 6, 106, 35 });


            commas[5] = new Comma(this, new int[] { -2, -7, 3 });
            pumps[5]  = new Pump(commas[5], new int[]
                                 { 0, 55, 88, 143, 27, 127, 11, 44, 99, 154, 83, 116 });

            commas[6] = new Comma(this, new int[] { 1, 5, 1 });
            pumps[6]  = new Pump(commas[6]
                                 //,  new int[]
                                 //{110, 165, 49, 104, 159, 43}
                                 // { 0, 116, 61, 132, 77, 22, 138}
                                 //{129, 74, 19, 135, 35, 151, 96 }
                                 );

            commas[7] = new Comma(this, new int[] { 36, -12, 1 });
            pumps[7]  = new Pump(commas[7], new int[]
                                 { 74, 148, 51, 125, 28, 102, 5, 79, 153, 56, 130, 33, 107 });

            /*
             * commas[8] = new Comma(this, new int[] { 0, 6, 10 });
             * pumps[8] = new Pump(commas[8], new int[]
             *  {110, 121, 132, 143, 154, 165});
             */

            commas[9] = new Comma(this, new int[] { -1, 1, 9 });
            pumps[9]  = new Pump(commas[9], new int[]
                                 { 66, 99, 132, 165, 27, 60, 93, 126, 159, 21 });

            PumpStructure a171 = new PumpStructureBig(this, 0);
            PumpStructure b171 = new PumpStructureSimple(this, 6);

            pumpStructure = new PumpStructureSimple(this, 2);
            //pumpStructure = new PumpStructureTwo(this, 0, 6);


            scale = new bool[19];
            for (int i = 0; i < 8; i++)
            {
                scale[(7 * i) % scale.Length] = true;
            }


            /*
             * for (int i = 0; i < edo; i++)
             * {
             *  scale[i] = false;
             * }
             * for (int i = 0; i < 47; i++)
             * {
             *  scale[(11 * i) % scale.Length] = true;
             * }
             */
            /*
             * scale[0] = true;
             * scale[6] = true;
             * scale[16] = true;
             * scale[22] = true;
             * scale[32] = true;
             * scale[38] = true;
             * scale[55] = true;
             * scale[61] = true;
             * scale[71] = true;
             * scale[77] = true;
             * scale[87] = true;
             * scale[93] = true;
             * scale[99] = true;
             * scale[116] = true;
             * scale[122] = true;
             * scale[132] = true;
             * scale[138] = true;
             * scale[148] = true;
             * scale[154] = true;
             */
            /*
             * for (int i = 0; i < 53; i++)
             * {
             *  scale[(100 * i) % edo] = true;
             * }
             */

            /*
             * scale[0] = true;
             * scale[11] = true;
             * scale[22] = true;
             * scale[27] = true;
             * scale[44] = true;
             * scale[55] = true;
             * scale[66] = true;
             * scale[83] = true;
             * scale[88] = true;
             * scale[99] = true;
             * scale[116] = true;
             * scale[127] = true;
             * scale[138] = true;
             * scale[143] = true;
             * scale[154] = true;
             */
        }
Exemple #15
0
        public FactoryEDO53(Type_Map map, bool[] pinc) : base(53, map, pinc)
        {
            commas    = new Comma[5];
            pumps     = new Pump[6];
            commas[0] = new Comma(this, new int[] { 5, -6, 0 });
            int[] path = new int[6];
            for (int i = 0; i < 6; i++)
            {
                path[i] = (i * 14 + 56) % edo;
            }

            pumps[0] = new Pump(commas[0]);


            commas[1] = new Comma(this, new int[] { 8, 1, 0 });
            pumps[1]  = new Pump(commas[1],
                                 new int[] { 9, 40, 18, 49, 27, 5, 36, 14, 45 });
            commas[2] = new Comma(this, new int[] { 3, 7, 0 });
            pumps[2]  = new Pump(commas[2]);

            commas[3] = new Comma(this, new int[] { -2, -2, 1 });
            pumps[3]  = new Pump(commas[3],
                                 new int[] { 0, 31, 48, 26, 43 });
            pumps[4] = new Pump(commas[3],
                                new int[] { 36, 14, 24, 2, 19 });

            commas[4] = new Comma(this, new int[] { 1, 1, 0, 0, 3 });
            pumps[5]  = new Pump(commas[4]);


            pumpStructure = new PumpStructureRandom(this);
            //PumpStructure b53 = new PumpStructureBig(this, 2);
            //pumpStructure = new PumpStructureSum(this, a53, b53);

            hanson   = new bool[53];
            diatonic = new bool[53];

            diatonic[0]  = true;
            diatonic[9]  = true;
            diatonic[17] = true;
            diatonic[22] = true;
            diatonic[31] = true;
            diatonic[40] = true;
            diatonic[48] = true;

            for (int i = 0; i < 19; i++)
            {
                hanson[(i * 14) % 53] = true;
            }


            /*
             * scale = new bool[14];
             * scale[0] = true;
             * scale[3] = true;
             * scale[11] = true;
             */

            /*
             * for (int i = 0; i < edo; i++)
             * {
             *  scale[i] = false;
             * }
             */

            schismatic = new bool[53];
            for (int i = 0; i < 17; i++)
            {
                schismatic[(31 * i) % edo] = true;
            }

            amity = new bool[53];
            for (int i = 0; i < 18; i++)
            {
                amity[(15 * i) % edo] = true;
            }

            dichotomy        = new bool[3, edo];
            dichotomy[0, 0]  = true;
            dichotomy[0, 31] = true;
            dichotomy[0, 22] = true;
            dichotomy[0, 14] = true;
            dichotomy[0, 39] = true;
            dichotomy[0, 17] = true;
            dichotomy[0, 36] = true;
            dichotomy[0, 9]  = true;
            dichotomy[0, 44] = true;

            /*
             * dichotomy[0, 10] = true;
             * dichotomy[0, 43] = true;
             * dichotomy[0, 26] = true;
             * dichotomy[0, 27] = true;
             * dichotomy[0, 12] = true;
             * dichotomy[0, 41] = true;
             */

            //dichotomy[0, 48] = true;
            //dichotomy[0, 5] = true;
            //dichotomy[0, 44] = true;
            //dichotomy[0, 9] = true;

            dichotomy[1, 0]  = true;
            dichotomy[1, 14] = true;
            dichotomy[1, 17] = true;
            dichotomy[1, 39] = true;
            dichotomy[1, 36] = true;
            dichotomy[1, 48] = true;
            dichotomy[1, 5]  = true;

            dichotomy[2, 0]  = true;
            dichotomy[2, 22] = true;
            dichotomy[2, 31] = true;
        }