Copia profunda de un registro con R1: = R2, o ¿Hay una buena manera de implementar la matriz NxM con el registro?

Question

Estoy implementando una matriz N x M (clase) con un registro y una matriz dinámica interna como la siguiente.

TMat = record 
public  
    // contents 
    _Elem: array of array of Double; 

    // 
    procedure SetSize(Row, Col: Integer); 

    procedure Add(const M: TMat); 
    procedure Subtract(const M: TMat); 
    function Multiply(const M: TMat): TMat; 
    //.. 
    class operator Add(A, B: TMat): TMat; 
    class operator Subtract(A, B: TMat): TMat; 
    //.. 
    class operator Implicit(A: TMat): TMat; // call assign inside proc. 
              // <--Self Implicit(which isn't be used in D2007, got compilation error in DelphiXE) 

    procedure Assign(const M: TMat); // copy _Elem inside proc. 
            // <-- I don't want to use it explicitly. 
end; 

Elijo un registro, porque no quiero Crear/Liberar/Asignar para usarlo.

Pero con la matriz dinámica, los valores no se pueden (profundamente) copiar con M1: = M2, en lugar de M1.Asignar (M2).

Intenté declarar el método de conversión implícito, pero no se puede usar para M1: = M2.

(Implícita (const pA: PMAT): TMAT y M1: M2 = @ funciona, pero es bastante feo y leer ..)

¿Hay alguna manera de conectar asignación de disco?

¿O hay alguna sugerencia para implementar la matriz N x M con los registros?

Gracias de antemano.

Editar:

que implementa, como a continuación con el método de Barry y confirmó que funcione correctamente.

type 
    TDDArray = array of array of Double; 

    TMat = record 
    private 
    procedure CopyElementsIfOthersRefer; 
    public 
    _Elem: TDDArray; 
    _FRefCounter: IInterface; 
    .. 
    end; 

procedure TMat.SetSize(const RowSize, ColSize: Integer); 
begin 
    SetLength(_Elem, RowSize, ColSize); 

    if not Assigned(_FRefCounter) then 
    _FRefCounter := TInterfacedObject.Create; 
end; 

procedure TMat.Assign(const Source: TMat); 
var 
    I: Integer; 
    SrcElem: TDDArray; 
begin 
    SrcElem := Source._Elem; // Allows self assign 

    SetLength(Self._Elem, 0, 0); 
    SetLength(Self._Elem, Length(SrcElem)); 

    for I := 0 to Length(SrcElem) - 1 do 
    begin 
    SetLength(Self._Elem[I], Length(SrcElem[I])); 
    Self._Elem[I] := Copy(SrcElem[I]); 
    end; 
end; 

procedure TMat.CopyElementsIfOthersRefer; 
begin 
    if (_FRefCounter as TInterfacedObject).RefCount > 1 then 
    begin 
    Self.Assign(Self); // Self Copy 
    end; 
end; 

Estoy de acuerdo en que no es eficiente. Solo usar Asignar con registro puro es absolutamente más rápido.

pero es bastante práctico y más fácil de leer. (Y interesante. :-)

Creo que es útil para el cálculo de iluminación o prototipos de pre-producción. ¿No es así?

Edit2:

kibab da la función de conseguir el contador de referencia de la misma matriz dinámica.

La solución de Barry es más independiente de la impl interna, y quizás funcione en los próximos compiladores de 64 bits sin ninguna modificación, pero en este caso, prefiero la simplicidad & de kibab por su simplicidad. Gracias.

TMat = record 
    private 
    procedure CopyElementsIfOthersRefer; 
    public 
    _Elem: TDDArray; 
    .. 
    end; 

procedure TMat.SetSize(const RowSize, ColSize: Integer); 
begin 
    SetLength(_Elem, RowSize, ColSize); 
end;  

function GetDynArrayRefCnt(const ADynArray): Longword; 
begin 
    if Pointer(ADynArray) = nil then 
    Result := 1 {or 0, depending what you need} 
    else 
    Result := PLongword(Longword(ADynArray) - 8)^; 
end; 

procedure TMat.CopyElementsIfOthersRefer; 
begin 
    if GetDynArrayRefCnt(_Elem) > 1 then 
    Self.Assign(Self); 
end; 

Answer 1

Se puede utilizar una interfaz campo de referencia dentro de su registro para averiguar si su matriz está compartida por más de un registro: simplemente verifique el recuento de referencias en el objeto detrás de la interfaz, y sabrá que la d ata en las matrices es compartido.De esta forma, puede copiar de forma perezosa la modificación, pero aún así utilizar el intercambio de datos cuando las matrices no se están modificando.

Answer 2

No puede anular la asignación de registros por operadores implícitos o explícitos. Lo mejor que puede hacer OMI no es utilizar la asignación directa, utilizando el método M.Assign lugar:

procedure TMat.Assign(const M: TMat); 
begin 
// "Copy" currently only copies the first dimension, 
// bug report is open - see comment by kibab 
// _Elem:= Copy(M._Elem); 
    .. 
end; 

ex

M1.Assign(M2); 

en lugar de

M1:= M2; 

Answer 3

Acabo de darme cuenta de una razón por la cual esta puede no ser una gran idea. Es cierto que el código de llamada se vuelve mucho más simple con la sobrecarga del operador. Pero puede tener problemas de rendimiento.

Considere, por ejemplo, el código simple A := A+B; y suponga que utiliza la idea en la respuesta aceptada de Barry. Al utilizar la sobrecarga del operador, esta simple operación dará como resultado la asignación de una nueva matriz dinámica. En realidad, desearía realizar esta operación en su lugar.

Dichas operaciones en el lugar son muy comunes en los algoritmos de matriz de álgebra lineal por la sencilla razón de que no desea golpear al montón si puede evitarlo, es caro.

Para tipos de valores pequeños (por ejemplo, números complejos, matrices 3x3, etc.), la sobrecarga del operador dentro de registros es eficiente, pero creo que si el rendimiento es importante, la sobrecarga de operadores no es la mejor solución para matrices grandes.