Freerunner, ne mozes da odgovoris na osnovna pitanja, koja je svrha tvog daljeg ubedjivanja ovde?
Citat:
makro zakoni su deterministichki, i kada naprimer, imas brzinu lopte, masu lopte, smer, impuls ili ubrzanje - ti apsolutno znas deterministicki gde ce ta lopta da zavrsi.
Ako ti ukljucim leteci tanjir pored lopte, dzaba ti od poznatih zakona.
Citat:
Ajd da vidimo formulu, pa da padne i neko merenje.
To su samo neke verzije, koje prave stabilne ili nestabilne fluktuacije, ne mora da odgovara prirodi, dok ne potrefis pravu.
Ko hoce da se igra dacu mu ceo program i kod, treba Delphi 7, kod je malo haotican ali zao mi je.
Ovde je neki primer funkcija:
Svaka od komentovanih linija je neka formula koja je probana, ali ima i deo u ostatku algoritma.
procedure ProcPoints3LDual(a1,a2,a3,d1,d2,d3:Single; var o1,o2,o3,od1,od2,od3:Single);
var Stp:Single;
begin
// Stp := (dr + df) / Fps; //test
// Stp := (1/(dr*(dr / (df/2)))) / Fps;
// Stp := (1/((dr*dr)/(dr+dr))) {/ Fps};
// Stp := (1/(dr*dr)) / Fps;
// Stp := (1/(dr)) / Fps;
// Stp := (1/((dr*dr)/(df))) / Fps;
// Stp := (dr*dr*dr) / Fps;
// Stp := Stp / d2
// Stp := (sqrt(dr)) / Fps;
// Stp := (dr / df) {/ Fps};
// Stp := (df / dr) / Fps;
// Stp := Stp / od;
// Stp := Stp / os;
// Stp := Stp * (os);
// Stp := Stp * (dr/os);
// Stp := (a1*(a1/(d2*1.61833099))) / Fps;
// Stp := (a1*(a1*d2)) / Fps;
// Stp := ((d3-d1)/d2) / Fps;
Stp := ((d3)/d2) / Fps;
o3 := o3 + Stp;
o1 := o1 - Stp;
Stp := ((d1)/d2) / Fps;
o3 := o3 - Stp;
o1 := o1 + Stp;
end;
procedure ProcPoints3DDual(d1,d2,d3,a1,a2,a3:Single; var od1,od2,od3,o1,o2,o3:Single);
var Stp:Single;
begin
// Stp := (dr + df) / Fps; //test
// Stp := (1/((dr*dr)/(dr+dr))) {/ Fps};
// Stp := (1/(dr*dr)) / Fps;
// Stp := (1/(dr)) / Fps;
// Stp := (1/((dr*dr*dr)/(df*df))) / Fps;
// Stp := (dr*dr*dr) / Fps;
//Stp := (dr*dr) / Fps;
// Stp := (sqrt(dr)) / Fps;
// Stp := (dr / df) {/ Fps};
// Stp := (df / dr) / Fps;
// Stp := Stp / od;
// Stp := Stp / os;
// Stp := Stp * (1/os);
// Stp := Stp * (dr/os);
// Stp := ((a3-a1)/a2) / Fps;
Stp := ((a3)/a2) / Fps;
od3 := od3 - Stp;
od1 := od1 + Stp;
Stp := ((a1)/a2) / Fps;
od3 := od3 + Stp;
od1 := od1 - Stp;
end;
(*
procedure ProcPoints3LDual(a1,a2,a3,d1,d2,d3:Single; var o1,o2,o3,od1,od2,od3:Single);
var Stp:Single;
begin
// Stp := (dr + df) / Fps; //test
// Stp := (1/(dr*(dr / (df/2)))) / Fps;
// Stp := (1/((dr*dr)/(dr+dr))) {/ Fps};
// Stp := (1/(dr*dr)) / Fps;
// Stp := (1/(dr)) / Fps;
// Stp := (1/((dr*dr)/(df))) / Fps;
// Stp := (dr*dr*dr) / Fps;
// Stp := Stp / d2
// Stp := (sqrt(dr)) / Fps;
// Stp := (dr / df) {/ Fps};
// Stp := (df / dr) / Fps;
// Stp := Stp / od;
// Stp := Stp / os;
// Stp := Stp * (os);
// Stp := Stp * (dr/os);
// Stp := (a1*(a1/(d2*1.61833099))) / Fps;
// Stp := (a1*(a1*d2)) / Fps;
// Stp := ((d3-d1)/d2) / Fps;
Stp := (d1*d1) / Fps;
o2 := o2 - (Stp);
od1 := od1 + (Stp*2);
// Stp := d2 / Fps;
// od2 := od2 - Stp;
// o1 := o1 + (Stp*2);
end;
procedure ProcPoints3DDual(d1,d2,d3,a1,a2,a3:Single; var od1,od2,od3,o1,o2,o3:Single);
var Stp:Single;
begin
// Stp := (dr + df) / Fps; //test
// Stp := (1/((dr*dr)/(dr+dr))) {/ Fps};
// Stp := (1/(dr*dr)) / Fps;
// Stp := (1/(dr)) / Fps;
// Stp := (1/((dr*dr*dr)/(df*df))) / Fps;
// Stp := (dr*dr*dr) / Fps;
//Stp := (dr*dr) / Fps;
// Stp := (sqrt(dr)) / Fps;
// Stp := (dr / df) {/ Fps};
// Stp := (df / dr) / Fps;
// Stp := Stp / od;
// Stp := Stp / os;
// Stp := Stp * (1/os);
// Stp := Stp * (dr/os);
// Stp := ((a3-a1)/a2) / Fps;
Stp := (a1*a1) / Fps;
od2 := od2 - (Stp);
o1 := o1 + (Stp/2);
// Stp := a2 / Fps;
// o2 := o2 - Stp;
// od1 := od1 + (Stp*2);
end; *)
//==================sfere packing matrica primer=========================
procedure SphereCycle3PDual;
var I,J,K:Integer;
L2,L3,I2,I3,J2,J3,K2,K3:Integer;
Stp,Stp2,Stp3:Single;
begin
for I := 1 to sSizeH do
for J := 1 to sSize do
for K := 1 to sSize do
begin
Spo[I][J][K] := 0;
Dpo[I][J][K] := 0;
end;
for I := 1 to sSizeH do
begin
for J := 1 to sSize do
begin
for K := 1 to sSize do
begin
if Sp[I][J][K] > Dp[I][J][K] then
begin
Stp := Sp[I][J][K] - Dp[I][J][K];
Stp := Stp / FlipFps; //*2 ili /2
Sp[I][J][K] := Sp[I][J][K] - Stp;
Dp[I][J][K] := Dp[I][J][K] + ({0.5 *} Stp);
//ili * phi
end else
if Dp[I][J][K] > Sp[I][J][K] then
begin
Stp := Dp[I][J][K] - Sp[I][J][K];
Stp := Stp / FlipFps;
Dp[I][J][K] := Dp[I][J][K] - Stp;
Sp[I][J][K] := Sp[I][J][K] + ({2 *} Stp);
//konverzija razlicite brzine ili radijacija razlicite brzine??
end;
//Inc(Count);
end;
end;
end;
for I := 1 to sSizeH do
begin
for J := 1 to sSize do
begin
for K := 1 to sSize do
begin
for L2 := 1 to 12 do
begin
SphereCoordFromSphere(I, J, K, L2, I2, J2, K2);
for L3 := 1 to 12 do
begin
SphereCoordFromSphere(I2, J2, K2, L3, I3, J3, K3);
if I = I3 then if J = J3 then if K = K3 then Continue;//to self
//to self??
//ako je filter 0 ne vezuje nista
//ako je filter 40 vezuje pola, propusta pola
//ako je filter 80 vezuje potpuno ne propusti nista
Stp := Sp[I][J][K] / Fps;
Stp2 := Dp[I2][J2][K2] / 80; //stp2 greater if filter greater (range 0 to 1)
Stp3 := Abs(1 - Stp2); //stp3 smaller if filter greater
Stp2 := Stp2 * Stp;
Stp3 := Stp3 * Stp;
Spo[I][J][K] := Spo[I][J][K] - Stp;
Spo[I3][J3][K3] := Spo[I3][J3][K3] + Stp3;
Dpo[I2][J2][K2] := Dpo[I2][J2][K2] + Stp2;
//will be procesed when i3 is i
(* Stp := Sp[I][J][K] / Fps;
Stp2 := Dp[I2][J2][K2] / 80; //stp2 greater if filter greater (range 0 to 1)
Stp3 := Abs(1 - Stp2); //stp3 smaller if filter greater
Stp2 := Stp2 * Stp;
Stp3 := Stp3 * Stp;
Spo[I][J][K] := Spo[I][J][K] - Stp;
Spo[I3][J3][K3] := Spo[I3][J3][K3] + Stp3;
Dpo[I2][J2][K2] := Dpo[I2][J2][K2] + Stp2; *)
// ProcPoints3LDual(Sp[I][J][K], Sp[I2][J2][K2], Sp[I3][J3][K3], Dp[I][J][K], Dp[I2][J2][K2], Dp[I3][J3][K3], Spo[I][J][K], Spo[I2][J2][K2], Spo[I3][J3][K3], Dpo[I][J][K], Dpo[I2][J2][K2], Dpo[I3][J3][K3]);
//Inc(Count);
end;
end;
end;
end;
end;
for I := 1 to sSizeH do
for J := 1 to sSize do
for K := 1 to sSize do
begin
Sp[I][J][K] := Sp[I][J][K] + Spo[I][J][K];
Dp[I][J][K] := Dp[I][J][K] + Dpo[I][J][K];
Spo[I][J][K] := 0;
Dpo[I][J][K] := 0;
end;
for I := 1 to sSizeH do
begin
for J := 1 to sSize do
begin
for K := 1 to sSize do
begin
for L2 := 1 to 12 do
begin
SphereCoordFromSphere(I, J, K, L2, I2, J2, K2);
for L3 := 1 to 12 do
begin
SphereCoordFromSphere(I2, J2, K2, L3, I3, J3, K3);
if I = I3 then if J = J3 then if K = K3 then Continue;//to self
//to self??
(*
Stp := Dp[I][J][K] / Fps;
Stp2 := Sp[I2][J2][K2] / 80; //stp2 greater if filter greater (range 0 to 1)
Stp3 := Abs(1 - Stp2); //stp3 smaller if filter greater
Stp2 := Stp2 * Stp;
Stp3 := Stp3 * Stp;
Dpo[I][J][K] := Dpo[I][J][K] - Stp;
Dpo[I3][J3][K3] := Dpo[I3][J3][K3] + Stp3;
Spo[I2][J2][K2] := Spo[I2][J2][K2] + Stp2;
*)
if Dp[I][J][K] > Dp[I3][J3][K3] then
begin
Stp := (Dp[I3][J3][K3] * Dp[I3][J3][K3]) / Dp[I][J][K];
Stp := Stp / (Fps*2);
Stp2 := Sp[I2][J2][K2] / 80; //stp2 greater if filter greater (range 0 to 1)
Stp3 := Abs(1 - Stp2); //stp3 smaller if filter greater
Stp2 := Stp2 * Stp;
Stp3 := Stp3 * Stp;
Dpo[I][J][K] := Dpo[I][J][K] + Stp3;
Dpo[I3][J3][K3] := Dpo[I3][J3][K3] - Stp;
Spo[I2][J2][K2] := Spo[I2][J2][K2] + Stp2;
end else
//duplo procesed??
if Dp[I][J][K] < Dp[I3][J3][K3] then
begin
Stp := (Dp[I][J][K] * Dp[I][J][K]) / Dp[I3][J3][K3];
Stp := Stp / (Fps*2);
Stp2 := Sp[I2][J2][K2] / 80; //stp2 greater if filter greater (range 0 to 1)
Stp3 := Abs(1 - Stp2); //stp3 smaller if filter greater
Stp2 := Stp2 * Stp;
Stp3 := Stp3 * Stp;
Dpo[I][J][K] := Dpo[I][J][K] - Stp;
Dpo[I3][J3][K3] := Dpo[I3][J3][K3] + Stp3;
Spo[I2][J2][K2] := Spo[I2][J2][K2] + Stp2;
end;
// ProcPoints3DDual(Dp[I][J][K], Dp[I2][J2][K2], Dp[I3][J3][K3], Sp[I][J][K], Sp[I2][J2][K2], Sp[I3][J3][K3], Dpo[I][J][K], Dpo[I2][J2][K2], Dpo[I3][J3][K3], Spo[I][J][K], Spo[I2][J2][K2], Spo[I3][J3][K3]);
//Inc(Count);
end;
end;
end;
end;
end;
for I := 1 to sSizeH do
for J := 1 to sSize do
for K := 1 to sSize do
begin
Sp[I][J][K] := Sp[I][J][K] + Spo[I][J][K];
Dp[I][J][K] := Dp[I][J][K] + Dpo[I][J][K];
end;
SphereRecordFrame;
// SphereGridDraw;
Inc(NumSteps);
PointToWav(Sp[1][1][1]);
end;
//===============================kubna matrica primer==================
procedure Step2P3D;
var I,J,K,Ib,lJ,Jr,uK,Kd:Integer;
begin
for I := 0 to mStep do//depth (0 is front, mstep is back)//SpinEdit1.Value to SpinEdit1.Value do /////
for J := 0 to mStep do //horizontal
for K := 0 to mStep do //vertical
begin
// K2 := (K-1)+( *(mStep+1)); //back up //optimizer
// I2 := (I+1)-((I div mStep)*(mStep+1)); //back
lJ := J-1; if lJ < 0 then lJ := mStep;
Jr := J+1; if Jr > mStep then Jr := 0;
uK := K-1; if uK < 0 then uK := mStep;
Kd := K+1; if Kd > mStep then Kd := 0;
// fI := I-1; if fI < 0 then fI := mStep;
Ib := I+1; if Ib > mStep then Ib := 0;
//right
ProcPoints2L(Dg[I][J][K], Dg[I][Jr][K], Lg[I][J][K], Lg[I][Jr][K]{, 1});
// ProcPointsPolar2aDOnly(Lg[I][J][K], Lg[I][Jr][K], Dg[I][J][K], Dg[I][Jr][K], Lg[I][J][K], Lg[I][Jr][K], Dg[I][J][K], Dg[I][Jr][K], 1);
//down
ProcPoints2L(Dg[I][J][K], Dg[I][J][Kd], Lg[I][J][K], Lg[I][J][Kd]{, 1});
// ProcPointsPolar2aDOnly(Lg[I][J][K], Lg[I][J][Kd], Dg[I][J][K], Dg[I][J][Kd], Lg[I][J][K], Lg[I][J][Kd], Dg[I][J][K], Dg[I][J][Kd], 1);
//right down
ProcPoints2L(Dg[I][J][K], Dg[I][Jr][Kd], Lg[I][J][K], Lg[I][Jr][Kd]{, sqrt(2)});
// ProcPointsPolar2aDOnly(Lg[I][J][K], Lg[I][Jr][Kd], Dg[I][J][K], Dg[I][Jr][Kd], Lg[I][J][K], Lg[I][Jr][Kd], Dg[I][J][K], Dg[I][Jr][Kd], sqrt(2));
//right up
ProcPoints2L(Dg[I][J][K], Dg[I][Jr][uK], Lg[I][J][K], Lg[I][Jr][uK]{, sqrt(2)});
// ProcPointsPolar2aDOnly(Lg[I][J][K], Lg[I][Jr][uK], Dg[I][J][K], Dg[I][Jr][uK], Lg[I][J][K], Lg[I][Jr][uK], Dg[I][J][K], Dg[I][Jr][uK], sqrt(2));
//back
ProcPoints2L(Dg[I][J][K], Dg[Ib][J][K], Lg[I][J][K], Lg[Ib][J][K]{, 1});
// ProcPointsPolar2aDOnly(Lg[I][J][K], Lg[Ib][J][K], Dg[I][J][K], Dg[Ib][J][K], Lg[I][J][K], Lg[Ib][J][K], Dg[I][J][K], Dg[Ib][J][K], 1);
//back right
ProcPoints2L(Dg[I][J][K], Dg[Ib][Jr][K], Lg[I][J][K], Lg[Ib][Jr][K]{, sqrt(2)});
// ProcPointsPolar2aDOnly(Lg[I][J][K], Lg[Ib][Jr][K], Dg[I][J][K], Dg[Ib][Jr][K], Lg[I][J][K], Lg[Ib][Jr][K], Dg[I][J][K], Dg[Ib][Jr][K], sqrt(2));
//back right down
ProcPoints2L(Dg[I][J][K], Dg[Ib][Jr][Kd], Lg[I][J][K], Lg[Ib][Jr][Kd]{, sqrt(3)});
// ProcPointsPolar2aDOnly(Lg[I][J][K], Lg[Ib][Jr][Kd], Dg[I][J][K], Dg[Ib][Jr][Kd], Lg[I][J][K], Lg[Ib][Jr][Kd], Dg[I][J][K], Dg[Ib][Jr][Kd], sqrt(3));
//back down
ProcPoints2L(Dg[I][J][K], Dg[Ib][J][Kd], Lg[I][J][K], Lg[Ib][J][Kd]{, sqrt(2)});
// ProcPointsPolar2aDOnly(Lg[I][J][K], Lg[Ib][J][Kd], Dg[I][J][K], Dg[Ib][J][Kd], Lg[I][J][K], Lg[Ib][J][Kd], Dg[I][J][K], Dg[Ib][J][Kd], sqrt(2));
//back left down
ProcPoints2L(Dg[I][J][K], Dg[Ib][lJ][Kd], Lg[I][J][K], Lg[Ib][lJ][Kd]{, sqrt(3)});
// ProcPointsPolar2aDOnly(Lg[I][J][K], Lg[Ib][lJ][Kd], Dg[I][J][K], Dg[Ib][lJ][Kd], Lg[I][J][K], Lg[Ib][lJ][Kd], Dg[I][J][K], Dg[Ib][lJ][Kd], sqrt(3));
//back left
ProcPoints2L(Dg[I][J][K], Dg[Ib][lJ][K], Lg[I][J][K], Lg[Ib][lJ][K]{, sqrt(2)});
// ProcPointsPolar2aDOnly(Lg[I][J][K], Lg[Ib][lJ][K], Dg[I][J][K], Dg[Ib][lJ][K], Lg[I][J][K], Lg[Ib][lJ][K], Dg[I][J][K], Dg[Ib][lJ][K], sqrt(2));
//back left up
ProcPoints2L(Dg[I][J][K], Dg[Ib][lJ][uK], Lg[I][J][K], Lg[Ib][lJ][uK]{, sqrt(3)});
// ProcPointsPolar2aDOnly(Lg[I][J][K], Lg[Ib][lJ][uK], Dg[I][J][K], Dg[Ib][lJ][uK], Lg[I][J][K], Lg[Ib][lJ][uK], Dg[I][J][K], Dg[Ib][lJ][uK], sqrt(3));
//back up
ProcPoints2L(Dg[I][J][K], Dg[Ib][J][uK], Lg[I][J][K], Lg[Ib][J][uK]{, sqrt(2)});
// ProcPointsPolar2aDOnly(Lg[I][J][K], Lg[Ib][J][uK], Dg[I][J][K], Dg[Ib][J][uK], Lg[I][J][K], Lg[Ib][J][uK], Dg[I][J][K], Dg[Ib][J][uK], sqrt(2));
//back right up
ProcPoints2L(Dg[I][J][K], Dg[Ib][Jr][uK], Lg[I][J][K], Lg[Ib][Jr][uK]{, sqrt(3)});
// ProcPointsPolar2aDOnly(Lg[I][J][K], Lg[Ib][Jr][uK], Dg[I][J][K], Dg[Ib][Jr][uK], Lg[I][J][K], Lg[Ib][Jr][uK], Dg[I][J][K], Dg[Ib][Jr][uK], sqrt(3));
end;
for I := 0 to mStep do//depth (0 is front, mstep is back)//SpinEdit1.Value to SpinEdit1.Value do /////
for J := 0 to mStep do //horizontal
for K := 0 to mStep do //vertical
begin
// K2 := (K-1)+( *(mStep+1)); //back up //optimizer
// I2 := (I+1)-((I div mStep)*(mStep+1)); //back
lJ := J-1; if lJ < 0 then lJ := mStep;
Jr := J+1; if Jr > mStep then Jr := 0;
uK := K-1; if uK < 0 then uK := mStep;
Kd := K+1; if Kd > mStep then Kd := 0;
// fI := I-1; if fI < 0 then fI := mStep;
Ib := I+1; if Ib > mStep then Ib := 0;
//right
// ProcPointsPolar2aLOnly(Lg[I][J][K], Lg[I][Jr][K], Dg[I][J][K], Dg[I][Jr][K], Lg[I][J][K], Lg[I][Jr][K], Dg[I][J][K], Dg[I][Jr][K], 1);
ProcPoints2D(Lg[I][J][K], Lg[I][Jr][K], Dg[I][J][K], Dg[I][Jr][K]{, 1});
//down
// ProcPointsPolar2aLOnly(Lg[I][J][K], Lg[I][J][Kd], Dg[I][J][K], Dg[I][J][Kd], Lg[I][J][K], Lg[I][J][Kd], Dg[I][J][K], Dg[I][J][Kd], 1);
ProcPoints2D(Lg[I][J][K], Lg[I][J][Kd], Dg[I][J][K], Dg[I][J][Kd]{, 1});
//right down
// ProcPointsPolar2aLOnly(Lg[I][J][K], Lg[I][Jr][Kd], Dg[I][J][K], Dg[I][Jr][Kd], Lg[I][J][K], Lg[I][Jr][Kd], Dg[I][J][K], Dg[I][Jr][Kd], sqrt(2));
ProcPoints2D(Lg[I][J][K], Lg[I][Jr][Kd], Dg[I][J][K], Dg[I][Jr][Kd]{, sqrt(2)});
//right up
// ProcPointsPolar2aLOnly(Lg[I][J][K], Lg[I][Jr][uK], Dg[I][J][K], Dg[I][Jr][uK], Lg[I][J][K], Lg[I][Jr][uK], Dg[I][J][K], Dg[I][Jr][uK], sqrt(2));
ProcPoints2D(Lg[I][J][K], Lg[I][Jr][uK], Dg[I][J][K], Dg[I][Jr][uK]{, sqrt(2)});
//back
// ProcPointsPolar2aLOnly(Lg[I][J][K], Lg[Ib][J][K], Dg[I][J][K], Dg[Ib][J][K], Lg[I][J][K], Lg[Ib][J][K], Dg[I][J][K], Dg[Ib][J][K], 1);
ProcPoints2D(Lg[I][J][K], Lg[Ib][J][K], Dg[I][J][K], Dg[Ib][J][K]{, 1});
//back right
// ProcPointsPolar2aLOnly(Lg[I][J][K], Lg[Ib][Jr][K], Dg[I][J][K], Dg[Ib][Jr][K], Lg[I][J][K], Lg[Ib][Jr][K], Dg[I][J][K], Dg[Ib][Jr][K], sqrt(2));
ProcPoints2D(Lg[I][J][K], Lg[Ib][Jr][K], Dg[I][J][K], Dg[Ib][Jr][K]{, sqrt(2)});
//back right down
// ProcPointsPolar2aLOnly(Lg[I][J][K], Lg[Ib][Jr][Kd], Dg[I][J][K], Dg[Ib][Jr][Kd], Lg[I][J][K], Lg[Ib][Jr][Kd], Dg[I][J][K], Dg[Ib][Jr][Kd], sqrt(3));
ProcPoints2D(Lg[I][J][K], Lg[Ib][Jr][Kd], Dg[I][J][K], Dg[Ib][Jr][Kd]{, sqrt(3)});
//back down
// ProcPointsPolar2aLOnly(Lg[I][J][K], Lg[Ib][J][Kd], Dg[I][J][K], Dg[Ib][J][Kd], Lg[I][J][K], Lg[Ib][J][Kd], Dg[I][J][K], Dg[Ib][J][Kd], sqrt(2));
ProcPoints2D(Lg[I][J][K], Lg[Ib][J][Kd], Dg[I][J][K], Dg[Ib][J][Kd]{, sqrt(2)});
//back left down
// ProcPointsPolar2aLOnly(Lg[I][J][K], Lg[Ib][lJ][Kd], Dg[I][J][K], Dg[Ib][lJ][Kd], Lg[I][J][K], Lg[Ib][lJ][Kd], Dg[I][J][K], Dg[Ib][lJ][Kd], sqrt(3));
ProcPoints2D(Lg[I][J][K], Lg[Ib][lJ][Kd], Dg[I][J][K], Dg[Ib][lJ][Kd]{, sqrt(3)});
//back left
// ProcPointsPolar2aLOnly(Lg[I][J][K], Lg[Ib][lJ][K], Dg[I][J][K], Dg[Ib][lJ][K], Lg[I][J][K], Lg[Ib][lJ][K], Dg[I][J][K], Dg[Ib][lJ][K], sqrt(2));
ProcPoints2D(Lg[I][J][K], Lg[Ib][lJ][K], Dg[I][J][K], Dg[Ib][lJ][K]{, sqrt(2)});
//back left up
// ProcPointsPolar2aLOnly(Lg[I][J][K], Lg[Ib][lJ][uK], Dg[I][J][K], Dg[Ib][lJ][uK], Lg[I][J][K], Lg[Ib][lJ][uK], Dg[I][J][K], Dg[Ib][lJ][uK], sqrt(3));
ProcPoints2D(Lg[I][J][K], Lg[Ib][lJ][uK], Dg[I][J][K], Dg[Ib][lJ][uK]{, sqrt(3)});
//back up
// ProcPointsPolar2aLOnly(Lg[I][J][K], Lg[Ib][J][uK], Dg[I][J][K], Dg[Ib][J][uK], Lg[I][J][K], Lg[Ib][J][uK], Dg[I][J][K], Dg[Ib][J][uK], sqrt(2));
ProcPoints2D(Lg[I][J][K], Lg[Ib][J][uK], Dg[I][J][K], Dg[Ib][J][uK]{, sqrt(2)});
//back right up
// ProcPointsPolar2aLOnly(Lg[I][J][K], Lg[Ib][Jr][uK], Dg[I][J][K], Dg[Ib][Jr][uK], Lg[I][J][K], Lg[Ib][Jr][uK], Dg[I][J][K], Dg[Ib][Jr][uK], sqrt(3));
ProcPoints2D(Lg[I][J][K], Lg[Ib][Jr][uK], Dg[I][J][K], Dg[Ib][Jr][uK]{, sqrt(3)});
end;
Inc(NumSteps);
PointToWav(Lg[Form1.SpinEdit1.Value][1][1]);
end;
//==========================================================
Neke stabilne jednacine zvuce ovako:
http://www.youtube.com/watch?v=IkEh84ioMeA
Napravio sam i algoritam za proceduralne jednacine, samo nisam pustao da analizira rezultate.