error en compilación: identifier idents no member
 

Saludos de nuevo :p

Como siempre... aquí intentando averiguar qué significan los mensajes de mis queridos amigos los errores 0:)

Bueno, autocrítica a parte. En un form tengo un botón desde el cual creo 3 instancias de un objeto (TComplex) mediante un constructor, copio los valores de 4 edits en dos de ellas, llamo al método "Suma" y espero que muestre la suma de ellos en dos edits más.

Pero a la hora de compilar me devuelve:
"unit2.pas(47,6) Error: identifier idents no member "Suma""

El constructor, definido por mi, parece que funciona correctamente pues puedo asignar libremente valor de un edit a otro pasando por TComplex antes (ya sé que debe sonarles a chapuza, pero es lo único que se me ocurrió para comprobar que las instancias existían y funcionaban correctamente).

Y no creo que el fallo esté en la suma...

He andado toda la tarde buscando por la web y no me he aclarado nada.
¿Alguna sugerencia, por favor?

Gracias de antemano por su tiempo :)


PD: Adjunto las partes de código implicadas por si quieren mirarlas

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
begin
  z1:=TComplex.Create;
  z2:=TComplex.Create;
  z3:=TComplex.Create;
  z1.Re:=Edit1.text;
  z1.Img:=Edit2.text;
  z2.Re:=Edit3.text;
  z2.Img:=Edit4.text;
  z3.Suma(z1,z2);
  Edit5.text:=z3.Re;
  Edit6.text:=z3.Img;
  z1.destroy;
  z2.destroy;
  z3.destroy;
end;

Código Delphi [-]
              Constructor TComplex.Create(format:char=' '; firstInput:string='0'; secondInput:string='0'); overload;
                          Begin
                               Inherited Create;
                               Case format of
                                    'R': Begin
                                              fRe:=StrToFloat(firstInput);
                                              fImg:=StrToFloat(secondInput);
                                              GetPolar;
                                         end;
                                    'P': Begin
                                            fModulus:=StrToFloat(firstInput);
                                            fArgument:=StrToFloat(secondInput);
                                            GetRectangular;
                                         end;
                                    else
                                        Begin
                                             fRe:=0;
                                             fImg:=0;
                                             fModulus:=0;
                                             fArgument:=0;
                                        end;
                               end;
                          end;

Código Delphi [-]
              Procedure TComplex.Suma(a,b:TComplex);
                        Begin
                             {Suma en formato rectangular}
                             fRe:=StrToFloat(a.Re)+StrToFloat(b.Re);
                             fImg:=StrToFloat(a.Img)+StrToFloat(b.Img);
                             {Modificación del formato polar}
                             GetPolar;
                        end;

Código Delphi [-]
  Type
      TComplex = class(TObject)
                Private
                fRe:extended;
                fImg:extended;
                fModulus:extended;
                fArgument:extended;
                // Métodos de uso interno de la clase
                Function GetRe:string;
                Procedure SetRe(inputRe:string);
                Function GetImg:string;
                Procedure SetImg(inputImg:string);
                Function GetModulus:string;
                Procedure SetModulus(inputModulus:string);
                Function GetArgument:string;
                Procedure SetArgument(inputArgument:string);
                Procedure GetPolar;
                Procedure GetRectangular;


                // Propiedades y métodos accesibles desde fuera de la clase
                Public
                // Llamada cuando se crea una nueva instancia de la clase
                // El parámetro del tipo carácter (R,P) determina el formato (Rectangular o Polar) en que se
                //   expresa el número mediante los otros dos parámetros de entrada
                Constructor Create(format:char=' '; firstInput:string='0'; secondInput:string='0'); overload;
                // Parte real del número (string)
                Property Re:string read GetRe write SetRe;
                // Parte imaginaria del número (string)
                Property Img:string read GetImg write SetImg;
                // Módulo del número (string)
                Property Modulus:string read GetModulus write SetModulus;
                // Argumento del número en radianes (string)
                Property Argument:string read GetArgument write SetArgument;
                // Suma de dos complejos
                Procedure Suma(a,b:TComplex);
      end;

Estos días he tenido alguna hora libre entre clase y clase y he cogido la unit y la he ido recomponiendo línea a línea, revisando cada letra, cada punto y cada apóstrofe y no sé ni cómo ni porqué ha dejado de salirme el error de antes... pero si hago exactamente lo mismo (o al menos eso creo).

Si creen que puede ser útil para álguien, subo el código que no da el fallo :)

Pues claro, siempre puede ser interesante para alguien, gracias :)

A ver si termino de averiguar cómo solucionar el último problema que tengo (manejarme con una TObjectList). Pero para ello faltan mínimo dos días de trabajo antes de comentar dudas jeje.

Si termino y el departamento de Matemáticas de la facultad me de el vistobueno conforme funcione como debería y esté más o menos completa puedo mirar de subir un enlace con el código entero. Que no es gran cosa pero me hace ilusión aportar algo ya que siempre me están ayudando :)

También se aceptan sugerencias para mejorar lo posteado ;)

Código Delphi [-]
interface

uses
  Classes, SysUtils, Math, Dialogs;

type
  TComplex = class(TObject)
  protected
    fRe:extended;
    fImg:extended;
    fModulo:extended;
    fArgumento:extended;
    { Métodos de acceso }
    function GetRe:string;
    procedure SetRe(const AnRe: string);
    function GetImg:string;
    procedure SetImg(const AnImg: string);
    function GetModulo:string;
    procedure SetModulo(const AnModulo: string);
    function GetArgumento:string;
    procedure SetArgumento(const AnArgumento: string);
    { Métodos de completado por formatos }
    procedure GetRectangular;
    procedure GetPolar;

  public
    { Constructor por defecto Z=0 }
    constructor Create; overload;
    { Constructor de números complejos.
        Dados un formato (P=Polar, R=Rectangular
          y dos parámetros que definan el formato
          crea un número complejo definido completamente
        Valores por defecto Z=0 }
    constructor Crear(format:char; input1,input2:string);

    { Propiedades que definen al objeto }
    property Re:string read GetRe write SetRe;
    property Img:string read GetImg write SetImg;
    property Modulo:string read GetModulo write SetModulo;
    property Argumento:string read GetArgumento write SetArgumento;

    { Métodos públicos }
     //z3.Suma(z1,z2) --> z3=z1+z2
    procedure Suma(a,b:TComplex);

  end;


implementation

  { Constructores }
  constructor TComplex.Create;
    Begin
      inherited Create;
      fRe:=0;
      fImg:=0;
      fModulo:=0;
      fArgumento:=0;
      existelista:=false;
    end;

  constructor TComplex.Crear(format:char; input1,input2:string);
    Begin
      inherited Create;
      fRe:=0;
      fImg:=0;
      fModulo:=0;
      fArgumento:=0;
      existelista:=false;
      Case format of
        'R': Begin
               If TryStrToFloat(input1,fRe) and TryStrToFloat(input2,fImg) then
                 GetPolar
               else
                 showmessage('Error: Datos introducidos no válidos');
             end;

        'P': Begin
               If TryStrToFloat(input1,fModulo) and TryStrToFloat(input2,fArgumento) then
                 GetRectangular
               else
                 showmessage('Error: Datos introducidos no válidos');
             end;
      end;
    end;

  { Métodos de acceso }
  function TComplex.GetRe: string;
    Begin
      Result:=FloatToStr(fRe);
    end;

  procedure TComplex.SetRe(const AnRe: string);
    Begin
      fRe:=StrToFloat(AnRe);
    end;

 { 
  Resumo esta parte para no ocupar tanto post. 
  Igual para:
 
  function TComplex.GetImg: string;
  procedure TComplex.SetImg(const AnImg: string);
  function TComplex.GetModulo:string;
  procedure TComplex.SetModulo(const AnModulo: string);
  function TComplex.GetArgumento:string;
  procedure TComplex.SetArgumento(const AnArgumento: string);
}

  { Métodos de completado por formatos }
  procedure TComplex.GetRectangular;
    Begin
      fRe:=fModulo*cos(fArgumento);
      fImg:=fModulo*sin(fArgumento);
    end;

  procedure TComplex.GetPolar;
    Begin
      fModulo:=Sqrt(Power(fRe,2)+Power(fImg,2));
      If fRe=0 then // ------------------------------------ Re(z)=0...
         If fImg=0 then // ---------------------------------- ...Img(z)=0
           fArgumento:=0
         else
           If fImg>0 then // -------------------------------- ...Img(z)>0
             fArgumento:=Pi/2
           else // ------------------------------------------ ...Img(z)<0
             fArgumento:=3*Pi/2
      else
        If fRe>0 then // ---------------------------------- Re(z)>0...
          If fImg=0 then // --------------------------------- ...Img(z)=0
            fArgumento:=0
          else  // ------------------------------------------ ...Img(z)>0 , Img(z)<0
            fArgumento:=arctan(fImg/fRe)
        else  //------------------------------------------- Re(z)<0...
          If fImg>0 then // --------------------------------- ...Img(z)>0
            fArgumento:=arctan(fImg/fRe)+Pi
          else
            If fImg<0 then // ------------------------------- ...Img(z)<0
              fArgumento:=arctan(fImg/fRe)-Pi
            else  // ---------------------------------------- ...Img(z)=0
              fArgumento:=Pi;
    end;

  { Métodos públicos}
  procedure TComplex.Suma(a,b:TComplex);
    Begin
      fRe:=StrToFloat(a.Re)+StrToFloat(b.Re);
      fImg:=StrToFloat(a.Img)+StrToFloat(b.Img);
      GetPolar;
    end;