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

[Mick]

Aunque se pudiese realizar una asignacion directa, seria algo ineficiente porque el programa tendria igualmente que copiar los datos de una variable a otra .
La ventaja de usar directamente los datos de los arrays es que es muy rapido no se necesita nunca copiar esos arrrays de un lado a otro ya estan en memoria en su sitio una vez cargado el ejecutable.

Si necesitas la maxima eficiencia, tendrias que trabajar con punteros, aunque se puede ocultar la complejidad de usar punteros definiendo y utilizando una clase que facilite el acceso a los datos.

Todo depende de si esos arrays cambian el numero de columnas y/o filas. Si esos arrays tienen el mismo numero de columnas y filas, lo mas rapido y eficiente es usar un puntero a un array para devolver los datos, ejemplo:

Código Delphi [-]

type
  // Definimos mas filas de las que realmente pudiera tener cualquier array que inicialicemos, como accederemos despues a traves de un puntero
  // no importa que ALineas tenga muchas mas filas que los datos reales.
  ALineas= array [0..1023,0..4] of double;
  PLineas= ^ALineas;

function  proc_L_72_F_32(ns:integer; CC:String): PLineas
begin
   if (nS = 1) AND (cC = '1V') then
      Result := @L_72_F_32_1_1V
   else if (nS = 1) AND (cC = '2V') then
      Result := @L_72_F_32_1_2V
   else if (nS = 1) AND (cC = '3V') then
      Result := @L_72_F_32_1_3V
   end if
end;

function test;
va
 Ptr: PLineas;
begin

 Ptr:=  proc_L_72_F_32( ... );

 // Y Accederiamos a los datos de la siguiente manera
 Ptr^[0,3]; 
 Ptr^[1,2]; 
 Ptr^[2,3]; 
end;

Si los arrays tienen numero de filas variables, el problema es que en un array estatico no se sabe a posteriori cuantas filas tiene asi que o se usa alguna otra constate que nos lo diga (usando un tipo record por ejemplo que almacena tanto el array como el numero de filas) o se crea una ultima fila "en blanco" con algun valor numerico que nunca pueda salir en los datos reales y que marque el final.

Código Delphi [-]

 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 ),
      ( 0,0,0,0,0 )   // cuando recorremos el array al llegar a esta fila sabemos que no hay mas
   );

Si el numero de filas y columnas varía luego es un pelin mas complejo, si realmente necesitas un sistema con todo variable (filas y columnas) , indicalo e intentare poner un ejemplo.

Saludos

[jplj]

El funcionamiento del programa es el siguiente.

En un archivo prg tenemos las tablas de datos, esta tablas está agrupadas en funciones en base al tipo de datos que proporcionan. De esta forma en este archivo nos encontramos con funciones similares a:

Código Delphi [-]

FUNCTION L_72_F_32( nS, cC )  -> devuelve tablas con valores del tipo F

FUNCTION L_72_G_32( nS, cC )  -> devuelve tablas con valores del tipo G

FUNCTION L_72_HJ_32( nS, cC )  -> devuelve tablas con valores del tipo HJ

FUNCTION L_72_TM_32( nS, cC )  -> devuelve tablas con valores del tipo TM

Dentro de cada función los array tienen el mismo número de columnas, pero el número de filas varía.

Entre los arrays devuelto por diferentes funciones varía también el número de columnas.

El array devuelto por esta funciones es recuperado en una función similar a:

Código Delphi [-]
FUNCTION LeeLinea(nS, cC, cClase)
  LOCAL aDatos:= {}

  IF cClase = "F" 
     aDatos:= L_72_F_32( nS, cC ) 
  Else If cClase = "G"
     aDatos:= L_72_G_32( nS, cC )
  Else If cClase = "HJ"
     aDatos:= L_72_HJ_32( nS, cC ) 
  Else If cClase = "TM"
     aDatos:= L_72_TM_32( nS, cC ) 
  End if

RETURN aDatos

Por último una función de intrepolación trata los datos obtenidos:

Código Delphi [-]
FUNCTION IntrePolacion(cClase, nValorEntrada, nIndice, sS, c)
  LOCAL nValor:= 0;
            aDatos:= {}

   aDatos:= FUNCTION (nS, cC, cClase)

   nValor:= Interpolar(aDatos, nValorEntrada, nIndice, cClase) 

RETURN nValor

Mick
La ventaja de usar directamente los datos de los arrays es que es muy rapido no se necesita nunca copiar esos arrrays de un lado a otro ya estan en memoria en su sitio una vez cargado el ejecutable

¿Cómo?

[[Lepe]]

Yo creo que nos estamos mareando demasiado. Hay tantas opciones que nos perdemos, para mí la solución más limpia sería:

Código Delphi [-]

type  TVector = Array of array of double;

function LeeLinea(nS, cC, cClase:string):TVector;
var ruta:string;
begin
  ruta := Extractfilepath(Application.Exename) + 'L_72_'+ cClase+ '_'+ns+'_'+cC+'.dat';

  Result:= CargaDatos(ruta);
end;

La rutina establece dinamicamente las columnas y las filas del array y devuelve los datos; cuando dicha variable pierda su visibilidad, delphi liberará la memoria del array, punto y final.

Nos quitamos de encima los siguientes puntos:
- el nombre de las funciones que tanto nos marea.
- los punteros que se arrastrarían por todo el programa.
- Tener en memoria todos los arrays cargados.

No estamos hablando de arrays con 1.000.000 de datos, son unos 100 o 200 que se leerán de un solo golpe del disco duro, y el tiempo en hacerlo no se notará.

Los archivos se guardarían en binario, para guardarse directamente como números floats (nos ahorramos leer como texto y convertir cada uno a número). La migración requiere un paso más, pero el resultado creo lo merece.

Saludos

[[Lepe]]

Para muestra un boton:

Saludos

[Mick]

Una forma de hacerlo con un minimo uso de memoria y rapido acceso a los datos.

Código Delphi [-]
unit uDataMatrix;

//##############################################################################
interface
//##############################################################################

uses SysUtils;

type

  TDataArray= array [0..MaxInt div 16-1] of double;
  PDataArray= ^TDataArray;

  TDataMatrix= class
     private
      FColCount,FRowCount:integer;
      FData: PDataArray;
      procedure SetData(AData:PDataArray; ARows,ACols:integer);
      function  GetCell(ARow,ACol:integer):double;
     public
      procedure Select(Model:string); overload;
      procedure Select(Family:string; nS:integer; cC:string); overload;
      property RowCount:integer read FRowCount;
      property ColCount:integer read FColCount;
      property Cells[ARow,ACol:integer]:double read GetCell; default;
  end;

var
 DataMatrix: TDataMatrix;


//##############################################################################
implementation
//##############################################################################

type
  RModel= record
    Name:string;
    Rows:integer;
    Cols:integer;
    Data:Pointer;
  end;

var

//#######################################################################
//#### Datos, cualquier nuevo modelo solo hace falta añadirlo aqui ######
//#######################################################################

L_72_F_32_1_1V: array [0..19] of double = ( 0,2,3,4,1,   1,3,4,5,3,   2,3,3,4,8,  3,2,3,4,9 );
L_72_F_32_1_2V: array [0..14] 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..13] of double = ( 1,2,3,4,1,3,4,  2,3,4,5,3,2,3  );
OTRFAMILY_1_3V: array [0..13] of double = ( 1,2,3,4,1,3,4,  2,3,4,5,3,2,3  );

Models: array [0..3] of RModel= (
  ( Name:'L_72_F_32_1_1V'; Rows:4; Cols:5; Data:@L_72_F_32_1_1V ),
  ( Name:'L_72_F_32_1_2V'; Rows:3; Cols:5; Data:@L_72_F_32_1_2V ),
  ( Name:'L_72_F_32_1_3V'; Rows:2; Cols:7; Data:@L_72_F_32_1_3V ),
  ( Name:'OTRFAMILY_1_3V'; Rows:2; Cols:7; Data:@OTRFAMILY_1_3V )
);

//####### Metodos ########################################################

function TDataMatrix.GetCell(ARow,ACol:integer):double;
begin
  Result:= FData^[ARow*FColCount+ACol];
end;

procedure TDataMatrix.SetData(AData:PDataArray; ARows,ACols:integer);
begin
  FData    := AData;
  FRowCount:= ARows;
  FColCount:= ACols;
end;

procedure TDataMatrix.Select(Model:string);
var
 i:integer;
begin
  for i:=High(Models) downto 0 do
   if Models[i].Name=Model then begin
      SetData( Models[i].Data, Models[i].Rows, Models[i].Cols );
      Exit;
   end;
   Raise Exception.Create('Unknow Model');
end;

procedure TDataMatrix.Select(Family:string; nS:integer; cC:string);
begin
  Select( Format( '%s_%d_%s' ,[family,nS,cC]) );
end;

//###############################################################
// Creamos un objeto para acceder a los datos (en el arranque del programa)
// Lo que sigue a continuacion se puede eliminar si queremos crear nuestros
// propios objetos en el programa solo cuando sean necesarios
initialization
begin
 DataMatrix:= TDataMatrix.Create;
end;
//###############################################################
finalization
begin
 DataMatrix.free;
end;

end.

Como usar la unit:

Código Delphi [-]
uses uDataMatrix;

// Seleccionar modelo/datos
DataMatrix.Select('L_72_F_32', 1,'3V');
// Usar los datos
for Row:=0 to DataMatrix.RowCount-1 do
  for Col:=0 to DataMatrix.ColCount-1 do
      Sum:= sum+ DataMatrix[Row,Col];
// Otra forma de seleccionar los datos que nos interesen
DataMatrix.Select('L_72_F_32_1_3V');
  
// Si no queremos usar el objeto que crea la unit al arrancar
// Podemos crear otros objetos

var
 Data:TDataMatrix;
begin
 Data:= TDataMatrix.Create; 
 try
    Data.Select('L_72_F_32',1,'3V');
    Data.RowCount;    // Numero de filas
    Data.ColCount;     // Numero de colmnas
    Data[columna,fila]; // Acceder a un dato de la matriz
    //
    Data.Select('OTROMODELO', 1,'1V');
    ..etc. 
 finally
   Data.Free;
 end;

end;

Saludos

[[Lepe]]

¡¡ Que derroche de ingenio Mick!!

Saludos

[jplj]

En primer lugar agradeceros vuestras respuesta.

Debido principalmente a las peculiares características de los usuarios finales de la aplicación -son unos increíbles ingenieros de I+D- voy a emplear el método expuesto por Mick. Emplear ficheros de datos exigiría entre otras cosas verificar que no han sido modificados por los citados "ingenieros" antes de proceder a su lectura.

Un saludo.
Juan P.