Здравствуйте,скажите пжлста,как сделать,чтобы в цикле q и p проги вып.цикл m и n
От: Nadezdushka  
Дата: 25.05.13 19:58
Оценка: -1
unit Unit1;

interface

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, OleServer, ExcelXP,comObj, Grids, DBGrids, DB, ADODB,
ExtCtrls;


type lambda = record
Xn:Double;
Yn:Double;
Xk:Double;
Yk:Double;
Prx:Double;
Pry:Double;
Xc,Yc:Double;

end;
type S =record
Xsn:Double;
Ysn:Double;
Zsn:Double;
Xsk:Double;
Ysk:Double;
Zsk:Double;
PrSx:Double;
PrSy:Double;
PrSz:double;
Modul:Double;
end;
type rlambda =record
AlfaX:Double;
AlfaY:Double;
Prx:Double;
Pry:Double;
end;
type alambda =record
znach:double;
end;
var
AlambdaAlfa_Sa: alambda;
AlambdaAlfa_Sbb: alambda;
AlambdaX_Sa: array [1..100] of array [1..100] of alambda;
AlambdaY_Sa: array [1..100] of array [1..100] of alambda;
AlambdaX_Sbb: array [1..100] of array [1..100] of alambda;
AlambdaY_Sbb: array [1..100] of array [1..100] of alambda;
rlambdaAlfa_Sa: rlambda;
rlambdaAlfa_Sbb: rlambda;
rlambdaX_Sa: array [1..100] of array [1..100] of rlambda;
rlambdaY_Sa: array [1..100] of array [1..100] of rlambda;
rlambdaX_Sbb: array [1..100] of array [1..100] of rlambda;
rlambdaY_Sbb: array [1..100] of array [1..100] of rlambda;
lambdaAlfa:lambda;
Salfa:S;
xrazb: array of Integer;
edtxche,edtyche,edtbay,edtbbx,edtbby,edth,edtdx,edtdy,edtR,edtro,edtbax,edtU:real;
lambdaBetaX:array [0..100] of array [0..100] of lambda;
lambdaBetaY:array [0..100] of array [0..100] of lambda;
Sbeta: array[0..100] of array [0..100] of S;

type
Tfrm1 = class(TForm)
edtxche: TEdit;
Label1: TLabel;
edtyche: TEdit;
Label2: TLabel;
XcheLabel: TLabel;
YcheLabel: TLabel;
ShirinaLabel: TLabel;
edtbay: TEdit;
Label3: TLabel;
Label4: TLabel;
Label5: TLabel;
Label6: TLabel;
Label7: TLabel;
Label8: TLabel;
edtbby: TEdit;
ShirinalLabel: TLabel;
edtbbx: TEdit;
DlinalLabel: TLabel;
VisotalLabel: TLabel;
edth: TEdit;
SmeshenieXLabel: TLabel;
SmeshenieYLabel: TLabel;
edtdx: TEdit;
edtdy: TEdit;
SoprLabel: TLabel;
NLabel: TLabel;
MLabel: TLabel;
roLabel: TLabel;
VisotaCheLabel: TLabel;
edtR: TEdit;
Label9: TLabel;
Label10: TLabel;
Label11: TLabel;
edtro: TEdit;
edtbax: TEdit;
edtM: TEdit;
edtN: TEdit;
edtU: TEdit;
NaprLabel: TLabel;
Label12: TLabel;
IshDanLabel: TLabel;
btnTokLyambda: TButton;
StringGrid1: TStringGrid;
PositionRG: TRadioGroup;



procedure btnTokLyambdaClick(Sender: TObject);


private
{ Private declarations }
public
{ Public declarations }
end;
{ Глобальные переменные }
var
frm1: Tfrm1;

implementation

{$R *.dfm}



procedure Tfrm1.btnTokLyambdaClick(Sender: TObject);
var i,j,m,n,p,q,v,z,M_count,N_count,k:Integer;
s,a,b, s1, s2,s3,s4,s5,s6,s7,s8: string;
y, x: Double;
begin
btnTokLyambda.Enabled := False;

M_count:=StrToInt(edtM.Text);
N_count:=StrToInt(edtN.Text);

x:= strtofloat(edtbbx.text)/strtofloat(edtm.text);
y:= strtofloat(edtbby.text)/strtofloat(edtn.text);
//======================================================================//
lambdaAlfa.Xn:=StrToFloat(edtxche.text)+StrToFloat(edtbax.Text)/2;
lambdaAlfa.Yn:=StrToFloat(edtyche.Text);
lambdaAlfa.Xk:=lambdaAlfa.Xn-StrToFloat(edtbax.Text);
lambdaAlfa.Yk:= lambdaAlfa.Yn;
lambdaAlfa.Xc:=(lambdaAlfa.Xn+ lambdaAlfa.Xk)/2;
lambdaAlfa.Yc:=(lambdaAlfa.Yn+ lambdaAlfa.Yk)/2;
lambdaAlfa.Prx:=lambdaAlfa.Xk- lambdaAlfa.Xn;
lambdaAlfa.Pry:=lambdaAlfa.Yk- lambdaAlfa.Yn;



Salfa.Xsn:=StrToFloat(edtxche.text);
Salfa.Ysn:=StrToFloat(edtyche.Text)-strtofloat(edtbay.Text)/2;
Salfa.Zsn:=0;
Salfa.Xsk:= Salfa.Xsn;
Salfa.Ysk:=Salfa.Ysn;
Salfa.Zsk:=StrToFloat(edtbax.Text)*strtofloat(edtbay.text);
Salfa.PrSx:=Salfa.Xsk- Salfa.Xsn;
Salfa.PrSy:=Salfa.Ysk- Salfa.Ysn;
Salfa.PrSz:=Salfa.Zsk- Salfa.Zsn;
Salfa.Modul:=Sqrt(Sqr(Salfa.PrSx)+sqr(Salfa.PrSy)+ sqr(Salfa.PrSz));


rlambdaAlfa_Sa.PrX:= Salfa.Xsn- lambdaAlfa.Xc;
rlambdaAlfa_Sa.PrY:= Salfa.Ysn- lambdaAlfa.Yc;
AlambdaAlfa_Sa.znach:= ((Salfa.PrSz)*((lambdaAlfa.Prx) *(rlambdaAlfa_Sa.PrY) -(lambdaAlfa.Pry) *(rlambdaAlfa_Sa.PrX))) /((sqrt(sqr(rlambdaAlfa_Sa.PrY))+(sqr(rlambdaAlfa_Sa.PrX)))*(sqrt(sqr(rlambdaAlfa_Sa.PrY))+(sqr(rlambdaAlfa_Sa.PrX)))*(sqrt(sqr (rlambdaAlfa_Sa.PrY))+(sqr(rlambdaAlfa_Sa.PrX)))*10000000)*(-1);

for q:= 1 to M_count do begin
for p:= 1 to N_count do begin
Sbeta[q,p].Xsn:=StrToFloat(edtxche.text)+StrToFloat(edtdx.text)-strtofloat(edtbbx.text)/2+x/2+(x * (p-1));
Sbeta[q,p].Ysn:=StrToFloat(edtyche.text)+StrToFloat(edtdy.text)+y/2+(y* (q-1));
Sbeta[q,p].Zsn:=0;
Sbeta[q,p].Xsk:=Sbeta[q,p].Xsn;
Sbeta[q,p].Ysk:= Sbeta[q,p].Ysn;
Sbeta[q,p].Zsk:=x*y;
Sbeta[q,p].PrSx:=Sbeta[q,p].Xsk-Sbeta[q,p].Xsn;
Sbeta[q,p].PrSy:= Sbeta[q,p].Ysk- Sbeta[q,p].Ysn;
Sbeta[q,p].PrSz:= Sbeta[q,p].Zsk-Sbeta[q,p].Zsn;
Sbeta[q,p].Modul:= Sqrt(Sqr(Sbeta[q,p].PrSx)+sqr(Sbeta[q,p].PrSy)+ sqr(Sbeta[q,p].PrSz));

for n:=1 to M_count+1 do begin
for m:=1 to N_count do begin

lambdaBetaX[n,m].Xn:=StrToFloat(edtxche.text)+StrToFloat(edtdx.text)-x+(x * (m-1));
lambdaBetaX[n,m].Yn:=StrToFloat(edtyche.text)+StrToFloat(edtdy.text)+(y* (n-1));
lambdaBetaX[n,m].Xk:=lambdaBetaX[n,m].Xn+x;
lambdaBetaX[n,m].Yk:=lambdaBetaX[n,m].Yn;
lambdaBetaX[n,m].Xc:=(lambdaBetaX[n,m].Xn+lambdaBetaX[n,m].Xk)/2;
lambdaBetaX[n,m].Yc:=(lambdaBetaX[n,m].Yn+lambdaBetaX[n,m].Yk)/2;
lambdaBetaX[n,m].PrX:=lambdaBetaX[n,m].Xk-lambdaBetaX[n,m].Xn;
lambdaBetaX[n,m].PrY:= lambdaBetaX[n,m].Yk-lambdaBetaX[n,m].Yn;
rlambdaX_Sa[n,m].PrX:= Salfa.Xsn- lambdaBetaX[n,m].Xc; //rlambdaX11-Sa
rlambdaX_Sa[n,m].PrY:=Salfa.Ysn-lambdaBetaX[n,m].Yc;
AlambdaX_Sa[n,m].znach:= ((Salfa.PrSz)*((lambdaBetaX[n,m].Prx) * rlambdaX_Sa[n,m].PrY -lambdaBetaX[n,m].PrY * rlambdaX_Sa[n,m].PrX)) /((sqrt(sqr(rlambdaX_Sa[n,m].PrX)+(sqr(rlambdaX_Sa[n,m].PrY))))*(sqrt(sqr(rlambdaX_Sa[n,m].PrX)+(sqr(rlambdaX_Sa[n,m].PrY))))*(sqrt(sqr(rlambdaX_Sa[n,m].PrX)+(sqr(rlambdaX_Sa[n,m].PrY))))*10000000)*(-1);
//rlambdaAlfa_Sbb.AlfaX:= SBeta[q,p].Xsn- lambdaAlfa.Xc;
//AlambdaAlfa_Sbb.znach:= ((Sbeta[q,p].PrSz)*((lambdaAlfa.Prx) *(rlambdaX_Sbb[n,m].AlfaY) -(lambdaAlfa.Pry) *(rlambdaX_Sbb[n,m].AlfaX))) /((sqrt(sqr(rlambdaX_Sbb[n,m].AlfaY))+(sqr(rlambdaX_Sbb[n,m].AlfaX)))*(sqrt(sqr(rlambdaX_Sbb[n,m].AlfaY))+(sqr(rlambdaX_Sbb[n,m].AlfaX)))*(sqrt(sqr (rlambdaX_Sbb[n,m].AlfaY))+(sqr(rlambdaX_Sbb[n,m].AlfaX)))*10000000)*(-1);
//rlambdaX_Sbb[n,m].PrX:= SBeta[q,p].Xsn- lambdaBetaX[n,m].Xc;
//rlambdaX_Sbb[n,m].PrY:= SBeta[q,p].Ysn- lambdaBetaX[n,m].Yc;
// AlambdaX_Sbb[n,m].znach:= ((Sbeta[q,p].PrSz)*((lambdaBetaX[n,m].Prx) * rlambdaX_Sbb[n,m].PrY -lambdaBetaX[n,m].PrY * rlambdaX_Sbb[n,m].PrX)) /((sqrt(sqr(rlambdaX_Sbb[n,m].PrX)+(sqr(rlambdaX_Sbb[n,m].PrY))))*(sqrt(sqr(rlambdaX_Sbb[n,m].PrX)+(sqr(rlambdaX_Sbb[n,m].PrY))))*(sqrt(sqr(rlambdaX_Sbb[n,m].PrX)+(sqr(rlambdaX_Sbb[n,m].PrY))))*10000000)*(-1);
end;
end;
end;

for n:=1 to M_count do begin
for m:=1 to N_count+1 do begin
lambdaBetaY[n,m].Xn:=StrToFloat(edtxche.text)+StrToFloat(edtdx.text)-strToFloat(edtbbx.text)/2+(x * (m-1));
lambdaBetaY[n,m].Yn:=StrToFloat(edtyche.text)+StrToFloat(edtdy.text)+(y* (n-1));
lambdaBetaY[n,m].Xk:=lambdaBetaY[n,m].Xn;
lambdaBetaY[n,m].Yk:=lambdaBetaY[n,m].Yn+y;
lambdaBetaY[n,m].Xc:=(lambdaBetaY[n,m].Xn+lambdaBetaY[n,m].Xk)/2;
lambdaBetaY[n,m].Yc:=(lambdaBetaY[n,m].Yn+lambdaBetaY[n,m].Yk)/2;
lambdaBetaY[n,m].PrX:=lambdaBetaY[n,m].Xk-lambdaBetaY[n,m].Xn;
lambdaBetaY[n,m].PrY:=lambdaBetaY[n,m].Yk-lambdaBetaY[n,m].Yn;
rlambdaY_Sa[n,m].PrX:=Salfa.Xsn-lambdaBetaY[n,m].Xc; //rlambdaY11-Sa
rlambdaY_Sa[n,m].PrY:=Salfa.Ysn-lambdaBetaY[n,m].Yc;
AlambdaY_Sa[n,m].znach:= ((Salfa.PrSz)*((lambdaBetaY[n,m].PrX) * rlambdaY_Sa[n,m].PrY -lambdaBetaY[n,m].PrY * rlambdaY_Sa[n,m].PrX)) /((sqrt(sqr(rlambdaY_Sa[n,m].PrX)+(sqr(rlambdaY_Sa[n,m].PrY))))*(sqrt(sqr(rlambdaY_Sa[n,m].PrX)+(sqr(rlambdaY_Sa[n,m].PrY))))*(sqrt(sqr(rlambdaY_Sa[n,m].PrX)+(sqr(rlambdaY_Sa[n,m].PrY))))*10000000)*(-1);
//rlambdaAlfa_Sbb.AlfaY:= SBeta[q,p].Ysn- lambdaAlfa.Yc;
//AlambdaAlfa_Sbb.znach:= ((Sbeta[q,p].PrSz)*((lambdaAlfa.Prx) *(rlambdaX_Sbb[n,m].AlfaY) -(lambdaAlfa.Pry) *(rlambdaX_Sbb[n,m].AlfaX))) /((sqrt(sqr(rlambdaX_Sbb[n,m].AlfaY))+(sqr(rlambdaX_Sbb[n,m].AlfaX)))*(sqrt(sqr(rlambdaX_Sbb[n,m].AlfaY))+(sqr(rlambdaX_Sbb[n,m].AlfaX)))*(sqrt(sqr (rlambdaX_Sbb[n,m].AlfaY))+(sqr(rlambdaX_Sbb[n,m].AlfaX)))*10000000)*(-1);
//rlambdaX_Sbb[n,m].PrX:= SBeta[q,p].Xsn- lambdaBetaY[n,m].Xc;
//rlambdaX_Sbb[n,m].PrY:= SBeta[q,p].Ysn- lambdaBetaY[n,m].Yc;
//AlambdaX_Sbb[n,m].znach:= ((Sbeta[q,p].PrSz)*((lambdaBetaY[n,m].Prx) * rlambdaY_Sbb[n,m].PrY -lambdaBetaY[n,m].PrY * rlambdaY_Sbb[n,m].PrX)) /((sqrt(sqr(rlambdaY_Sbb[n,m].PrX)+(sqr(rlambdaY_Sbb[n,m].PrY))))*(sqrt(sqr(rlambdaY_Sbb[n,m].PrX)+(sqr(rlambdaY_Sbb[n,m].PrY))))*(sqrt(sqr(rlambdaY_Sbb[n,m].PrX)+(sqr(rlambdaY_Sbb[n,m].PrY))))*10000000)*(-1);
end;
end;
end;

//======================================================================//

if PositionRG.ItemIndex=0 then begin
with StringGRid1 do
for z:=0 to RowCount-1 do
begin
Rows[z].Clear;
Cells[0, z]:='';
end;
StringGrid1.Cells[0,0] :='Эл.тока lambda';
StringGrid1.Cells[1,0] :='Коор.начала ЭТ поX';
StringGrid1.Cells[2,0] :='Коорд.начала ЭТ поY';
StringGrid1.Cells[3,0] :='Коорд.конца ЭТ поX';
StringGrid1.Cells[4,0] :='Коорд.конца ЭТ поY';
StringGrid1.Cells[5,0] :='Коорд.центра ЭТ поX';
StringGrid1.Cells[6,0] :='Коорд.центра ЭТ поY';
StringGrid1.Cells[7,0] :='Проекции ЭТ на OX';
StringGrid1.Cells[8,0] :='Проекции ЭТ на OY';
StringGrid1.Cells[0,1] :='lambdaAlfa';
StringGrid1.Cells[1,1] := FloatToStr(lambdaAlfa.Xn);
StringGrid1.Cells[2,1] := FloatToStr(lambdaAlfa.Yn);
StringGrid1.Cells[3,1] := FloatToStr(lambdaAlfa.Xk);
StringGrid1.Cells[4,1] := FloatToStr(lambdaAlfa.Yk);
StringGrid1.Cells[5,1] := FloatToStr(lambdaAlfa.Xc);
StringGrid1.Cells[6,1] := FloatToStr(lambdaAlfa.Yc);
StringGrid1.Cells[7,1] := FloatToStr(lambdaAlfa.Prx);
StringGrid1.Cells[8,1] := FloatToStr(lambdaAlfa.Pry);

s:='lambdaBetaX';
k:=1;

for n:= 1 to M_count+ 1 do begin
for m := 1 to N_count do begin
StringGrid1.Cells[0,k+1] := s+inttostr(n)+' '+inttostr(m);
StringGrid1.Cells[0,k+1] := s+inttostr(m)+' '+inttostr(n);
StringGrid1.cells[1,k+1]:= FloatToStr(lambdaBetaX[n,m].Xn);
StringGrid1.cells[2,k+1]:= FloatToStr(lambdaBetaX[n,m].Yn);
StringGrid1.cells[3,k+1]:= FloatToStr(lambdaBetaX[n,m].Xk);
StringGrid1.cells[4,k+1]:= FloatToStr(lambdaBetaX[n,m].Yk);
StringGrid1.cells[5,k+1]:= FloatToStr(lambdaBetaX[n,m].Xc);
StringGrid1.cells[6,k+1]:= FloatToStr(lambdaBetaX[n,m].Yc);
StringGrid1.cells[7,k+1]:= FloatToStr(lambdaBetaX[n,m].PrX);
StringGrid1.cells[8,k+1]:= FloatToStr(lambdaBetaX[n,m].PrY);
k:=k+1;
end;
end;

s1:='lambdaBetaY';

for n:= 1 to M_count do begin
for m:= 1 to N_count+1 do begin
StringGrid1.Cells[0,k+1] := s1+inttostr(n)+' '+inttostr(m);
StringGrid1.Cells[0,k+1] := s1+inttostr(m)+' '+inttostr(n);
StringGrid1.cells[1,k+1]:= FloatToStr(lambdaBetaY[n,m].Xn);
StringGrid1.cells[2,k+1]:= FloatToStr(lambdaBetaY[n,m].Yn);
StringGrid1.cells[3,k+1]:= FloatToStr(lambdaBetaY[n,m].Xk);
StringGrid1.cells[4,k+1]:= FloatToStr(lambdaBetaY[n,m].Yk);
StringGrid1.cells[5,k+1]:= FloatToStr(lambdaBetaY[n,m].Xc);
StringGrid1.cells[6,k+1]:= FloatToStr(lambdaBetaY[n,m].Yc);
StringGrid1.cells[7,k+1]:= FloatToStr(lambdaBetaY[n,m].PrX);
StringGrid1.cells[8,k+1]:= FloatToStr(lambdaBetaY[n,m].PrY);
k:=k+1;
end
end
end
else if PositionRG.ItemIndex=1 then begin
with StringGRid1 do
for z:=0 to RowCount-1 do
begin
Rows[z].Clear;
Cells[0, z]:='';
end;
with StringGRid1 do begin

Cells[0,0] :='Обозначения';
Cells[1,0] :='Коорд.начала Xsn';
Cells[2,0] :='Коорд.начала Ysn';
Cells[3,0] :='Коорд.начала Zsn';
Cells[4,0] :='Коорд.конца Xsk';
Cells[5,0] :='Коорд.конца Ysk';
Cells[6,0] :='Коорд.конца Zsk';
Cells[7,0] :='Проекция Sx';
Cells[8,0] :='Проекция Sy';
Cells[9,0] :='Проекция Sz';
Cells[10,0] :='Модуль';
Cells[0,1] := 'Sа';
Cells[1,1] := FloatToStr(Salfa.Xsn);
Cells[2,1] := FloatToStr(Salfa.Ysn);
Cells[3,1] := FloatToStr(Salfa.Zsn);
Cells[4,1] := FloatToStr(Salfa.Xsk);
Cells[5,1] := FloatToStr(Salfa.Ysk);
Cells[6,1] := FloatToStr(Salfa.Zsk);
Cells[7,1] := FloatToStr(Salfa.PrSx);
Cells[8,1] := FloatToStr(Salfa.PrSy);
Cells[9,1] := FloatToStr(Salfa.PrSz);
Cells[10,1] := FloatToStr(Salfa.Modul);


k:=1;
s:='Sb';

for q:= 1 to M_count do begin
for p:= 1 to N_count do begin
Cells[0,k+1] := s+inttostr(q)+' '+inttostr(p);
Cells[0,k+1] := s+inttostr(p)+' '+inttostr(q);
Cells[1,k+1] := FloatToStr(Sbeta[q,p].Xsn);
Cells[2,k+1] := FloatToStr(Sbeta[q,p].Ysn);
Cells[3,k+1] := FloatToStr(Sbeta[q,p].Zsn);
Cells[4,k+1] := FloatToStr(Sbeta[q,p].Xsk);
Cells[5,k+1] := FloatToStr(Sbeta[q,p].Ysk);
Cells[6,k+1] := FloatToStr(Sbeta[q,p].Zsk);
Cells[7,k+1] := FloatToStr(Sbeta[q,p].PrSx);
Cells[8,k+1] := FloatToStr(Sbeta[q,p].PrSy);
Cells[9,k+1] := FloatToStr(Sbeta[q,p].PrSz);
Cells[10,k+1]:= FloatToStr(Sbeta[q,p].Modul);
k:=k+1;
end;
end;
end

end
else if PositionRG.ItemIndex=2 then begin
with StringGRid1 do
for z:=0 to RowCount-1 do
begin
Rows[z].Clear;
Cells[0, z]:='';
end;
with StringGRid1 do

begin
Cells[0,0] :='Обозначения радиус вектора';
Cells[1,0] :='Проекции r по X';
Cells[2,0] :='Проекции r по Y';
Cells[3,0] :='Обозначения коэффициента A';
Cells[4,0] :='Значение*(-1)';
Cells[0,1] := 'rlambdaAlfa-Sa';
Cells[1,1] := FloatToStr( rlambdaAlfa_Sa.PrX);
Cells[2,1] := FloatToStr( rlambdaAlfa_Sa.PrY);
Cells[1,13] := FloatToStr( rlambdaAlfa_Sbb.PrX);
Cells[2,13] := FloatToStr( rlambdaAlfa_Sbb.PrY);
Cells[3,1] := 'AlambdaAlfa-Sa';
Cells[4,1] := FloatToStr( AlambdaAlfa_Sa.znach);

s2:='rlambdaX';
s4:='AlambdaX';
s6:= 'rlambdaAlfa- Sbeta';
s7:= 'rlambdaX';
s8:= 'rlambdaY';
a:= '_Sa';
b:= '_Sb';
k:=1;


for n:= 1 to M_count+ 1 do begin
for m := 1 to N_count do begin
Cells[0,k+1] := s2+inttostr(n)+' '+inttostr(m)+a;
Cells[0,k+1] := s2+inttostr(m)+' '+inttostr(n)+a;
//Cells[0,49+k] := FloatToStr(rlambdaX_Sbb[n,m].PrX);
//Cells[1,49+k] := FloatToStr(rlambdaX_Sbb[n,m].PrY);
// Cells[2,49+k] := FloatToStr(AlambdaX_Sbb[n,m].znach);
Cells[3,k+1] := s4+inttostr(n)+' '+inttostr(m)+a;
Cells[3,k+1] := s4+inttostr(m)+' '+inttostr(n)+a;
Cells[1,k+1] := FloatToStr(rlambdaX_Sa[n,m].PrX);
Cells[2,k+1] := FloatToStr(rlambdaX_Sa[n,m].PrY);
Cells[4,k+1] := FloatToStr( AlambdaX_Sa[n,m].znach);
k:=k+1;
end;
end;

s3:='rlambdaY';
s5:='AlambdaY';

for n:= 1 to M_count do begin
for m:= 1 to N_count+1 do begin
Cells[0,k+1] := s3+inttostr(n)+' '+inttostr(m)+a;
Cells[0,k+1] := s3+inttostr(m)+' '+inttostr(n)+a;
// Cells[0,49+k] := FloatToStr(rlambdaY_Sbb[n,m].PrX);
// Cells[1,49+k] := FloatToStr(rlambdaY_Sbb[n,m].PrY);
//Cells[2,49+k] := FloatToStr(AlambdaY_Sbb[n,m].znach);
Cells[3,k+1] := s5+inttostr(n)+' '+inttostr(m)+a;
Cells[3,k+1] := s5+inttostr(m)+' '+inttostr(n)+a;
Cells[1,k+1] := FloatToStr(rlambdaY_Sa[n,m].PrX);
Cells[2,k+1] := FloatToStr(rlambdaY_Sa[n,m].PrY);
Cells[4,k+1] := FloatToStr( AlambdaY_Sa[n,m].znach);
k:=k+1;
end;
end;




end
end;
btnTokLyambda.Enabled := true;

end;
end.
Re: Здравствуйте,скажите пжлста,как сделать,чтобы в цикле q и p проги вып.цикл m
От: KARPOLAN Украина http://karpolan.com
Дата: 25.05.13 21:51
Оценка:
Прочитать мануал про procedure и function
KARPOLAN (Anton Karpenko)
http://karpolan.com
http://facebook.com/karpolan
http://linkedin.com/in/karpolan
http://twitter.com/karpolan
http://plus.google.com/+AntonKarpenko
Re[2]: Здравствуйте,скажите пжлста,как сделать,чтобы в цикле q и p проги вып.цик
От: Nadezdushka  
Дата: 26.05.13 06:11
Оценка:
Здравствуйте, KARPOLAN, Вы писали:

KAR>Прочитать мануал про procedure и function

спасибо за совет))
 
Подождите ...
Wait...
Пока на собственное сообщение не было ответов, его можно удалить.