Cargar datos en array para mostrar

[compuin]

Hola foro,

Tengo la siguiente situacion

Tengo las siguentes variables

Código Delphi [-]
L:=0; B:=0 y R:=0;

Tengo una procedure que lee los siguientes parametros, nombre de planeta, fecha juliana y longitud, latitud y radio, asi

Código Delphi [-]

procedure LBR_For(Object_Name:String;At_JDE:Extended;out L: extended; out B: extended; out R: extended);
begin
  If Object_Name = 'SUN' Then LBR_For_Sun(At_JDE,L,B,R);
  If Object_Name = 'MERCURY' Then LBR_For_Mercury(At_JDE,L,B,R);
  If Object_Name = 'VENUS' Then LBR_For_Venus(At_JDE,L,B,R);
  If Object_Name = 'EARTH' Then LBR_For_Earth(At_JDE,L,B,R);
  If Object_Name = 'MARS' Then LBR_For_Mars(At_JDE,L,B,R);
  If Object_Name = 'JUPITER' Then LBR_For_Jupiter(At_JDE,L,B,R);
  If Object_Name = 'SATURN' Then LBR_For_Saturn(At_JDE,L,B,R);
  If Object_Name = 'URANUS' Then LBR_For_Uranus(At_JDE,L,B,R);
  If Object_Name = 'NEPTUNE' Then LBR_For_Neptune(At_JDE,L,B,R);  
end;

Código Delphi [-]
Procedure Posicion_Planeta(Object_Name:String; At_JDE:Extended;out L:extended;out B:Extended;out R:Extended);

Esta procedure devuelve el valor de L, B y R dependiendo del planeta (Sol hasta Neptuno).

Como puedo hacer para crear un arreglo que me almacene el resultado de cada planeta para luego mostrarlo con un bucle FOR?

Gracias de antemano

[ecfisa]

Hola.

Podes usar un arreglo de record, vg.r.:

Código Delphi [-]
...
implementation  {$R *.dfm}

const
  NPLANETAS = 9; // (u ocho según consideres a Plutón)

type
  TPlaneta = record   // un planeta
    nombre: string;
    L,B,R : Extended;
  end;

  TvPlanetas = array[1..NPLANETAS] of TPlaneta; // nueve planetas

// Procedimiento que muestra planetas
procedure MostrarPlanetas(VP: TvPlanetas; ST: TStrings);
var
  i : Integer;
begin
  for i := Low(VP) to High(VP) do
    ST.Add(Format('%8s : %8.2f - %8.2f - %8.2f',
      [VP[i].nombre, VP[i].L, VP[i].B, VP[i].R]));
end;

// Codigo de ejemplo
procedure TForm1.btnShowClick(Sender: TObject);
const
  NAMES: array[1..NPLANETAS] of string =('Mercurio','Venus','Tierra','Marte',
    'Jupiter','Saturno','Urano','Neptuno','Plutón');
var
  vp: TvPlanetas;
  i : Integer;
begin
  // Cargar algo en vp...
  for i := 1 to NPLANETAS do
  begin
    vp[i].nombre := NAMES[i];
    vp[i].L := i;
    vp[i].B := i;
    vp[i].R := i;
  end;

  // Mostrar arreglo de planetas en un Memo
  Memo1.Clear;
  Memo1.Font.Name := 'Courier';
  Mostrar_planetas(vp, Memo1.Lines);
end;
...

Salida:



Saludos

[compuin]

Muchas gracias por el ejemplo

Pero aca no veo como lleno el valor de cada planeta en el arreglo desde la funcion LBR_For para cada uno de ellos

[compuin]

Basicamente necesito algo asi,


Tengo

Código Delphi [-]
  TPlaneta = record
    Lat : Extended;
    Lon : Extended;
    Rad : Extended;
  end;

Y esta es la funcion para conseguir los valores del Sol, por ejemplo:

Código Delphi [-]
LBR_For_Sun(At_JDE,L,B,R);

Lo que me devuelva la funcion, asignarselo a

Código Delphi [-]
Planeta[i].lon:=L;
Planeta[i].lat:=B;
Planeta[i].rad:=R;

Y asi, lo mismo para el resto de los planetas

[ecfisa]

Hola.

No entiendo bien la situación, pero supongo que tendrías que cambiar el tipo del argumento de la función, por ejemplo:

Código Delphi [-]
type
   TPlaneta = record
    Lat : Extended;
    Lon : Extended;
    Rad : Extended;
  end;


procedure LBR_For_Sun(At_JDE: Extended; var PL: TPlaneta);
begin
  // Operaciones inherentes a la función

  // ...

  // Asignar los valores obtenidos al registro
  PL.Lat := ...
  PL.Lon := ...
  PL.Rad := ...
end;

Saludos

[compuin]

Gracias,

Si mas o menos por ahi van los tiros, pero como hago para que pueda hacer esto para cada planeta sin que me arroje error por usar las mismas variables para cada uno de los planetas y luego llenar con un FOR un stringgrid para mostrar los valores de cada planeta?

[ecfisa]

Hola.

Si tienes:

Código Delphi [-]
 TPlaneta = record
    Lat : Extended;
    Lon : Extended;
    Rad : Extended;
  end;
  TvPlaneta: array[1..9] of TPlaneta;

Puedes llamar a la función con cada miembro del arreglo, v. gr.:

Código Delphi [-]
var
  vp: TvPlaneta;
   i: Integer;
begin
   for i := 1 to 9 do
     LBR_For_Sun(At_JDE {???}, vp[i]);
     ...

Saludos

[compuin]

Pero alli es donde esta mi confusion ya que cada planeta tiene la misma cantidad de parametros, es decir, las mismas variables L,B,R y no encuentro como hacer para usar la mismas variables para todos los planetas

[ecfisa]

Empezado por compuin

Pero alli es donde esta mi confusion ya que cada planeta tiene la misma cantidad de parametros, es decir, las mismas variables L,B,R y no encuentro como hacer para usar la mismas variables para todos los planetas

No logro entender el asunto...

Usando un arreglo, todos los planetas usan los mismos nombres de variables:

Planeta 1 (vp[1]) -> Lat, Lon, Rad
Planeta 2 (vp[2]) -> Lat, Lon, Rad
Planeta 3 (vp[3]) -> Lat, Lon, Rad
...

pero, esos nombres en distintas partes del arreglo pueden tener diferentes valores.

Ahora si deseas "usar las mismas variables para todos los planetas" quiere decir que todos los planetas tendrán los mismos valores en L,B,R ¿ o no ?

Saludos

[compuin]

L,B,R van a tomar el valor correspondiente de cada planeta luego del retorno de la funcion

Es decir, tendre L,B,R para el Sol, L,B,R para Mercurio, etc

El problema es que lo estoy haciendo llamando a la funcion cada vez que quiero calcular cada planeta, entonces tengo muchas lineas de codigo repitiendo lo mismo, la idea es poder hacerlo en un solo llamado pero que calcule y retorne los resultados de los planetas de una vez

No se si ya me hice entender

[ecfisa]

Hola.

Empezado por compuin

..., la idea es poder hacerlo en un solo llamado pero que calcule y retorne los resultados de los planetas de una vez

Código Delphi [-]
procedure CargarPlanetas(var VP: TvPlanetas);
begin
  VP[1] := LBR_For_Sun(At_JDE,L,B,R);
  VP[2] := LBR_For_Mercury(At_JDE,L,B,R);
  VP[3] := LBR_For_Venus(At_JDE,L,B,R);
  VP[4] := LBR_For_Earth(At_JDE,L,B,R);
  VP[5] := LBR_For_Mars(At_JDE,L,B,R);
  VP[6] := LBR_For_Jupiter(At_JDE,L,B,R);
  VP[7] := LBR_For_Saturn(At_JDE,L,B,R);
  VP[8] := LBR_For_Uranus(At_JDE,L,B,R);
  VP[9] := LBR_For_Neptune(At_JDE,L,B,R);  
end;

Saludos

[compuin]

Gracias

Lo pruebo y te comento.

Saludos

[ecfisa]

Perdón, no sé donde puse la cabeza...

Olvida el mensaje anterior, debería haber sido:

Código Delphi [-]
procedure CargarPlanetas(var VP: TvPlanetas);
begin
  LBR_For_Sun(At_JDE, VP[1].Lat, VP[1].Lon, VP[1].Rad);
  LBR_For_Mercury(At_JDE, VP[2].Lat,VP[2].Lon ,VP[2].Rad);

  ...

  LBR_For_Uranus(At_JDE, VP[8].Lat, VP[8].Lon, VP[8].Rad);
  LBR_For_Neptune(At_JDE,VP[9].Lat, VP[9].Lon, VP[9].Rad);  
end;

Saludos

[compuin]

En este caso, cuando vaya a mostrar el platena en un Grid, lo estoy haciendo asi,

Caso Sol:

Código Delphi [-]
  StringGrid1.Cells[2,1] := AngleToStr(Lo); 
  StringGrid1.Cells[3,1] := AngleToStr(Bo);
  StringGrid1.Cells[4,1] := AngleToStr(Ro);

Caso Mercurio

Código Delphi [-]
  StringGrid1.Cells[2,3] := AngleToStr(Lm);
  StringGrid1.Cells[3,3] := AngleToStr(Bm);
  StringGrid1.Cells[4,3] := AngleToStr(Rm);

Cuando quiero mostrar todos los planetas tengo que crear una variable L(algo), B(algo) para mostrar los resultados por cada planeta. La idea de poderlo hacer mas sencillo con la mismas variables Lo,Bo y Ro

Es esto posible o existe otra mejor practica para hacerlo?

[ecfisa]

Hola.

A ver, te pongo un ejemplo ultra simplificado de que es lo que comprendí y como lo haría, tal vez nos ayude a entendernos.

Código Delphi [-]
...
implementation

type
  TPlanet = record
      l,b,r: Extended;
  end;
  TvPlanet = array[1..9] of TPlanet;

procedure TForm1.FormCreate(Sender: TObject);
begin
  StringGrid1.Rows[0].CommaText := ',L,B,R';
  StringGrid1.Cols[0].CommaText := ',Mercurio,Venus,Tierra,Marte, Jupiter,Saturno,Urano,Neptuno,Plutón'
end;

procedure CargarPlanetas(var v: TvPlanet);
var
  i: Integer;
begin
  for i  := 1 to 9 do
  begin
    v[i].l := i;
    v[i].b := i;
    v[i].r := i ;
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  i: Integer;
  v: TvPlanet;
begin
   CargarPlanetas(v);
   for i := 1 to 9 do
   begin
     StringGrid1.Cells[1,i] := FloatToStr(v[i].l);
     StringGrid1.Cells[2,i] := FloatToStr(v[i].b);
     StringGrid1.Cells[3,i] := FloatToStr(v[i].r);
   end;
end;
end.

El resultado:


Saludos

[compuin]

Si, esto es lo que necesito pero en la procedure de CargarPlaneta que colocastes utilizo la anterior o la que estas colocando alli??

Código Delphi [-]
procedure CargarPlanetas(var VP: TvPlanetas);
begin
  LBR_For_Sun(At_JDE, VP[1].Lat, VP[1].Lon, VP[1].Rad);
  LBR_For_Mercury(At_JDE, VP[2].Lat,VP[2].Lon ,VP[2].Rad);

  ...

  LBR_For_Uranus(At_JDE, VP[8].Lat, VP[8].Lon, VP[8].Rad);
  LBR_For_Neptune(At_JDE,VP[9].Lat, VP[9].Lon, VP[9].Rad);  
end;

Esta es la parte que me confunde un poco, ya que ahora la procedure luce asi

Código Delphi [-]
procedure CargarPlanetas(var v: TvPlanet);
var
  i: Integer;
begin
  for i  := 1 to 9 do
  begin
    v[i].l := i;
    v[i].b := i;
    v[i].r := i ;
  end;
end;

Cual es la correcta?

[ecfisa]

Hola.

En tu caso creo que es la primera, la que utiliza las funciónes "LBR_For_xxxx" (de las que desconozco todo). La del ejemplo fué eso; un ejemplo.
Es decir, deberías llenar cada uno de los elementos del arreglo de planetas con los valores que obtengas de cada función "LBR_For_xxxx" que le corresponda.

Saludos

[compuin]

Hola

Esto es lo que hace LBR_For_Mercury...hay un procedure por cada planeta

Código Delphi [-]
procedure LBR_For_Mercury(At_JDE:extended; out L: extended; out B: extended; out R: extended);
var
   T: extended;

begin
  //Compute T as Julian millennia since J2000.0
  T := (At_JDE - 2451545) / 365250;
       
  //Compute heliocentric, ecliptical Longitude L in radians
  L := Mercury_L01(T) + Mercury_L02(T);

  //Compute heliocentric, ecliptical Latitude B in radians
  B := Mercury_B01(T) + Mercury_B02(T);

  //Compute heliocentric distance R in AU
  R := Mercury_R01(T) + Mercury_R02(T);   
  
  //Convert longitude and latitude from radians into degrees.
  L := L * 45 / Arctan(1);
  
  If Abs(L) >= 360 Then L := L - 360 * Int(L / 360);
  If L < 0 Then L := L + 360;
  
  B := B * 45 / Arctan(1);

end;

[ecfisa]

Entonces, si declaras tu arreglo de planetas así:

Código Delphi [-]
type
  TPlanet = record
      L,B,R: Extended;
  end;

  TvPlanet = array[1..9] of TPlanet; // Mercurio,Venus,Tierra,Marte, Jupiter,Saturno,Urano,Neptuno,Plutón

De este modo podras cargar sus valores de una vez:

Código Delphi [-]
procedure CargarPlanetas(At_JDE:extended; var v: TvPlanetas);
begin
  LBR_For_Sun(At_JDE,     v[1].L, v[1].B, v[1].R);
  LBR_For_Mercury(At_JDE, v[2].L, v[2].B, v[2].R);
  LBR_For_Venus(At_JDE,   v[3].L, v[3].B, v[3].R);
  LBR_For_Earth(At_JDE,   v[4].L, v[4].B, v[4].R);
  LBR_For_Mars(At_JDE,    v[5].L, v[5].B, v[5].R);
  LBR_For_Jupiter(At_JDE, v[6].L, v[6].B, v[6].R);
  LBR_For_Saturn(At_JDE,  v[7].L, v[7].B, v[7].R);
  LBR_For_Uranus(At_JDE,  v[8].L, v[8].B, v[8].R);
  LBR_For_Neptune(At_JDE, v[9].L, v[9].B, v[9].R);
end;

Saludos

[compuin]

Y para llenar el StringGrid?