hier mein vorerst "gelöstes" Problem. Der Lösungsansatz ist derzeit noch sehr simpel und weniger zufriedenstellend. Gerade die markierten Zeilen sind nur eine Zwischenlösung. Ich suche noch nach besseren Lösungen hierfür - und versuche es auf größere Wertebereiche zu übertragen, sodass später alles mit Matlab abläuft. In dem Zusammenhang werde ich auch noch einige Zeilen aufräumen. Momentan ist's etwas unübersichtlich. Doch immerhin: Die Ergebnisse sind zufriedenstellend.

clear all
 
%Dezimalstellen
format short g 
 
%gegebene Punkte
PA = [0.8,1.1,0.4];
PB = [1.2,2.2,0.8];
PC = [2.4,2.2,1.7];
 
%Matrizen für jeweils x, y, z der jeweiligen Punkte PA, PB, PC 
Px = [[PA(:,1)];[PB(:,1)];[PC(:,1)]];
Py = [[PA(:,2)];[PB(:,2)];[PC(:,2)]];
Pz = [[PA(:,3)];[PB(:,3)];[PC(:,3)]];
 
%Matrix mit PA, PB, PC und deren Koordinaten x, y, z  
P = [0.8 1.1 0.4
     1.2 2.2 0.8
     2.4 2.2 1.7];
 
%Vektor für ppm-Werte der Punkte PA, PB, PC 
PPM = [1756
       1758
       1761];
 
%Anzahl der zu simulierenden Werte (variabel)   
AnzahlWerte = 100;
 
%leerer Vektor
B = zeros(AnzahlWerte,1);
 
[b]%Simulation
%0.41, 0.29, 0.76 für unterschiedliche Werte (ansonsten gleiche Werte)[/b]
c = 0;
d = 3;
Cx = c + (d-c).*randn(AnzahlWerte,1)*0.41;
Cy = 0.7*(c + (d-c).*randn(AnzahlWerte,1)*0.29);
Cz = c + (d-c).*randn(AnzahlWerte,1)*0.76;
 
 
%simulierte Koordinaten für x, y, z
Rx = Cx';
Rx = Rx';
 
Ry = Cy';
Ry = Ry';
 
Rz = Cz';
Rz = Rz';
 
%Rc = Cc';
%Rc = Rc';
 
%simulierte Koordinaten gesamt
RG = [Rx,Ry,Rz];
 
%Abstände zwischen gegebenen Punkten
Abstandsmatrix = zeros(4,1);
 
Abstandsmatrix(1,1) = 0;
Abstandsmatrix(2,1) = sqrt(((PA(1,1)-PB(1,1))^2)+((PA(1,2)-PB(1,2))^2)+((PA(1,3)-PB(1,3))^2));
Abstandsmatrix(3,1) = sqrt(((PA(1,1)-PC(1,1))^2)+((PA(1,2)-PC(1,2))^2)+((PA(1,3)-PC(1,3))^2));
Abstandsmatrix(4,1) = sqrt(((PB(1,1)-PC(1,1))^2)+((PB(1,2)-PC(1,2))^2)+((PB(1,3)-PC(1,3))^2));
 
Abstandsmatrix;
 
%Abstände zwischen gegebenen und simulierten Werten 
PN = zeros(AnzahlWerte,1);
 
for i = 1:size(PN);
    P1N(i) = sqrt(((PA(1,1)-Rx(i,1))^2)+((PA(1,2)-Ry(i,1))^2)+((PA(1,3)-Rz(i,1))^2));
    P2N(i) = sqrt(((PB(1,1)-Rx(i,1))^2)+((PB(1,2)-Ry(i,1))^2)+((PB(1,3)-Rz(i,1))^2));
    P3N(i) = sqrt(((PC(1,1)-Rx(i,1))^2)+((PC(1,2)-Ry(i,1))^2)+((PC(1,3)-Rz(i,1))^2));
    i = i+1;
end
 
%Abstände zu PA, PB, PC zu Neupunkten
P1N = P1N';
P2N = P2N';
P3N = P3N';
 
%Abstände zu PA, PB, PC zu Neupunkten gesamt
PN = [P1N,P2N,P3N];
 
[b]%Berechnung Gammas, Anwendung sphärisches Modell
%a = range, C = Sill --> aus Excel[/b]
a = 1.690;
C = (19/3);
Gamma = zeros(4,100);
 
%Gammas zwischen bekannten und unbekannten Punkten 
 
%Gamma PA-PN 
for i=1:AnzahlWerte;
    for j=1:AnzahlWerte;
        if P1N(i,1)==0;
            Gamma(i,j) = 0;
        elseif P1N(i,1)>0 && P1N(i,1)<=a;
            Gamma(i,j) = C.*(((3.*P1N(i,1))./2.*a)-0.5.*(((abs(P1N(i,1)))./a).^3));
        elseif abs(P1N(i,1))>a;
            Gamma(i,j)=C;
        end
        j = j+1;
    end 
    i = i+1;
end
 
Gamma1 = Gamma(:,1);
 
%Gamma PB-PN 
for i=1:AnzahlWerte;
    for j=1:AnzahlWerte;
        if P2N(i,1)==0;
            Gamma(i,j) = 0;
        elseif P2N(i,1)>0 && P2N(i,1)<=a;
            Gamma(i,j) = C.*(((3.*P2N(i,1))./2.*a)-0.5.*(((abs(P2N(i,1)))./a).^3));
        elseif abs(P2N(i,1))>a;
            Gamma(i,j)=C;
        end
        j = j+1;
    end 
    i = i+1;
end
 
Gamma2 = Gamma(:,1);
 
%Gamma PC-PN
for i=1:AnzahlWerte;
    for j=1:AnzahlWerte;
        if P3N(i,1)==0;
            Gamma(i,j) = 0;
        elseif P3N(i,1)>0 && P3N(i,1)<=a;
            Gamma(i,j) = C.*(((3.*P3N(i,1))./2.*a)-0.5.*(((abs(P3N(i,1)))./a).^3));
        elseif abs(P3N(i,1))>a;
            Gamma(i,j)=C;
        end
        j = j+1;
    end 
    i = i+1;
end
 
Gamma3 = Gamma(:,1);
 
%Auffüllen der Matrix
Gamma4 = ones(AnzahlWerte,1);
 
%Gamma gesamt
Gamma = [Gamma1';Gamma2';Gamma3';Gamma4'];
 
%Gammas zwischen bekannten Punkten
Abstandsgamma = zeros(4,1);
 
Abstandsgamma(1,1)=0;
Abstandsgamma(2,1)=C.*(((3.*Abstandsmatrix(2,1))./2.*a)-0.5.*(((abs(Abstandsmatrix(2,1)))./a).^3));
Abstandsgamma(3,1)=C;
Abstandsgamma(4,1)=C.*(((3.*Abstandsmatrix(4,1))./2.*a)-0.5.*(((abs(Abstandsmatrix(4,1)))./a).^3));
Abstandsgamma;
 
MatrixA = [Abstandsgamma(1,1) Abstandsgamma(2,1) Abstandsgamma(3,1) 1
           Abstandsgamma(2,1) Abstandsgamma(1,1) Abstandsgamma(4,1) 1
           Abstandsgamma(3,1) Abstandsgamma(4,1) Abstandsgamma(1,1) 1
           1                  1                  1                  0];
 
InvMatrixA = inv(MatrixA);
 
Gewichte = zeros(4,AnzahlWerte);
 
for i = 1:100;
    %for j = 1:100;
        Gewichte(:,i)=InvMatrixA*Gamma(:,i);
        i = i+1;
end
 
Gewichte;
 
Gewichtsmatrix = [Gewichte(1,:)
                 Gewichte(2,:)
                 Gewichte(3,:)];
 
Endwertvektor = zeros(AnzahlWerte,1);
 
for i = 1:AnzahlWerte;
    Endwertvektor(i,1)=PPM(1,1)*Gewichtsmatrix(1,i)+PPM(2,1)*Gewichtsmatrix(2,i)+PPM(3,1)*Gewichtsmatrix(3,i);
    i=i+1;
end
 
Endwertvektor;

vielen Dank für deine Ausdauer und Geduld mit mir! Ich glaube, ich habe einen mächtigen Denkfehler.

Ich habe ein funktionales Modell (in meinem Fall also die Berechnung der Strecke aus Koordinaten) und ich habe die Unsicherheiten dieser Koordinaten.

Ich habe letztendlich auch Streckenberechnungen aus dreidimensionalen Koordinaten (und mein zusätzliches Attribut C, welches von Interesse ist). Statt der Unsicherheit meiner Koordinaten suche ich eine Unsicherheit meines zusätzlichen Attributs C. Dafür könnte ich meine Krige-Varianz nehmen - richtig?

Meine Punkte sind korreliert miteinander - zum einen zwischen den Koordinatenkomponenten und zum anderen zwischen den Punkten selbst, sodass ich eine vollbesetzte Kovarianzmatrix habe.

Eine Kovarianzfunktion und eine ~matrix entwickle ich beim Kriging.

Es sind also nicht einfach nur verrauschte Daten. Wenn dem so wäre, hätte randn() bereits ausgereicht.

Ich schulde dir wohl langsam ein Bier. Vielen Dank! Langsam wird's in meinem Kopf heller. Ich wünsche dir einen schönen Abend!

Mittlerweile verregnete Grüße aus Neubrandenburg
Dustin

In deiner Monte-Carlo-Simulation erzeugst du - vereinfacht ausgedrückt - einfach nur verrauschte Daten?!

Ich habe ein funktionales Modell (in meinem Fall also die Berechnung der Strecke aus Koordinaten) und ich habe die Unsicherheiten dieser Koordinaten. Gesucht wird die Strecke zwischen den Punkten und die zugehörige Unsicherheit. Meine Punkte sind korreliert miteinander - zum einen zwischen den Koordinatenkomponenten und zum anderen zwischen den Punkten selbst, sodass ich eine vollbesetzte Kovarianzmatrix habe.

Mit der Monte-Carlo-Simulation werden (synthetische) Stichproben meiner Eingangsgrößen erzeugt. Diese würden sich bspw. auch ergeben, wenn ich die Punkte erneut aufmessen würde. Die Simulation am Rechner nimmt mir also das wiederholte Messen meiner Eingangsgrößen ab. Die Abhängigkeiten (Bedingungen, Korrelationen) zwischen meinen Punkten, die sich in meiner Kovarianzmatrix befinden, berücksichtige ich hierbei. Es sind also nicht einfach nur verrauschte Daten. Wenn dem so wäre, hätte randn() bereits ausgereicht.

Aus Deinen Angaben habe ich entnommen, dass Du auch eine Eingangskovarianzmatrix hast (oder diese zumindest erzeugen kannst). Folglich kannst Du neue Daten synthetisch erzeugen, die die Korrelationen Deiner Eingangskovarianzmatrix berücksichtigen.

Viele Grüße
Micha

die Problematik "bedinge Simulation" oder "sequentielle Simulation" ist leider noch nicht gelöst! Ich hänge weiterhin fest. In deiner Monte-Carlo-Simulation erzeugst du - vereinfacht ausgedrückt - einfach nur verrauschte Daten?!

Derzeit habe ich mein Kriging in Matlab gelöst. Ich verwendete Funktionen von Wolfgang Schanghart (http://de.mathworks.com/matlabcentral/fileexchange/29025-ordinary-kriging), welche ich für dreidimensionale Daten anpasste. Mein Kriging sollte somit abgeschlossen sein.

Nun lese ich in der Literatur unter den Stichpunkten "Sequentielle Simulation" und "Sequentielle Gauß-Simulation" (M.-Th. Schafmeister):

1. Bestimmung der univariaten Verteilungsfunktion von Z,
2. Gauß-Transformation: y = Phi(z)^3, (mit Phi = geeignete Transformationsfunktion)
3. Festlegung eines Zufallsweges durch das Untersuchungsgebiet,
4. Simple Kriging zur Bestimmung von Erwartungswert und Varianz im Punkt x,
5. Ziehung eines Zufallswertes aus dieser Normalverteilung,
6. dieser simulierte Wert wird den Daten hinzugefügt,
7. Wiederholung von 4, 5 und 6 am nächsten Gitterpunkt des Zufallspfades, bis alle simuliert sind,
8. Rücktransformation der simulierten Werte mittels Zs = Phi^-1 (ys)

Hierzu existieren keine weiteren Infos oder Beispiele, sodass es für mich schwer nachvollziehbar ist. Die Punkte 4 - 7 sind noch einleuchtend - ich simuliere Werte und füge diese meinen Daten hinzu. Anschließend wiederhole ich mein Kriging. Doch wie komme ich auf die simulierten Werte, welche ich meinen Daten hinzufüge?

Sehe ich den Wald vor läuter Bäumen nicht?

Sonnige Grüße aus Neubrandenburg

wenn Du am Ende zu einer zielführenden Lösung gekommen bist, kannst Du diese ja hier kurz skizzieren. Andere Suchende sind Dir sicher dankbar.

das werde ich machen!