Asignar valores a Arrays dinámicos - (migrar datos desde CLIPPER)

[jplj]

Hola:

Pretendo migrar unos datos de un programa hecho en clipper. Estos datos están en forma de matrices, de forma similar a:

Código Delphi [-]

FUNCTION L_72_F_32( nS, cC )

  LOCAL aLineas:={}

  DO CASE


     CASE nS = 1 .AND. cC = "1V"
      aLineas:={ ;
        {   100,  11.20,  0.00,  0.00,  9,  1,  0.10,  -1,  1 },;
        {   500,  56.30,  2.30,  0.86,  9,  3,  1.10,  -5,  5 },;
        {   700,  79.40,  3.30,  0.61,  9,  4,  1.60,  -7,  7 },;
        {  1000, 114.70,  4.70,  0.42,  8,  6,  2.50, -10, 10 },;
        {  1200, 138.90,  5.70,  0.35,  8,  7,  3.10, -12, 12 },;
        {  1500, 176.20,  7.30,  0.28,  8,  9,  4.00, -15, 15 },;
        {  2000, 242.10,  9.90,  0.21,  7, 13,  5.60, -19, 20 },;
        {  2500, 314.70, 12.80,  0.16,  6, 18,  7.60, -24, 24 },;
        {  3000, 398.00, 16.00,  0.13,  5, 25, 10.00, -28, 28 },;
        {  3200, 436.10, 17.40,  0.12,  5, 30, 11.10, -29, 30 },;
        {  3500, 501.70, 19.80,  0.10,  4, 39, 13.30, -31, 32 },;
        {  3600, 527.00, 20.70,  0.10,  4, 44, 14.20, -32, 33 },;
        {  3700, 554.90, 21.70,  0.10,  3, 50, 15.20, -33, 34 },;
        {  3800, 586.50, 22.70,  0.09,  3, 60, 16.40, -33, 34 },;
        {  3900, 624.10, 24.00,  0.09,  2, 77, 17.90, -34, 35 },;
        {  4000, 673.60, 25.60,  0.08,  2, 77, 20.10, -35, 35 } ;
             }

     CASE nS = 1 .AND. cC = "2V"
      aLineas:={ ;
        {   500,  44.70,  2.00,  0.96, 11,  2,  0.80,  -5,  5 },;
        {  1000,  90.80,  4.20,  0.48, 11,  2,  1.90, -10, 10 },;
        {  1300, 119.30,  5.50,  0.37, 10,  3,  2.60, -13, 13 },;
        {  1500, 138.80,  6.40,  0.31, 10,  3,  3.00, -15, 15 },;
        {  2000, 189.30,  8.70,  0.23, 10,  4,  4.30, -19, 20 },;
        {  2500, 243.20, 11.20,  0.18,  9,  6,  5.60, -24, 24 },;
        {  3000, 301.80, 13.80,  0.15,  8,  8,  7.20, -28, 28 },;
        {  3500, 367.10, 16.60,  0.12,  7, 11,  9.00, -31, 32 },;
        {  4000, 443.10, 19.80,  0.10,  6, 15, 11.30, -35, 36 },;
        {  4300, 497.40, 21.90,  0.09,  5, 20, 13.10, -37, 38 },;
        {  4500, 539.80, 23.60,  0.09,  4, 25, 14.60, -38, 39 },;
        {  4600, 564.00, 24.50,  0.08,  4, 29, 15.50, -39, 40 },;
        {  4700, 591.00, 25.60,  0.08,  3, 34, 16.60, -39, 40 },;
        {  4800, 622.50, 26.70,  0.08,  3, 43, 17.80, -40, 41 },;
        {  4900, 661.70, 28.10,  0.07,  2, 62, 19.60, -40, 41 },;
        {  5000, 722.40, 30.20,  0.07,  0, 63, 22.50, -41, 41 } ;
             }

     CASE nS = 1 .AND. cC = "3V"

     .....


  ENDCASE

RETURN aLineas

Existen muchas funciones similares a FUNCTION L_72_F_32( nS, cC ) que devuelven aLineas al mismo procedimiento que se encarga de leer los datos necesarios en cada caso.
Aunque en la función expuesta sólo varía el número de filas, en otras funciones aLineas tiene distinto número de columnas, por lo que en principio creo que debo usar un array dinámico, el problema es cómo realizo la asignación de valores.
Por ahora he pensado en "traducir" los array de clipper en array de cadenas y posteriormente en una función cargar los datos en un vector numérico.

Código Delphi [-]
function L_72_F_32( nS, cC ): TArray_Dinamico_Real;
var
   aLineas: TStringList;
begin


  DO CASE


     CASE nS = 1 .AND. cC = "1V"

       aLinea.Add( '100,  11.20,  0.00,  0.00,  9,  1,  0.10,  -1,  1' );
       aLinea.Add( '500,  56.30,  2.30,  0.86,  9,  3,  1.10,  -5,  5' );
       ....
       aLinea.Add( '4000, 673.60, 25.60,  0.08,  2, 77, 20.10, -35, 35' );


     ...



     result:= Conver_aLineas(aLineas);

end;



function Conver_aLineas(aLineas): TArray_Dinamico_Real;
var
    A: TArray_Dinamico_Real;
begin

    Dimensionar A;
    Leer Valores de aLineas y cargarlos en A;

    resutl:= A;

end;

Mi pregunta es si existe un método más eficiente y sencillo.

Un Saludo
Gracias de antemano.
Juan P.

[Robert01]

Hola

Yo tomaria los datos de un archivo de texto o de una tabla de una base de datos pero no se que vas a hacer con esos datos.

Saludos

[Mick]

Hay varias posibilidades, pero todo depende de como se vaya a acceder a los datos despues y como se vayan a usar, por ejempo podrias guardar la informacion en arrays estaticos:

Código Delphi [-]
const

 L_72_F_32_1_1V: array [0..3,0..4] of double =
   (
      ( 1,2,3,4,1 ),
      ( 2,3,4,5,3 ),
      ( 2,3,3,4,8 ),
      ( 2,2,3,4,9 )
   );

 L_72_F_32_1_2V: array [0..2,0..4] of double =
   (
      ( 1,2,3,4,1 ),
      ( 2,3,4,5,3 ),
      ( 2,3,3,4,8 )
   );

 L_72_F_32_1_3V: array [0..3,0..4] of double =
   (
      ( 1,2,3,4,1 ),
      ( 2,3,4,5,3 ),
      ( 2,3,3,4,8 ),
      ( 2,2,3,4,9 )
   );

Y despues hacer una funcion o un objeto que recupere la informacion adecuada segun los parametros que se le pasen.

Tambien podrias guarada la informacion en un archivo externo, y cargarlo en un array dinamico,
en delphi un array dinamico de dos dimesiones puedes definirlo de esta forma:

Código Delphi [-]
var
 Data: array of array of double;

Saludos

[[Lepe]]

... No acabo yo de pillar el tema....

Desde mi punto de vista, haría un programa que lea el archivo de clipper (se supone que puede abrirse con notepad ¿no?), lo parsea, y ahora crea un archivo de salida .pas con el contenido leido y traducido a codigo delphi.

No creas que es muy complicado hacerlo a mano, aunque TRegExpr puede servir de ayuda.

La idea:

Código Delphi [-]

procedure LeerArchivo(filename:string); // el archio clipper
var Clipper, Delphi:TStringlist;
begin
  Clipper := TStringlist.Create;
  Clipper.LoadFromFile(Filename);
  Delphi := TStringList.Create;
  CreaCabeceraDelphi;
  for i:= 0 to Archivo.Count
  if pos('FUNCTION ', Archivo[i]) <> 0 then
    Procesa_matriz( Archivo, i);
  end;
  Clipper.Free;
  Delphi.SaveToFile('c:\mio.pas');
end;

procedure CreaCabeceraDelphi;
begin
   Delphi.Add('Unit  unidad1;');
   Delphi.Add('');
   Delphi.Add('interface');
   Delphi.Add('');
   Delphi.Add('uses sysutils;');
   Delphi.Add('');
   Delphi.Add('var ');
end;

procedure Procesa_matriz(Lineas:TStrings; idx:integer);
var f:textfile;
begin

// en lineas tenemos todo el texto, a partir del índice idx tenemos la función que queremos parsear:
delete(lineas[idx], 'FUNCTION ',9);// quitamos el texto "function " de esa linea
assign(f, 'c:\mio.pas');
Append; // preparamos el archivo para seguir escribiendo en él.

writeln(Copy(Archivo[idx], 1, 9) + ' : array of array of double = (' );

Buscar_el_case_mas_cercano;

CloseFile(f);
end;

El resumen de todo esto, es que el contenido de "c:\mio.pas" queda como:

Unit Unidad1;

interface

uses sysutils;

var 
L_72_F_32 : array of array of double = (

y hasta aquí he llegado yo

Tu nuevo archivo .pas tiene los arrays creados como si los hubieses escrito tu mismo. Después ese archivo .pas lo agregas al proyecto donde lo necesites.

Edito: Por supuesto lo he escrito todo de memoria... habrá cosas que ni compile, pero bueno... ahí queda. Ya puestos, puedes crear las funciones de clipper con parámetros incluidos para que la unidad final te quede como:

Código Delphi [-]
Unit Unidad1;

interface

uses sysutils;

var 
L_72_F_32 : array of array of double = (
        (   100,  11.20,  0.00,  0.00,  9,  1,  0.10,  -1,  1 ),
        (   500,  56.30,  2.30,  0.86,  9,  3,  1.10,  -5,  5 ),
        (   700,  79.40,  3.30,  0.61,  9,  4,  1.60,  -7,  7 )
        )

FUNCTION proc_L_72_F_32(ns:integer; CC:String):double;


implementation

FUNCTION proc_L_72_F_32(ns:integer; CC:String):double;
begin
   if (nS = 1) AND (cC = '1V') then
    Result := L_72_F_32[ los indices que sean ]
  else if ...
end;

Saludos

[[Lepe]]

Al ver el código de Mick he recordado que al usar arrays inicializados, se necesita conocer los índices, pero bueno, no es problema tampoco, se puede deducir contando las "comas" que existen en cada línea que se va parseando, y las filas según el conteo de llaves abiertas y cerradas (por ejemplo).

Saludos

[jplj]

Muchas gracias por las respuestas.

Desde un primer momento he pensado en arrays dinámicos, y aunque el resultado final de la función lo sea, la solución es crear los arrays de datos estáticos tal como decís.

Presentáis dos opciones para definirlos, como variables o constantes: ¿cuál es la forma más adecuada de hacerlo?

La finalidad de todo esto es emplear el vector devuelto en un procedimiento que por interpolación -habitualmente polinómica- nos devuelva valores intermedios de la tabla.

Código Delphi [-]
Function DatosInter(ValorEntrada, col,  p1, p2)

  // ValorEntrada:  se corresponde con la primera columna.
  // col: es la columna para la que queremos obtener el dato.

  aLineas:= L_72_F_32(p1, p2);
  dato:= Interpola(aLineas, ValorEntrada, col)

Retrun dato

Por ejemplo, tomando los valores puesto en mi primer post:
DatosInter(2115, 2, 1, '1V')
Proporcionaría un valor similar a 265.9