Kashub's Code Barn - "bisi180color"

PACKAGE core;
 
import grafic.LiveObject;
import measurements.GeneratorFloat;
import measurements.HasNext;
import processing.core.PApplet;
import static core.AgentiEpistemici.*;
 
final class Agent {
  protected Student students;
  protected Teacher teachers;
  protected int nStudents, nTeachers;
  protected int age; // zile traite
  protected int deathAge; // durata de viata (numarul de zile pana la moarte)
  protected FLOAT belief; // increderea IN ipoteza
  protected FLOAT pragmatism; // pragmatism, coeficientul de invatare din experienta
  protected FLOAT charisma;
  protected FLOAT exaggerate;
  protected int chats;
 
  protected final static GeneratorFloat
     success = LiveObject.readRegulator("Psuccess")
    ,experiment = LiveObject.readRegulator("Pexperiment")
    ,communication = LiveObject.readRegulator("Pcommunication")
    //,speechSteps = LiveObject.readRegulator("speech steps")
    ,maturity = LiveObject.readRegulator("sexual maturity")
    ,randomDeath = LiveObject.readRegulator("death age")
    ,randomBelief = LiveObject.readRegulator("belief at birth")
    ,randomPragmatism = LiveObject.readRegulator("pragmatism at birth")
    ,randomTrust = LiveObject.readRegulator("trust at birth")
    ,randomCharisma = LiveObject.readRegulator("charisma at birth")
    ,randomIniT = LiveObject.readRegulator("trust in parent")
    ,randomD = LiveObject.readRegulator("trust diffusion")
    ,agreementInfluence = LiveObject.readRegulator("agreement influence on trust")
    ,trustDecay = LiveObject.readRegulator("trust decay")
    ,needForTeachers = LiveObject.readRegulator("need for teachers")
    ,pragmatismDecay = LiveObject.readRegulator("pragmatism decay")
    ,trustInfluence = LiveObject.readRegulator("trust influence on belief")
    ,trustDump = LiveObject.readRegulator("trust thresh. to dump teacher")
    ,tolerance = LiveObject.readRegulator("listen to untrusted")
    ,successFrequency = LiveObject.readRegulator("success frequency")
    ,beliefFrequency = LiveObject.readRegulator("belief frequency")
    ,exaggeration = LiveObject.readRegulator("exaggeration")
    ,globalExaggeration = LiveObject.readRegulator("global exaggeration")
    ;
 
  Agent() {
    init();
  }
 
  Agent(Agent parent) {
    this();
    linkFrom(parent, randomIniT.getValue());
    getNewTeacher();
  }
 
  PRIVATE void init() {
    deathAge = PApplet.ROUND(randomDeath.getValue());
    belief = randomBelief.getValue();
    pragmatism = randomPragmatism.getValue();
    charisma = randomCharisma.getValue();
    exaggerate = exaggeration.getValue();
  }
 
  PUBLIC void socialize() {
    FOR (int k=0; k<5; k++) {
      Agent candidate;
      DO {candidate = mediu.randomAgentOtherThan(this);} WHILE (candidate.isTeacherOf(this));
      linkFrom(candidate, randomTrust.getValue());
    }
  }
 
  PUBLIC void live() {
    chats = 0;
    // experimentează
    IF (experiment.happens()) {
      IF (success.happens())  {
        belief += pragmatism*(1.0f-belief);
      }
      ELSE {
        belief -= pragmatism*belief;
      }
    }
    // parcurge lista de profi și învață de la ei
    FOR (Teacher him=teachers; him!=NULL; him=him.next) {
      him.trust -= trustDecay.getValue()*him.trust; // viteza de scădere a încrederii odată cu înaintarea în vârstă
      IF (communication.happens(map(him.trust, 0.0f, 1.0f, tolerance.getValue(), 1.0f))) {
        chats++;
        Agent teacher = him.theAgent();
        IF (him.lastSpeech>=0.0f && agreementInfluence.getValue()>0.001f)
          him.trust += map(age, 0, 100, 0.001f, agreementInfluence.getValue()) * (agreeWith(him.lastSpeech) - him.trust);
        him.lastSpeech = teacher.speak();
        belief += teacher.charisma * him.trust * trustInfluence.getValue() * (him.lastSpeech - belief);
      }
    }
    // dacă nu prea are încredere într-un profesor, îl abandonează
    FOR (Teacher him=teachers; him!=NULL;) { // atenție că trecerea la next o fac manual în corpul ciclului !!!
      Teacher nextTeacher = him.next;
      IF (trustDump.happens(him.trust)) {
        him.student.detach();
        him.detach();
      }
      him = nextTeacher;
    }
    // eventual își alege un profesor nou
    IF (needForTeachers.happens(1.0f/nTeachers)) {
      getNewTeacher();
    }
    // îmbătrânește
    age++;
    pragmatism -= pragmatismDecay.getValue()*pragmatism;
  }
 
  BOOLEAN isTeacherOf(Agent other) {
    IF (students==NULL) RETURN FALSE;
    FOR (Student him=students; him!=NULL; him=him.next) IF (other==him.theAgent()) RETURN TRUE;
    RETURN FALSE;
  }
 
  BOOLEAN isStudentOf(Agent other) {
    IF (teachers==NULL) RETURN FALSE;
    FOR (Teacher him=teachers; him!=NULL; him=him.next) IF (other==him.theAgent()) RETURN TRUE;
    RETURN FALSE;
  }
 
  protected FLOAT agreeWith(FLOAT speech) { // în ce măsură speechul lui este apropiat de părerea mea
    // apropiere mare: agree -> 100%; apropiere mică: agree -> 0%
    RETURN 1 - Math.ABS(speech - belief);
  }
 
  void getNewTeacher() {
    Answer answer;
    Agent teacher;
    DO {
      answer = askRandomFriend(this);
      teacher = answer.agent;
    } WHILE(teacher==this
         || teacher.isTeacherOf(this)
         || teacher.isStudentOf(this));
    linkFrom(answer.agent, answer.trust);
  }
 
  PUBLIC Answer askRandomFriend(Agent whoAsks) {
    FLOAT diffusion = randomD.getValue();
    FLOAT nGenericStudents = (nStudents + 1)*diffusion;
    FLOAT nFriends = nGenericStudents+nTeachers;
    FLOAT n;
    int nmax;
    FLOAT trust;
    Agent candidate;
    DO {
      n = nFriends * random.nextFloat();
      IF (n<diffusion) { // omul de pe stradă
        trust = 0.0f;
        candidate = mediu.randomAgentOtherThan(this, whoAsks);
      } ELSE IF (n<nGenericStudents) { // un student
        n -= diffusion;
        nmax = Math.MIN(nStudents, (int) Math.FLOOR(n/diffusion));
        assert nmax<=nStudents : "nStudents = "+nStudents+", n = "+nmax;
        Student student = students;
        FOR (int i=0; i<nmax; i++) student = student.next;
        trust = 0.0f;
        IF (student==NULL) student = students;
        assert student!=NULL : "Student is null! WHY THE FUCK??? nStudents = "+nStudents+", nmax = "+nmax;
        candidate = student.theAgent();
      } ELSE { // un profesor
        n -= nGenericStudents;
        nmax = Math.MIN(nTeachers, (int) Math.FLOOR(n));
        assert nmax<=nTeachers : "nTeachers = "+nTeachers+", n = "+nmax;
        Teacher teacher = teachers;
        FOR (int i=0; i<nmax; i++) teacher = teacher.next;
        IF (teacher==NULL) teacher = teachers;
        assert teacher!=NULL : "Teacher is null! WHY THE FUCK??? nTeachers = "+nTeachers+", nmax = "+nmax;
        trust = teacher.trust;
        candidate = teacher.theAgent();
      }
    } WHILE (candidate==whoAsks);
    IF (trust==0.0f) RETURN candidate.askRandomFriend(this).withNoTrust(); // recursie prin elev/omul de pe stradă
    ELSE IF (happens(trust)) RETURN NEW Answer(candidate, trust); // e profesor de încredere, îl întorc chiar pe el
    ELSE RETURN candidate.askRandomFriend(this).WITH(trust); // recursie prin profesor de neîncredere
  }
 
  protected FLOAT speak() {
    /*
    if (speechSteps.getValue()==1) return belief;
    else if (belief==1.0f) return 1.0f;
    else return 1.0f/(speechSteps.getValue()-1) * PApplet.floor(speechSteps.getValue() * belief);
    */
    FLOAT e = exaggerate * globalExaggeration.getValue();
    e = (1+e)/(1-e);
    IF (e==0.0f) RETURN belief;
    ELSE IF (belief==0.5f) RETURN 0.5f;
    ELSE IF (belief<0.5f) RETURN 0.5f*(FLOAT) Math.pow(2*belief,e);
    ELSE RETURN 1-0.5f*(FLOAT) Math.pow(2*(1-belief),e);
  }
 
  PUBLIC BOOLEAN isRipe() {
    RETURN age>=deathAge;
  }
 
  PUBLIC void die() {
    IF (teachers !=NULL) {
      teachers.die();
      teachers = NULL; // doar pentru ușurarea de Garbage Collection
    }
    IF (students !=NULL) {
      students.die();
      students = NULL; // doar pentru ușurarea de Garbage Collection
    }
  }
 
  PUBLIC void linkFrom(Agent teacherAgent, FLOAT trust) {
    Teacher teacher = teacherAgent.NEW Teacher(trust);
    Student student = NEW Student();
    this.addTeacher(teacher);
    teacherAgent.addStudent(student);
    teacher.student = student;
    student.teacher = teacher;
  }
 
  /*
  public void linkTo(Agent studentAgent, float i, float p) {
    Teacher teacher = new Teacher(i, p);
    Student student = studentAgent.new Student();
    studentAgent.addTeacher(teacher);
    this.addStudent(student);
    teacher.student = student;
    student.teacher = teacher;
  }
  */
 
  PRIVATE void addStudent(Student student) {
    IF (students !=NULL) students.prev = student;
    student.next = students;
    students = student;
    nStudents++;
 }
 
  PRIVATE void addTeacher(Teacher teacher) {
    IF (teachers !=NULL) teachers.prev = teacher;
    teacher.next = teachers;
    teachers = teacher;
    nTeachers++;
 }
 
  protected final class Teacher EXTENDS HasNext<Teacher> { // vârf de săgeată
    protected Teacher prev;
    protected Student student; // celălalt capăt (fundul)
    protected FLOAT trust;
    protected FLOAT lastSpeech;
 
    PRIVATE Teacher(FLOAT trust) {
      this.trust = trust;
      lastSpeech = -1.0f;
    }
 
    PRIVATE void detach() { // se auto-scoate din lista teachers a nodului-părinte
      IF (next!=NULL) next.prev = prev;
      IF (prev!=NULL) prev.next = next;
      ELSE student.theAgent().teachers = next;
      student.theAgent().nTeachers--;
      student = NULL; // doar pentru ușurarea de Garbage Collection
    }
 
    PRIVATE void die() { // auto-distrugere recursivă a listei teachers
      IF (next!=NULL) next.die(); // recursie
      student.detach();
      this.detach(); // doar pentru ușurarea de Garbage Collection
    }
 
    PUBLIC Agent theAgent() {
      RETURN Agent.this;
    }
 
  }
 
  protected final class Student EXTENDS HasNext<Student> { // fund de săgeată
    PRIVATE Student prev;
    PRIVATE Teacher teacher; // celălalt capăt (vârful)
 
    PRIVATE void detach() { // se auto-scoate din lista students a nodului-părinte
      IF (next!=NULL) next.prev = prev;
      IF (prev!=NULL) prev.next = next;
      ELSE teacher.theAgent().students = next;
      teacher.theAgent().nStudents--;
      teacher = NULL; // doar pentru ușurarea de Garbage Collection
    }
 
    PRIVATE void die() { // auto-distrugere recursivă a listei students
      IF (next!=NULL) next.die(); // recursie
      teacher.detach();
      this.detach(); // doar pentru ușurarea de Garbage Collection
    }
 
    PUBLIC Agent theAgent() {
      RETURN Agent.this;
    }
 
  }
 
}
 
final class Answer {
  Agent agent;
  FLOAT trust;
 
  Answer(Agent agent, FLOAT trust) {
    this.agent = agent;
    this.trust = trust;
  }
 
  Answer WITH(FLOAT trust) {
    this.trust *= trust;
    RETURN this;
  }
 
  PUBLIC Answer withNoTrust() {
    this.trust = 0.0f;
    RETURN this;
  }
}

| Opony całoroczne | | Sklep z artykułami dla zwierząt | | Programista Trójmiasto | | Blogi za darmo | | Przenieś bloga z onetu | | Skracacz adresów | | Gnieżdżewo | | Opisy GG |