Ejemplo n.º 1
0
 public static IAutomat[] GenerateRandomAutomats(int count) {
     var retAut = new List<IAutomat>();
     for (int i = 0; i < count; i++) {
         retAut.Add(DFA.GenerateRandom());
         retAut.Add(NFA.GenerateRandom());
         retAut.Add(NFAe.GenerateRandom());
         retAut.Add(StatePDA.GenerateRandom());
         retAut.Add(StackPDA.GenerateRandom());
         retAut.Add(DPDA.GenerateRandom());
         retAut.Add(TuringMachineSingleBand.GenerateRandom());
         retAut.Add(TuringMachineSingleBand1659.GenerateRandom());
         retAut.Add(TuringMachineMultiTrack.GenerateRandom());
         retAut.Add(NTM1659.GenerateRandom());
     }
     return retAut.ToArray();
 }
Ejemplo n.º 2
0
        public static IAcceptWord[][] CastToEveryPossibility(IEnumerable<IAcceptWord> automats) {
            var retAutomats = new List<IAcceptWord[]>();

            foreach (IAcceptWord automat in automats) {
                var ret1Automat = new List<IAcceptWord>();
                if (automat is DFA D) {
                    ret1Automat.Add(D);

                    NFA NfromD = (NFA)D;
                    ret1Automat.Add(NfromD);

                    NFAe NEfromD = (NFAe)D;
                    ret1Automat.Add(NEfromD);

                    NFAe NEfromN = (NFAe)NfromD;
                    ret1Automat.Add(NEfromN);

                    ReGrammer RGfromD = (ReGrammer)D;
                    // ret1Automat.Add((NFAe)RGfromD);

                    CFGrammer CFGfromD = (CFGrammer)RGfromD;
                    CFGrammer CFGCNF = (CFGrammer)RGfromD;
                    // ret1Automat.Add(CFGCNF);

                    StatePDA QPDAfromNe = (StatePDA)NEfromD;
                    ret1Automat.Add(QPDAfromNe);

                    StackPDA SPDAFromQPDA = (StackPDA)QPDAfromNe;
                    // ret1Automat.Add(SPDAFromQPDA);

                    try {
                        DPDA DPDAFromD = (DPDA)D;
                        ret1Automat.Add(DPDAFromD);
                    } catch { }

                    TuringMachineSingleBand TMfromD = (TuringMachineSingleBand)D;
                    ret1Automat.Add(TMfromD);

                } else if (automat is NFA N) {
                    ret1Automat.Add(N);

                    DFA DfromN = DFA.Nea2TeilmengenDea(N);
                    ret1Automat.Add(DfromN);

                    NFAe NEfromD = (NFAe)DfromN;
                    ret1Automat.Add(NEfromD);

                    NFAe NEfromN = (NFAe)N;
                    ret1Automat.Add(NEfromN);

                    StatePDA QPDAfromNe = (StatePDA)NEfromD;
                    ret1Automat.Add(QPDAfromNe);

                    StackPDA SPDAFromQPDA = (StackPDA)QPDAfromNe;
                    ret1Automat.Add(SPDAFromQPDA);

                    try {
                        DPDA DPDAFromD = (DPDA)DfromN;
                        ret1Automat.Add(DPDAFromD);
                    } catch { }

                    TuringMachineSingleBand TMfromD = (TuringMachineSingleBand)DfromN;
                    ret1Automat.Add(TMfromD);

                } else if (automat is NFAe Ne) {
                    ret1Automat.Add(Ne);

                    DFA DfromNe = DFA.Nea2TeilmengenDea(Ne);
                    ret1Automat.Add(DfromNe);

                    // NFA NfromD = (NFAe)DfromNe;

                    StatePDA QPDAfromNe = (StatePDA)Ne;
                    ret1Automat.Add(QPDAfromNe);

                    StackPDA SPDAFromQPDA = (StackPDA)QPDAfromNe;
                    ret1Automat.Add(SPDAFromQPDA);

                    try {
                        DPDA DPDAFromD = (DPDA)DfromNe;
                        ret1Automat.Add(DPDAFromD);
                    } catch { }


                    TuringMachineSingleBand TMfromD = (TuringMachineSingleBand)DfromNe;
                    ret1Automat.Add(TMfromD);

                } else if (automat is StatePDA QPDA) {
                    ret1Automat.Add(QPDA);

                    try {
                        var SPDAfromQPDA = (StackPDA)QPDA;
                        ret1Automat.Add(SPDAfromQPDA);

                        // NTM1659 NTMfromQPDA = (NTM1659)QPDA;
                        // ret1Automat.Add(NTMfromQPDA);
                    } catch { }
                } else if (automat is StackPDA SPDA) {
                    var QPDAfromSPDA = (StackPDA)SPDA;

                    ret1Automat.Add(SPDA);
                    ret1Automat.Add(QPDAfromSPDA);
                } else if (automat is DPDA dpda) {
                    var QPDAfromDPDA = (StatePDA)dpda;

                    ret1Automat.Add(dpda);
                    ret1Automat.Add(QPDAfromDPDA);
                } else if (automat is TuringMachineSingleBand tm1) {
                    ret1Automat.Add(tm1);
                } else {
                    ret1Automat.Add(automat);
                }

                if (automat is IReverse Arev) {
                    ret1Automat.Add((IReverse)((IReverse)Arev.Reverse()).Reverse());
                }

                retAutomats.Add(ret1Automat.ToArray());
            }

            return retAutomats.ToArray();
        }