Package eas.startSetup.marbBuilder.graph

Examples of eas.startSetup.marbBuilder.graph.Knoten


    public BufferedImage getInsideView() {
        BufferedImage buffImgAut;
        Graphics2D g;
       
        ArrowMaster master = new ArrowMaster(this.pars);
        Knoten aktKnot = this.getAktZustand();
        if (aktKnot == null) {
            aktKnot = this.getVAut()[0].holeStartzustand();
        }
        DargestellterGraph darstellung = new DarstModEA(
                0,
View Full Code Here


     * @param aut       The automaton.
     */
    private void insertEdge(final int knotNam1,
                            final int knotNam2,
                            final EndlicherAutomat aut) {
        Knoten knot1 = aut.holeKnoten(knotNam1);
        Knoten knot2 = aut.holeKnoten(knotNam2);
        Condition c;
       
        if (knot1 == null) {
            this.insertNode(knotNam1, aut);
        }
View Full Code Here

    private void changeNode(final int mode,
                            final int knotNam,
                            final int setValue,
                            final EndlicherAutomat aut) {
       
        Knoten knot = aut.holeKnoten(knotNam);
        ZInfo zusatz;
        int set;
        int setInst;
       
        if (knot == null) {
            this.insertNode(knotNam, aut);
            knot = aut.holeKnoten(knotNam);
        }
       
        zusatz = knot.getInfo();
        set = setValue % 256;
        if (set == 0) {
            set++;
        }
View Full Code Here

            final int qKnotNam,
            final int zKnotNam,
            final EndlicherAutomat aut) {
       
        int quellKnotNam = qKnotNam, zielKnotNam = zKnotNam;
        Knoten knot1;
        Knoten knot2;
        List<Transition> vorhTrans;
        List<Condition> vorhConds;
        Condition c;
        Condition[] cZwisch;
        ArrayList<Integer> knListe;
View Full Code Here

        String seq = StaticMethods.stringAusListSeq(vCode);
        EndlicherAutomat ea = new EndlicherAutomat();
        ea.generateFromSequence(seq, getTranslatoren()[this.getAktAutNum()], false, this.getPars());
        double prob =  this.getPars().getParValueDouble("reachProb");
        for (Integer nodeId: ea.getAdjazenzliste().keySet()) {
            Knoten node = ea.getAdjazenzliste().get(nodeId);
            if (ea.erreichbarVonStart(node.holeName(), prob)) {
                if (!node.getInfo().istStartZ()) {
                    node.getInfo().setAlter(node.getInfo().getAlter() + 1);
                }
                for (Transition t: node.getInfo().getBeds()) {
                    if (StaticMethods.condStrength(
                            t.getCond(),
                            eas.startSetup.marbBuilder.darstellungsModi.ConstantsDarstellung.STAERKE_ERST,
                            eas.startSetup.marbBuilder.darstellungsModi.ConstantsDarstellung.STAERKE_ZWEIT)
                            >= prob) {
View Full Code Here

        ArrayList<Integer> zustaende;
        boolean vorhandenAll;
        Iterator<Integer> it, it1, it2;
        Integer aktName;
        Knoten[] knotenListe = new Knoten[rob.length];
        Knoten zwischKnoten;
        Integer kn1, kn2;
        Knoten zKnoten;
        Condition zCond;
        int aktion;
        int param;      
        int alt;
        boolean istStart;
        RobEA aktRob;
        Condition[] condListe = new Condition[rob.length];
        int j = -1;
       
        /*
         * Ersetzt alle Vorkommnisse von <code>null</code> im Array rob durch
         * gültige im Array weiter vorne stehende Roboter. Dabei wird die
         * Liste der Roboter VOR dem ersten Vorkommnis von <code>null</code>
         * immer wieder über das Array gelegt und die null-Werte werden
         * überschrieben:
         *
         * [1 3 null null null null] => [1 3 1 3 1 3].
         *
         * Wenn nach dem ersten Vorkommnis von <code>null</code> ein gültiger
         * Roboter vorkommt (dies ist kein erwünschter Fall), dann wird er
         * im Array belassen.
         */
        for (int i = 0; i < rob.length; i++) {
            if (rob[i] == null) {
                if (j < 0) {
                    j = i;
                }
                rob[i] = rob[i % j];
            }
        }
       
        for (int i = 0; i < rob.length; i++) {
            if (rob[i].getFitness()[0] > 0) {
                vert.add(new Long(rob[i].getFitness()[0]));
            } else {
                vert.add(new Long(0));
            }
        }

        aktRob = (RobEA) MiscMath.randVerteilung(rob, vert, this.rand);
        zustaende = aktRob.vAuts()[0].getKnList();
        fitness = aktRob.getFitness()[0];
       
        vorhandenAll = true;
       
        it = zustaende.iterator();
        while (it.hasNext()) {
            aktName = it.next();
            for (int i = 0; i < rob.length; i++) {
                zwischKnoten = rob[i].vAuts()[0].holeKnoten(aktName);
                if (zwischKnoten != null) {
                    knotenListe[i] = zwischKnoten;
                } else {
                    vorhandenAll = false;
                    break;
                }
            }
           
            if (vorhandenAll) {
                zKnoten = (Knoten) MiscMath.randVerteilung(knotenListe,
                                                           vert,
                                                           this.rand);
            } else {
                zKnoten = aktRob.vAuts()[0].holeKnoten(aktName);
            }
           
            aktion = (zKnoten.getInfo()).getAktion();
            param = (zKnoten.getInfo()).getParam();
            alt = (zKnoten.getInfo()).getAlter();
            istStart = (zKnoten.getInfo()).istStartZ();
           
            kind.einfuegenKnoten(aktName, aktion, param, alt);
            if (istStart) {
                kind.setStart(kind.holeKnoten(aktName));
            }
View Full Code Here

        int anzRobs;
        int aktName;
        int[] fitness;
        Condition zCond;
        Integer kn1, kn2;
        Knoten zwischKnoten;
        boolean vorhandenAll;
        Iterator<Integer> it;
        Iterator<Integer> it1;
        Iterator<Integer> it2;
        RobEA aktRob = null;
        EndlicherAutomat[] kind;
        ArrayList<Integer> zustaende;
        RobCode[] robC = new RobCode[1];
        Knoten[] knotList = new Knoten[rob.length];
        Condition[] condListe = new Condition[rob.length];
        ArrayList<Long> vert = new ArrayList<Long>(rob.length);
       
        if (rob.length <= 0 || rob[0] == null) {
            StaticMethods.log(StaticMethods.LOG_ERROR,
                          "Kein Roboter zum Rekombinieren übergeben ("
                          + this + ")",
                          this.pars);
        }
       
        id = rob[0].id();
        kind = new EndlicherAutomat[rob[0].vAuts().length];
       
        /*
         * Ersetzt alle Vorkommnisse von <code>null</code> im Array rob durch
         * gültige im Array weiter vorne stehende Roboter. Dabei wird die
         * Liste der Roboter VOR dem ersten Vorkommnis von <code>null</code>
         * immer wieder über das Array gelegt und die null-Werte werden
         * überschrieben:
         *
         * [1 3 null null null null] => [1 3 1 3 1 3].
         *
         * Wenn nach dem ersten Vorkommnis von <code>null</code> ein gültiger
         * Roboter vorkommt (dies ist allerdings kein erw�nschter Fall), dann
         * wird er im Array belassen.
         */
        anzRobs = -1;
        for (int i = 0; i < rob.length; i++) {
            if (rob[i] == null) {
                if (anzRobs < 0) {
                    anzRobs = i;
                }
                rob[i] = rob[i % anzRobs];
            }
        }

        fitness = new int[rob[0].vAuts().length];
       
        for (int i = 0; i < rob[0].vAuts().length; i++) {
            vert.clear();
           
            // Erzeuge Wahrscheinlichkeitsverteilung fitnessproportional.
            for (int j = 0; j < rob.length; j++) {
                if (rob[j].getFitness()[i] > 0) {
                    vert.add(new Long(rob[j].getFitness()[i]));
                } else {
                    vert.add(new Long(0));
                }
            }
           
            aktRob = (RobEA) MiscMath.randVerteilung(rob, vert, this.rand);
            zustaende = aktRob.vAuts()[i].getKnList();
            fitness[i] = aktRob.getFitness()[i];

            kind[i] = new EndlicherAutomat();
            vorhandenAll = true;
           
            // Zustände einfügen.
            it = zustaende.iterator();
            while (it.hasNext()) {
                aktName = it.next();
                for (int j = 0; j < rob.length; j++) {
                    zwischKnoten = rob[j].vAuts()[i].holeKnoten(aktName);
                    if (zwischKnoten != null) {
                        knotList[j] = zwischKnoten;
                    } else {
                        vorhandenAll = false;
                        break;
                    }
                }

                if (vorhandenAll) {
                    zwischKnoten = (Knoten) MiscMath.randVerteilung(knotList,
                                                                    vert,
                                                                    this.rand);
                } else {
                    zwischKnoten = aktRob.vAuts()[i].holeKnoten(aktName);
                }
               
                aktion = (zwischKnoten.getInfo()).getAktion();
                param = (zwischKnoten.getInfo()).getParam();
                alt = (zwischKnoten.getInfo()).getAlter();

                kind[i].einfuegenKnoten(aktName, aktion, param, alt);
            }

            kind[i].setStartBeliebig(); // Setze auf ersten vorh. Knoten.
View Full Code Here

        ArrayList<Integer> knot;
        ArrayList<Integer> knot1;
        Iterator<Integer> it, it1;
        Iterator<Transition> it3;
        Integer aktKnNum;
        Knoten aktKn;
        ZInfo info;
        Knoten zielKn;
        Integer zielKnNum;
        Condition aktBed;
        Condition neuBed = null;
        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);
                        }
                    }
                }
            }
        }

        // true - Kanten zu den einzelnen Startknoten einfügen.
        for (int i = 0; i < endAs.length; i++) {
            zielKn = endAs[i].holeStartzustand();
           
            if (zielKn != null) {
                zielKnNum = (Integer) knotZuord[i].get(zielKn.holeName());
               
                knot = new ArrayList<Integer>(endAs[i].holAdj().keySet());
                it = knot.iterator();
               
                while (it.hasNext()) {
View Full Code Here

    @Override
    public boolean entferneKnoten(final Integer knotenName) {
        final ArrayList<Integer> knotenlisteV;
        final ArrayList<Integer> knotenlisteN;
        Iterator<Integer>  it;
        Knoten          knoten;
        HashMap<Integer, Knoten> nachfolger;
        HashMap<Integer, Knoten> vorgaenger;

        nachfolger = this.holeKnoten(knotenName).holeNachfolger();
        vorgaenger = this.holeKnoten(knotenName).holeVorgaenger();
        knotenlisteN = new ArrayList<Integer>(nachfolger.keySet());
        knotenlisteV = new ArrayList<Integer>(vorgaenger.keySet());

        if (this.startKnName != null
            && this.startKnName.equals(knotenName)) {
            this.entferneStartZ();
        }

        if (this.holAdj().containsKey(knotenName)) {
            it = knotenlisteV.iterator();
            while (it.hasNext()) {
                knoten = this.holeKnoten(it.next());
                this.entferneKante(knoten.holeName(), knotenName);
                knoten.entferneNachfolger(this.holeKnoten(knotenName));
                knoten.entferneVorgaenger(this.holeKnoten(knotenName));
            }
            it = knotenlisteN.iterator();
            while (it.hasNext()) {
                knoten = this.holeKnoten(it.next());
                knoten.entferneNachfolger(this.holeKnoten(knotenName));
                knoten.entferneVorgaenger(this.holeKnoten(knotenName));
            }
            this.holAdj().remove(knotenName);
           
            this.sequenz = null;
           
View Full Code Here

    public boolean einfuegKante(final Integer    knotenName1,
                                final Integer    knotenName2,
                                final Condition  cond,
                                final int        alt) {

        final Knoten knoten1 = this.holeKnoten(knotenName1);
        final Knoten knoten2 = this.holeKnoten(knotenName2);
        ZInfo zusatz1;
        final Transition bed;

        if (!this.getAdjazenzliste().containsKey(knotenName1)
            || !this.getAdjazenzliste().containsKey(knotenName2)) {
            throw new RuntimeException(
                Messages.getString("EndlicherAutomat."
                    + "EinerderbeidenKnotenexistiertnicht"));
        }

        knoten1.neuerNachfolger(knoten2);
        knoten2.neuerVorgaenger(knoten1);

        zusatz1 = knoten1.getInfo();
        bed = new Transition(cond,
                             knotenName1.intValue(),
                             knotenName2.intValue(),
View Full Code Here

TOP

Related Classes of eas.startSetup.marbBuilder.graph.Knoten

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.