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

[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.