C = 1;
m = 1;
A = [      0   1      0    0
      -2*C/m   0    C/m    0
           0   0      0    1
         C/m   0   -2*C/m  0];

spec(A)

//    1.388D-16 + 1.7320508i  
//    1.388D-16 - 1.7320508i  
//  - 5.551D-17 + i           
//  - 5.551D-17 - i       

Code 0-1: Eigenwertberechnung mit Scilab beim Doppelschwinger

Das Pendel ist ein homogener Zylinder.
Masse  m = 10kg
Länge  l = 1m
Radius r = 0.05m

Code 0-2: Parameter für das Körperpendel

#VRML V2.0 utf8
#Beispiel eines Zyllinders
DEF FIGUR4 Transform
{
    translation 0 0 0
    rotation 0 0 1 0.0
    children
    [
    DEF FIGUR5 Transform
    {
       translation 0 -0.5 0
       rotation 1 0 0 0.0
       children
       [



        Shape
        {
            geometry Cylinder
            {
                    height 1.0
                    radius 0.05
            }
            appearance Appearance
            {
                material Material
                {
                    diffuseColor  0.0 0.8 0.8
                }
            }
        }
      ]
     }

     DEF START TouchSensor {}
    ]
}
DEF ZEIT TimeSensor 
{
  cycleInterval 8
}
DEF DREHUNG OrientationInterpolator
{
    #Zeit
    key
    [
        0.0
        0.33
        0.66
        1.0
    ]
    #Drehachse: x y z  Winkel
    keyValue
    [
        0.0  0.0 1.0  0.0
        0.0  0.0 1.0  1.5   
        0.0  0.0 1.0  0.0   
        0.0  0.0 1.0 -1.5   
    ]
}
ROUTE START.touchTime TO ZEIT.startTime
ROUTE ZEIT.fraction_changed TO DREHUNG.set_fraction
ROUTE DREHUNG.value_changed  TO FIGUR4.rotation

Code 0-3: Musterlösung für die Animation eines Körperpendels mit VRML.

zufallszahl = 1+ floor(grand(1, 1, "unf", 0, 1.999999999));

Code 0-4: Erzeugen einer gleichverteilten diskreten Zufallszahl mit grand, die entweder 1 oder 2 liefert.

clear();
//Implementierung eines modifizierten
//Gradientenverfahrens mit Scilab für 
//die Fehlerfunktion f(x,y)=x^3-4x+y^3-16y

//1. Schritt: Fehlerfunktion formulieren

C1 = 1000.0;
C2 = 0.0;
D2 = 0.0;
m1 = 500.0;
m2 = 20.0;
function f = rechteSeite(t,y)

//  m1*a1 = -C1x1 -D1x1  + (x2-x1)C2 + (v2-v1)D2
//  m2*a2 =              + (x1-x2)C2 + (v1-v2)D2

A = [
         0            1       0         0
        (-C1-C2)/m1  -D2/m1   C2/m1   D2/m1
         0            0       0         1
         C2/m2        D2/m2  -C2/m2  -D2/m2
    ];

    f = A*y;
endfunction


function z = berechneFehler(x,y)
    C2 = x;
    D2 = y;

    y0 = [1;0;0;0];
    t  = 0:0.01:100;
    t0 = 0;
    yy = ode(y0,t0,t,rechteSeite);

    fehler = sum(abs(yy(1,:)));    
    disp(fehler);
    z = fehler;    
endfunction

//2. Schritt: Startwert festlegen:
// (hier beginnt "unsere Skifahrt")

x_alt = 10;
y_alt = 10;

//3. Implementierung des iterativen Verfahrens

aktueller_fehler = berechneFehler(x_alt,y_alt);

alfa = 0.1; //Gewichtung der Änderung.

//Zielwert: xsoll = 1.154700538,  ysol = 2.309401077

for i=1:1000  //innere Befehle iterativ ausführen
    dx = 2*floor(grand(1, 1, "unf", 0, 1.999999999)) - 1;  //liefert -1 oder +1 zufällig
    dy = 2*floor(grand(1, 1, "unf", 0, 1.999999999)) - 1;  //liefert -1 oder +1 zufällig

    x_neu = x_alt + alfa*dx;
    y_neu = y_alt + alfa*dy;

    neuer_fehler = berechneFehler(x_neu,y_neu);

//Prüfen, ob neuer Fehler kleiner, wenn ja, zu neuem Punkt gehen, sonst bei altem bleiben    
    if neuer_fehler<=aktueller_fehler then
        x_alt = x_neu;
        y_alt = y_neu;
        aktueller_fehler = neuer_fehler;
        disp('fehler='+string(aktueller_fehler));     
        disp('x='+string(x_alt));     
        disp('y='+string(y_alt));     
    end
end

disp('Fehler zu Beginn:');
berechneFehler(10,10);

disp('Fehler am Ende:');
berechneFehler(x_alt,y_alt);

Code 0-5: Tilger mit Optimierer.

y = c0*x + c1*2^x

Meßwerte:

x | y
0 | 1
1 | 4
2 | 9

Code 0-6: Tefelbeispiel

B = [0 1
     1 2
     2 4];

d = [ -1
      -4
      -9 ];

A = B' * B

b = B' * d

//   A*c+b=0 =>

c = inv(A)*(-b)

//direkte Implementierung in Scilab von LSQ == Kleinste Quadrate Methode
lsq(B,-d)

Code 0-7: Tafelbeispiel in Scilab umgesetzt

import java.util.Random;
Random zufall = new Random(System.currentTimeMillis());
int anzahlGene  = 8;
int anzahlBeste = 3;
int genlaenge   = 6;
int[][] gene = new int[anzahlGene][genlaenge];
int[][] bestegene = new int[anzahlBeste][genlaenge];
int[] alleFehler = new int[anzahlGene];
public void setup()
{
    size(500,500);
    frameRate(1);
    //Erste Generation von Zufallsgenen bilden:
    for(int i=0;i<gene.length;i++)
    {
         for(int k=0;k<gene[i].length;k++)
         {
             gene[i][k] = zufall.nextInt(2);
         }
    }
}

public int berechneFehler(int[] gen)
{
     int[] soll_pattern = new int[] {1,0,1,0,1,0};
     int fehler = 0;
     for(int i=0;i<gen.length;i++)
         if(gen[i]!=soll_pattern[i])
             fehler++;
     return fehler;        
}

public void draw()
{
    background(255,255,255);
    fill(0,0,0);
    stroke(0,0,255);
    //ellipse(width/2, height/2, 50,50);
    textSize(18);
    for(int i=0;i<gene.length;i++)
    {
         for(int k=0;k<gene[i].length;k++)
         {
             text(gene[i][k],50+k*60,50+i*18);
         }         
    }
    //1. Alle Fehler aktualisieren:
    for(int i=0;i<gene.length;i++)
    {
         alleFehler[i] = berechneFehler(gene[i]);
    }
    fill(255,0,0);
    for(int i=0;i<gene.length;i++)
    {
         text(alleFehler[i],400,50+i*18);
    }
    //2. Finde die drei Besten
    int[] beste_index = new int[3];
    int[] h_beste = new int[] {Integer.MAX_VALUE,Integer.MAX_VALUE,Integer.MAX_VALUE};
    for(int iii=0;iii<anzahlBeste;iii++)
    {
      for(int i=0;i<alleFehler.length;i++)
      {
         if(alleFehler[i]<=h_beste[iii])// || alleFehler[i]<=h_beste[1] || alleFehler[i]<=h_beste[2])
         {
                h_beste[iii] = alleFehler[i];                
                beste_index[iii] = i; 
         }
         alleFehler[beste_index[iii]] = Integer.MAX_VALUE; //für nächsten Durchlauf neutraliseren
      }
    }
    //3. Rekombination aus den drei Besten:
    //3a die besten merken:
    for(int i=0;i<anzahlBeste;i++)
          for(int k=0;k<gene[beste_index[i]].length;k++)
              bestegene[i][k] = gene[beste_index[i]][k];
    //3b in gene kopieren als erste drei:           
    for(int i=0;i<anzahlBeste;i++)
          for(int k=0;k<gene[beste_index[i]].length;k++)
              gene[i][k] = bestegene[i][k];
    //3c Rekombinieren aller anderen
    for(int i=anzahlBeste;i<gene.length;i++)
    {
         int quelle1 = zufall.nextInt(anzahlBeste);
         int quelle2 = (quelle1 + 1 + zufall.nextInt(anzahlBeste-1))%anzahlBeste;
         for(int k=0;k<gene[i].length;k++)
         {
            if(zufall.nextInt(100)>95)
            {
               if(zufall.nextBoolean()==true)
                   gene[i][k] = gene[quelle1][k];
               else    
                   gene[i][k] = gene[quelle2][k];
            }
            else
            {
                   gene[i][k] = zufall.nextInt(2);
            }
         }
         
         
    }
}
Quelltext von Genetisch005

Code 0-8: #ul -- 11|12|2018 -- TUESDAY Simulationstechnik