Package eas.simulation.spatial.sim2D.marbSimulation.endlAutomat

Examples of eas.simulation.spatial.sim2D.marbSimulation.endlAutomat.Transition


     * @param simZyk  Der Simulationszyklus.
     */
    @Override
    public void step(final Wink simZyk) {
        LinkedList<Transition> bedingungen;
        Transition aktBed;
        int aktion;
        int parameter;
        ZInfo zusatz;
        int folgeZ = 0;
        Iterator<Transition> it;
        int i = 0;
       
        while (i < this.conds.length) {
            if (this.conds[i].evaluiere(this)) {
                if (this.initial || i != this.aktAut) {
                    this.aktAut = i;
                    this.vAut[this.aktAut].setzeChanged();
                    this.vAut[this.aktAut].notifyObservers(
                            new Integer(this.aktAut));
                    this.initial = false;
                }
                break;
            }
            i++;
        }
       
        this.expAktZyklen++;
        this.fitAktZyklen[this.aktAut]++;
        this.fitRedAktZyklen[this.aktAut]++;
        this.aktivZyklen[this.aktAut]++;
        this.mutAktZyklen++;
       
        if (this.fitRedAktZyklen[this.aktAut] > this.fitRedZyklen) {
            this.setFitness(this.aktAut,
                            (int) (this.getFitness()[this.aktAut]
                                    / this.fitRedWert));
            this.fitRedAktZyklen[this.aktAut] = 0;
        }
       
        if (simZyk.getLastTick() % this.fitZyklen == 0) {
            this.befehle.clear();
            this.befehle.add(new Integer(this.lastBf));

            this.setFitness(this.aktAut,
                            this.getFitness()[this.aktAut]
                            + this.fitVs[this.aktAut].fitness(
                                    (RobEA) this));
        }

        if (this.umg.existsPlugin(new EvolutionPluginCompletelyEvolvable().id())) {
            if (this.mutAktZyklen > this.mutZyklen) {
                this.mutV = true;
                this.mutiere();
                this.mutAktZyklen = 0;
                this.mutV = false;
                GlobaleMARBVariablen.setVMutationInLetztemZyklus(true);
            } else {
                this.mutV = false;
                GlobaleMARBVariablen.setVMutationInLetztemZyklus(false);
            }
           
            // Mutieren der Bedingungen deaktiviert.
            // if (this.condMutAktZyklen >
            // this.pars.getParWertLong().getCondMutZyk()) {
            // this.mutiereBeds();
            // this.condMutAktZyklen = 0;
            // }
        }
       
        if (this.aktZustand[this.aktAut] == null) {
            this.aktZustand[this.aktAut]
                            = this.vAut[this.aktAut].holeStartzustand();
        }

        if (this.isSelektiert()) {
            if (this.aktZustand[this.aktAut] != null) {
                this.vAut[this.aktAut].setzeChanged();
                this.vAut[this.aktAut].notifyObservers(
                        this.aktZustand[this.aktAut]);
            }
        }

        if (this.aktZustand[this.aktAut] != null) {
            zusatz = this.aktZustand[this.aktAut].getInfo();
            aktion = zusatz.getAktion();
            parameter = zusatz.getParam();

            this.gesamtAktion(aktion, parameter);
           
            this.lastBf = aktion;
           
            bedingungen = zusatz.getBeds();
            it = bedingungen.iterator();
            this.aktZustand[this.aktAut] = null;
            while (it.hasNext() && folgeZ == 0) {
                aktBed = it.next();
                if (aktBed.evaluiere(this)) {
                    folgeZ = aktBed.getFolgezustand();
                    this.aktZustand[this.aktAut]
                        = this.vAut[this.aktAut].holeKnoten(
                                new Integer(folgeZ));
                }
            }
View Full Code Here


        Condition zwischBed;
        int numOrig1, numOrig2;
        int idlBefehl;
        EndlicherAutomat[] endAs = new EndlicherAutomat[endAuts.length];
        LinkedList<Transition> trans;
        Transition tran;
        String[] args = {"log 4"};
       
        if (conds == null
                || endAuts.length != conds.length
                || endAuts.length == 0) {
            ParCollection parColl = GlobalVariables.getPrematureParameters();
            parColl.overwriteParameterList(args);
            StaticMethods.log(StaticMethods.LOG_ERROR,
                          "Gesamtautomat konnte nicht erzeugt werden.",
                          parColl);
        }
       
        for (int i = 0; i < endAs.length; i++) {
            endAs[i] = new EndlicherAutomat();
           
            if (params.getParValueBoolean("UseTranslatorWITHCompletingTransitions")) {
                endAs[i].generateFromSequence(
                        endAuts[i].erzeugeStringSeq(),
                        eas.simulation.spatial.sim2D.marbSimulation.translator.ConstantsTranslator.getStdTranslatorBE(params),
                        false, params);
            } else {
                endAs[i].generateFromSequence(
                        endAuts[i].erzeugeStringSeq(),
                        ConstantsTranslatorWOC.getStdTranslatorBE(params),
                        false, params);
            }
           
            if (endAs[i].istLeer()) {
                endAs[i].einfuegenKnoten(Integer.MAX_VALUE,
                        StaticMethods.posSuch(
                                eas.simulation.ConstantsSimulation.getBefehlNamenArray(params),
                                "stp"),
                        1,
                        1);
               
                endAs[i].setStart(endAs[i].holeKnoten(Integer.MAX_VALUE));
            }
        }
       
        // Neue Knoten zuordnen.
        for (int i = 0; i < endAs.length; i++) {
            knotZuord[i] = new HashMap<Integer, Integer>();
           
            knot = new ArrayList<Integer>(endAs[i].holAdj().keySet());
            it = knot.iterator();

            while (it.hasNext()) {
                aktKnNum = it.next();
                aktKn = endAs[i].holeKnoten(aktKnNum);
                info = aktKn.getInfo();
                neu.einfuegenKnoten(lfdNr,
                                    info.getAktion(),
                                    info.getParam(),
                                    info.getAlter());
               
                knotZuord[i].put(aktKnNum, lfdNr);
                lfdNr++;
            }
        }
       
        // Neue Kanten INTER Automaten zuordnen.
        for (int i = 0; i < endAs.length; i++) {
            zielKn = endAs[i].holeStartzustand();
           
            if (zielKn != null) {
                zielKnNum = (Integer) knotZuord[i].get(zielKn.holeName());
                neuBed = StaticMethods.ausFormatBed(conds[i].formatted());
                for (int j = 0; j < i; j++) {
                    zwischBed = StaticMethods.ausFormatBed(conds[j].formatted());
                    zwischBed.negiere();
                    neuBed = new InnerNode(neuBed,
                                           zwischBed,
                                           eas.simulation.spatial.sim2D.marbSimulation.Konstanten.UND);
                }
               
                for (int j = 0; j < endAs.length; j++) {
                    if (j != i) {
                        knot = new ArrayList<Integer>(
                                endAs[j].holAdj().keySet());
                        it = knot.iterator();
                       
                        while (it.hasNext()) {
                            aktKnNum = (Integer) knotZuord[j].get(it.next());
                            neu.einfuegKante(aktKnNum, zielKnNum, neuBed, 1);
                        }
                    }
                }
            }
        }

        // Neue Kanten INTRA Automaten zuordnen.
        for (int i = 0; i < endAs.length; i++) {
            knot1 = new ArrayList<Integer>(endAs[i].holAdj().keySet());
            it1 = knot1.iterator();
           
            while (it1.hasNext()) {
                numOrig1 = it1.next();
                aktKnNum = (Integer) knotZuord[i].get(numOrig1);
                aktKn = endAs[i].holeKnoten(numOrig1);
               
                if (aktKn.getInfo() != null
                        && aktKn.getInfo().getBedingungen() != null) {
                    trans = aktKn.getInfo().getBedingungen();
                    it3 = trans.iterator();
                   
                    while (it3.hasNext()) {
                        tran = it3.next();
                        numOrig2 = tran.getFolgezustand();
                        zielKnNum = (Integer) knotZuord[i].get(numOrig2);
                        aktBed = tran.getCond();
                       
                        if (aktBed != null) {
                            neu.einfuegKante(aktKnNum, zielKnNum, aktBed, 1);
                        }
                    }
View Full Code Here

        = new ArrayList<Integer>(alleBeds.keySet());
        LinkedList<Transition> aktBeds;
        Integer aktKnoten;
        Iterator<Transition> it;
        String aktBed;
        Transition vollstBed;
        Integer fZustand;
        int pruefIndex;

        while (alleKnoten.size() > 0) {
            pruefIndex = this.rand.nextInt(alleKnoten.size());
            aktKnoten = alleKnoten.get(pruefIndex);
            aktBeds = alleBeds.get(aktKnoten);

            it = aktBeds.iterator();
            while (it.hasNext()) {
                vollstBed = it.next();
                aktBed = vollstBed.getCond().formatted();
                if (aktBed.charAt(1) == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.FALSE) {
                    fZustand = new Integer(vollstBed.getFolgezustand());

                    ea.entferneKante(aktKnoten, fZustand, vollstBed);
                    return true;
                }
            }
View Full Code Here

     * @param ea  Der zu mutierende Automat.
     * @return  Ob eine Bedingung mutiert wurde.
     */
    public final boolean ageSemMutBedA(final EndlicherAutomat ea) {
        ArrayList<Transition> bedingungen = ea.getBedListe();
        Transition aktBed;
        String aktString;
        String neuString = "";
        int pos;
        int zufallsindex;
        ArrayList<Character> zeichen = new ArrayList<Character>(2);
        zeichen.add(new Character(eas.simulation.spatial.sim2D.marbSimulation.Konstanten.FALSE));
        zeichen.add(new Character(eas.simulation.spatial.sim2D.marbSimulation.Konstanten.GL));
        zeichen.add(new Character(eas.simulation.spatial.sim2D.marbSimulation.Konstanten.UNGF));
        zeichen.add(new Character(eas.simulation.spatial.sim2D.marbSimulation.Konstanten.KLGL));
        zeichen.add(new Character(eas.simulation.spatial.sim2D.marbSimulation.Konstanten.GRGL));
        zeichen.add(new Character(eas.simulation.spatial.sim2D.marbSimulation.Konstanten.KL));
        zeichen.add(new Character(eas.simulation.spatial.sim2D.marbSimulation.Konstanten.GR));
        zeichen.add(new Character(eas.simulation.spatial.sim2D.marbSimulation.Konstanten.NUNGF));
        zeichen.add(new Character(eas.simulation.spatial.sim2D.marbSimulation.Konstanten.UGL));
        zeichen.add(new Character(eas.simulation.spatial.sim2D.marbSimulation.Konstanten.TRUE));
        boolean links = this.rand.nextBoolean();
        boolean oben = this.rand.nextBoolean();
        boolean var1 = this.rand.nextBoolean();
        boolean var2 = !var1 || this.rand.nextBoolean();
        String string1;
        String string2;

        if (bedingungen.size() > 0) {
            zufallsindex = this.rand.nextInt(bedingungen.size());
            aktBed = bedingungen.get(zufallsindex);
            aktString = aktBed.getCond().formatted();

            pos = this.indexZeichen(aktString,
                    zeichen);
            if (aktString.charAt(pos)
                    == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.FALSE) {
                if (var1) {
                    int variable1 = StaticMethods.glVertZwischen(
                            StaticMethods.minVar(this.modus),
                            StaticMethods.maxVar(this.modus),
                            this.rand);

                    string1 = " " 
                        + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.EING + " "
                        + eas.miscellaneous.StaticMethods.normZahl(variable1);
                } else {
                    int nummer1 = this.rand.nextInt(255) + 1;
                    string1 = eas.miscellaneous.StaticMethods.normZahl(nummer1);
                }

                if (var2) {
                    int variable2 = StaticMethods.glVertZwischen(
                            StaticMethods.minVar(this.modus),
                            StaticMethods.maxVar(this.modus),
                            this.rand);

                    string2 = " "
                        + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.EING + " "
                        + eas.miscellaneous.StaticMethods.normZahl(variable2);
                } else {
                    int nummer2 = this.rand.nextInt(255) + 1;
                    string2 = eas.miscellaneous.StaticMethods.normZahl(nummer2);
                }

                neuString = aktString.substring(0, pos - 1)
                + string1
                + " " + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.GL + " "
                + string2
                + aktString.substring(pos + 2);
            }

            if (aktString.charAt(pos) == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.GL) {
                if (links) {
                    int lGrenze;
                    int rGrenze;
                    if (pos >= 6 && aktString.charAt(pos - 6)
                            == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.EING) {
                        lGrenze = pos - 7;
                    } else {
                        lGrenze = pos - 4;
                    }
                    if (aktString.charAt(pos + 3)
                            == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.EING) {
                        rGrenze = pos + 8;
                    } else {
                        rGrenze = pos + 5;
                    }
                    neuString = aktString.substring(0, lGrenze)
                    + " " + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.FALSE + " "
                    + aktString.substring(rGrenze);
                } else {
                    neuString = aktString.substring(0, pos)
                    + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.UNGF
                    + aktString.substring(pos + 1);
                }
            }

            if (aktString.charAt(pos) == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.UNGF) {
                if (links) {
                    neuString = aktString.substring(0, pos)
                    + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.GL
                    + aktString.substring(pos + 1);
                } else {
                    if (oben) {
                        neuString = aktString.substring(0, pos)
                        + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.KLGL
                        + aktString.substring(pos + 1);
                    } else {
                        neuString = aktString.substring(0, pos)
                        + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.GRGL
                        + aktString.substring(pos + 1);
                    }
                }
            }

            if (aktString.charAt(pos) == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.KLGL) {
                if (links) {
                    neuString = aktString.substring(0, pos)
                    + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.UNGF
                    + aktString.substring(pos + 1);
                } else {
                    neuString = aktString.substring(0, pos)
                    + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.KL
                    + aktString.substring(pos + 1);
                }
            }

            if (aktString.charAt(pos) == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.GRGL) {
                if (links) {
                    neuString = aktString.substring(0, pos)
                    + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.UNGF
                    + aktString.substring(pos + 1);
                } else {
                    neuString = aktString.substring(0, pos)
                    + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.GR
                    + aktString.substring(pos + 1);
                }
            }

            if (aktString.charAt(pos) == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.KL) {
                if (links) {
                    neuString = aktString.substring(0, pos)
                    + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.KLGL
                    + aktString.substring(pos + 1);
                } else {
                    neuString = aktString.substring(0, pos)
                    + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.NUNGF
                    + aktString.substring(pos + 1);
                }
            }

            if (aktString.charAt(pos) == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.GR) {
                if (links) {
                    neuString = aktString.substring(0, pos)
                    + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.GRGL
                    + aktString.substring(pos + 1);
                } else {
                    neuString = aktString.substring(0, pos)
                    + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.NUNGF
                    + aktString.substring(pos + 1);
                }
            }

            if (aktString.charAt(pos)
                    == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.NUNGF) {
                if (links) {
                    if (oben) {
                        neuString = aktString.substring(0, pos)
                        + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.KL
                        + aktString.substring(pos + 1);
                    } else {
                        neuString = aktString.substring(0, pos)
                        + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.GR
                        + aktString.substring(pos + 1);
                    }
                } else {
                    neuString = aktString.substring(0, pos)
                    + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.UGL
                    + aktString.substring(pos + 1);
                }
            }

            if (aktString.charAt(pos) == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.UGL) {
                if (links) {
                    neuString = aktString.substring(0, pos)
                    + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.NUNGF
                    + aktString.substring(pos + 1);
                } else {
                    int lGrenze;
                    int rGrenze;
                    if (pos >= 6 && aktString.charAt(pos - 6)
                            == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.EING) {
                        lGrenze = pos - 7;
                    } else {
                        lGrenze = pos - 4;
                    }
                    if (aktString.charAt(pos + 3)
                            == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.EING) {
                        rGrenze = pos + 8;
                    } else {
                        rGrenze = pos + 5;
                    }
                    neuString = aktString.substring(0, lGrenze)
                    + " "
                    + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.TRUE
                    + " "
                    + aktString.substring(rGrenze);
                }
            }

            if (aktString.charAt(pos) == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.TRUE) {
                if (var1) {
                    int variable1 = StaticMethods.glVertZwischen(
                            StaticMethods.minVar(this.modus),
                            StaticMethods.maxVar(this.modus),
                            this.rand);

                    string1 = " "
                        + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.EING
                        + " "
                        + eas.miscellaneous.StaticMethods.normZahl(variable1);
                } else {
                    int nummer1 = this.rand.nextInt(255) + 1;
                    string1 = eas.miscellaneous.StaticMethods.normZahl(nummer1);
                }

                if (var2) {
                    int variable2 = StaticMethods.glVertZwischen(
                            StaticMethods.minVar(this.modus),
                            StaticMethods.maxVar(this.modus),
                            this.rand);

                    string2 = " "
                        + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.EING
                        + " "
                        + eas.miscellaneous.StaticMethods.normZahl(variable2);
                } else {
                    int nummer2 = this.rand.nextInt(255) + 1;
                    string2 = eas.miscellaneous.StaticMethods.normZahl(nummer2);
                }

                neuString = aktString.substring(0, pos - 1)
                + string1
                + " " + eas.simulation.spatial.sim2D.marbSimulation.Konstanten.UGL + " "
                + string2
                + aktString.substring(pos + 2);
            }
            if (checkMutation(aktBed.getAlter())) {
                aktBed.setBedingung(neuString);
                return true;
            }
        }

        return false;
View Full Code Here

     * @param ea  Der zu mutierende Automat.
     * @return  Ob eine Bedingung mutiert wurde.
     */
    public final boolean ageSynMutBedBeinfacher(final EndlicherAutomat ea) {
        ArrayList<Transition> bedingungen = ea.getBedListe();
        Transition aktBed;
        String aktString;
        String neuString;
        int posLKlammer;
        int posRKlammer;
        int pos;
        int zufallsindex;

        while (bedingungen.size() > 0) {
            zufallsindex = rand.nextInt(bedingungen.size());
            aktBed = bedingungen.get(zufallsindex);
            aktString = aktBed.getCond().formatted();

            pos = this.indexZeichenfolge(aktString,
                    eas.simulation.spatial.sim2D.marbSimulation.Konstanten.UND,
                    eas.simulation.spatial.sim2D.marbSimulation.Konstanten.TRUE);

            if (pos < 0) {
                pos = this.indexZeichenfolge(
                        aktString,
                        eas.simulation.spatial.sim2D.marbSimulation.Konstanten.ODER,
                        eas.simulation.spatial.sim2D.marbSimulation.Konstanten.FALSE);
            }

            if (pos >= 0) {
                posLKlammer = this.findeKlLinks(aktString, pos);
                posRKlammer = pos + 3;
                neuString = aktString.substring(0, posLKlammer - 1)
                + aktString.substring(posLKlammer + 2,
                        pos - 4)
                        + aktString.substring(posRKlammer + 2);

                aktBed.setBedingung(neuString);
                return true;
            }

            pos = this.indexZeichenfolge(
                    aktString,
                    eas.simulation.spatial.sim2D.marbSimulation.Konstanten.TRUE,
                    eas.simulation.spatial.sim2D.marbSimulation.Konstanten.UND);

            if (pos < 0) {
                pos = this.indexZeichenfolge(
                        aktString,
                        eas.simulation.spatial.sim2D.marbSimulation.Konstanten.FALSE,
                        eas.simulation.spatial.sim2D.marbSimulation.Konstanten.ODER);
            }

            if (pos >= 0) {
                posLKlammer = pos - 3;
                posRKlammer = this.findeKlRechts(aktString, pos);
                neuString = aktString.substring(0, pos - 7)
                + aktString.substring(pos + 2,
                        posRKlammer - 1)
                        + aktString.substring(posRKlammer + 2);
                aktBed.setBedingung(neuString);
                return true;
            }

            pos = this.indexZeichenfolge(aktString,
                    eas.simulation.spatial.sim2D.marbSimulation.Konstanten.ODER,
                    eas.simulation.spatial.sim2D.marbSimulation.Konstanten.TRUE);
            if (pos < 0) {
                pos = this.indexZeichenfolge(aktString,
                        eas.simulation.spatial.sim2D.marbSimulation.Konstanten.UND,
                        eas.simulation.spatial.sim2D.marbSimulation.Konstanten.FALSE);
            }

            if (pos >= 0) {
                posLKlammer = this.findeKlLinks(aktString, pos);
                posRKlammer = pos + 3;
                neuString = aktString.substring(0, posLKlammer - 1)
                + aktString.substring(pos - 1, pos + 2)
                + aktString.substring(posRKlammer + 2);
                aktBed.setBedingung(neuString);
                return true;
            }

            pos = this.indexZeichenfolge(aktString,
                    eas.simulation.spatial.sim2D.marbSimulation.Konstanten.TRUE,
                    eas.simulation.spatial.sim2D.marbSimulation.Konstanten.ODER);
            if (pos < 0) {
                pos = this.indexZeichenfolge(aktString,
                        eas.simulation.spatial.sim2D.marbSimulation.Konstanten.FALSE,
                        eas.simulation.spatial.sim2D.marbSimulation.Konstanten.UND);
            }

            if (pos >= 0) {
                posLKlammer = pos - 6;
                posRKlammer = this.findeKlRechts(aktString, pos);
                neuString = aktString.substring(0, posLKlammer - 1)
                + aktString.substring(pos - 4, pos - 1)
                + aktString.substring(posRKlammer + 2);
                aktBed.setBedingung(neuString);
                return true;
            }
            bedingungen.remove(zufallsindex);
        }

View Full Code Here

     */
    protected void naechsterZustand() {
        int aktion;
        int parameter;
        LinkedList<Transition> bedingungen;
        Transition aktBed;
        ZInfo zusatz;
        int folgeZ = 0;
        Iterator<Transition> it;
        int i = 0;
       
        while (i < this.conds.length) {
            if (this.conds[i].evaluiere(this)) {
                if (this.initial || i != this.aktAut) {
                    this.aktAut = i;
                    this.vAut[this.aktAut].setzeChanged();
                    this.vAut[this.aktAut].notifyObservers(
                            new Integer(this.aktAut));
                    this.initial = false;
                }
                break;
            }
            i++;
        }
       
        this.expAktZyklen++;
        this.fitAktZyklen[this.aktAut]++;
        this.fitRedAktZyklen[this.aktAut]++;
        this.aktivZyklen[this.aktAut]++;
        this.mutAktZyklen++;
       
        if (this.fitRedAktZyklen[this.aktAut] > this.fitRedZyklen) {
            this.setFitness(this.aktAut,
                            (int) (this.getFitness()[this.aktAut]
                                    / this.fitRedWert));
            this.fitRedAktZyklen[this.aktAut] = 0;
        }
       
        if (this.fitAktZyklen[this.aktAut] > this.fitZyklen) {
            this.befehle.clear();
            this.befehle.add(new Integer(this.lastBf));


            this.fitAktZyklen[this.aktAut] = 0;
        }

//        if (this.pars.getEvol().booleanValue()) {
        if (this.umg.getSimulation().isEvolution()) {
            if (this.mutAktZyklen > this.mutZyklen) {
                this.mutV = true;
                this.mutiere();
                this.mutAktZyklen = 0;
                this.mutV = false;
                GlobaleMARBVariablen.setVMutationInLetztemZyklus(true);
            } else {
                this.mutV = false;
                GlobaleMARBVariablen.setVMutationInLetztemZyklus(false);
            }
           
        }
       
        if (this.aktZustand[this.aktAut] == null) {
            this.aktZustand[this.aktAut]
                            = this.vAut[this.aktAut].holeStartzustand();
        }

        if (this.isSelektiert()) {
            if (this.aktZustand[this.aktAut] != null) {
                this.vAut[this.aktAut].setzeChanged();
                this.vAut[this.aktAut].notifyObservers(
                        this.aktZustand[this.aktAut]);
            }
        }

        if (this.aktZustand[this.aktAut] != null) {
            zusatz = this.aktZustand[this.aktAut].getInfo();
            aktion = zusatz.getAktion();
            parameter = zusatz.getParam();

            this.gesamtAktion(aktion, parameter);
           
            this.lastBf = aktion;
           
            bedingungen = zusatz.getBeds();
            it = bedingungen.iterator();
            this.aktZustand[this.aktAut] = null;
            while (it.hasNext() && folgeZ == 0) {
                aktBed = it.next();
                if (aktBed.evaluiere(this)) {
                    folgeZ = aktBed.getFolgezustand();
                    this.aktZustand[this.aktAut]
                        = this.vAut[this.aktAut].holeKnoten(
                                new Integer(folgeZ));
                }
            }
View Full Code Here

        String bed;
        int folgeZustand;
        int kantAlter;
        ZInfo zusatz;
        Iterator<Transition> it;
        Transition bedingung;
        String istStart = "";

        this.loescheSelKnot();
        this.aktKnot = knot;

        if (this.aktKnot != null) {
            zusatz = this.aktKnot.getInfo();

            it = zusatz.getBeds().iterator();
            while (it.hasNext()) {
                bedingung = it.next();
                bed = bedingung.getCond().toString();
                folgeZustand = bedingung.getFolgezustand();
                kantAlter = bedingung.getAlter();
                this.ktList.add(bed
                                  + "-"
                                  + folgeZustand
                                  + " ("
                                  + kantAlter
View Full Code Here

     */
    @Override
    public void itemStateChanged(final ItemEvent event) {
        int pos;
        ZInfo zusatz;
        Transition bed;

        if (event.getSource() == this.ktList) {
            pos = ((Integer) event.getItem()).intValue();
            this.kantenEinstell.setEnabled(true);

            if (this.ktList.getSelectedItem() != null) {
                if (this.ktList.getSelectedItem().equals(
                        Messages.getString("SteuerFenster.KanteNeu"))) {
                    this.beding.setText(
                        Messages.getString("SteuerFenster.Bedingung"));
                    this.folgeZust.setText(
                        Messages.getString("SteuerFenster.FolgeZ"));
                    this.ktAlter.setText(
                        Messages.getString("SteuerFenster.KantAlter"));
                } else {
                    zusatz = this.aktKnot.getInfo();
                    bed = zusatz.getBeds().get(pos);
                    this.beding.setText(bed.getCond().toString());
                    this.folgeZust.setText("" + bed.getFolgezustand());
                    this.ktAlter.setText("" + bed.getAlter());
                }
            }
        } else if (event.getSource() == this.grAuswahl) {
            this.waehleGraph(this.grAuswahl.getSelectedIndex());
            this.selKn(this.aktGrph.getAktSelKnot());
View Full Code Here

            int koordX = this.links;
            int koordY = this.oben;
           
            int kX;
            int kY;
            Transition bed;
            int folgeZustand;
            String bedingung;
            int xAusgleich;
            int zaehler = 0;
           
            // Knoten
            it = knotenListe.iterator();
            while (it.hasNext()) {
                knot = it.next();

                if (this.gesetzteKn.containsKey(knot.holeName())) {
                    kX = (int) this.gesetzteKn.get(knot.holeName()).x;
                    kY = (int) this.gesetzteKn.get(knot.holeName()).y;
                    this.setzeKnoten(knot,
                                     darstellung,
                                     kX,
                                     kY,
                                     (Knoten) ausgKn);

                    if (g.istStartZ(knot)) {
                        darstellung.hinzuPfeil(kX - 60,
                                               kY - 60,
                                               kX - 45,
                                               kY - 45,
                                               0.5,
                                               false);
                    }
                } else {
                    this.setzeKnoten(knot,
                                     darstellung,
                                     koordX,
                                     koordY,
                                     (Knoten) ausgKn);

                    this.gesetzteKn.put(knot.holeName(),
                                        new Vector2D(koordX, koordY));

                    if (g.istStartZ(knot)) {
                        darstellung.hinzuPfeil(koordX - 60,
                                               koordY - 60,
                                               koordX - 45,
                                               koordY - 45,
                                               0.5,
                                               false);
                    }

                    zaehler++;
                   
                    if (zaehler < Math.ceil(Math.sqrt(knAnzahl))) {
                        koordX = koordX + gitterX;
                    } else {
                        koordX = this.links;
                        koordY = koordY + gitterY;
                        zaehler = 0;
                    }
                }
            }

            // Kanten
            it1 = knotenListe.iterator();
            while (it1.hasNext()) {
                knot1 = it1.next();
                koord1 = this.gesetzteKn.get(knot1.holeName());

                it2 = (new ArrayList<Integer>(
                                knot1.holeNachfolger().keySet())).iterator();
                while (it2.hasNext()) {
                    boolean gebogen = true;
                   
                    knot2 = g.holeKnoten(it2.next());
                    koord2 = this.gesetzteKn.get(knot2.holeName());
                    Condition cond
                        = knot1.getInfo().getTransZuZustand(
                                knot2.holeName()).get(0).getCond();
                    double staerke = StaticMethods.condStrength(cond,
                                                   ConstantsDarstellung.STAERKE_ERST,
                                                   ConstantsDarstellung.STAERKE_ZWEIT);
                   
                    if (koord1.distance(koord2) < 140
                            && !koord1.equals(koord2)) {
                        gebogen = false;
                    }
                   
                    darstellung.hinzuPfeil(
                            (int) koord1.x,
                            (int) koord1.y,
                            (int) koord2.x,
                            (int) koord2.y,
                            staerke,
                            gebogen);
                }
            }

            // Kantenbeschriftungen
            it1 = knotenListe.iterator();
            while (it1.hasNext()) {
                int kantNum = 1;
                knot1 = it1.next();
                koord1 = this.gesetzteKn.get(knot1.holeName());

                it3 = knot1.getInfo().getBeds().iterator();
                while (it3.hasNext()) {
                    Polygon p = new Polygon();
                    bed = it3.next();
                    folgeZustand = bed.getFolgezustand();
                    bedingung = bed.getCond().toString();
                    knot2 = g.holeKnoten(new Integer(folgeZustand));
                    koord2 = this.gesetzteKn.get(knot2.holeName());

                    p.addPoint((int) koord1.x, (int) koord1.y);
                    p.addPoint((int) koord2.x, (int) koord2.y);
View Full Code Here

            = new ArrayList<Integer>(alleBeds.keySet());
        LinkedList<Transition> aktBeds;
        Integer aktKnoten;
        Iterator<Transition> it;
        String aktBed;
        Transition vollstBed;
        Integer fZustand;
        int pruefIndex;
       
        while (alleKnoten.size() > 0) {
            pruefIndex = this.rand.nextInt(alleKnoten.size());
            aktKnoten = alleKnoten.get(pruefIndex);
            aktBeds = alleBeds.get(aktKnoten);
           
            it = aktBeds.iterator();
            while (it.hasNext()) {
                vollstBed = it.next();
                aktBed = vollstBed.getCond().formatted();
                if (aktBed.charAt(1) == eas.simulation.spatial.sim2D.marbSimulation.Konstanten.FALSE) {
                    fZustand = new Integer(vollstBed.getFolgezustand());
                    ea.entferneKante(aktKnoten, fZustand, vollstBed);
                    return true;
                }
            }
           
View Full Code Here

TOP

Related Classes of eas.simulation.spatial.sim2D.marbSimulation.endlAutomat.Transition

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.