Positive Zahlen in negative umwandeln

[divBy0]

Zitat:

Zitat von DeddyH

"Threads, die die Welt nicht braucht" oder "Kollektiver Wahnsinn" fände ich angebrachter :mrgreen:

Kollektiver Wahnsinn finde ich gut... :-D

Vielleicht können wir ja die Lazarus-Sparte umbenennen... :duck:

[Sir Rufo]

@luckie: das gehört eindeutig in die CodeLib :mrgreen:

cu

Oliver

[hathor]

Zitat:

Zitat von Sir Rufo

@luckie: das gehört eindeutig in die CodeLib :mrgreen:

cu

Oliver

Genau - und zwar Folgendes:

Um noch eine sinnvolle (und universelle) Antwort zu bringen:

Delphi-Quellcode:

var zahl : currency;

Zahl:= 3.14; // oder sonst was
Zahl := -abs(Zahl);
Memo1.lines.Add(Format('Zahl: %.2f ', [Zahl]));

[Matze]

Ich hoffe, das meinst du nicht ernst. ;)

und @Manu: Nein, den Source bekommst du nicht. *g*

Edit: Falscher Smiley.

[Missionar]

Gibt es da nicht etwas Performanteres, wie z. B.

Delphi-Quellcode:

procedure NEG(VAR Int: Integer);
assembler
  neg ACX;
end;

[jfheins]

Nein, das skaliert ja mindestens linear also O(n)

Matzes Texterkennungssoftware macht das ja sogar für beliebig viele Zahlen inm konstanter Zeit! O(1) :mrgreen:

P.S. Es geht bereits seit 6,5 Seiten nicht mehr um performante Lösungen ;)

[gammatester]

Vielleicht auch ActiveX (Excel oä). Performant wäre auch irgendwas mit inline.

[Missionar]

Dann müsste Mann es eben noch ausbauen. Vielleicht neben Integer noch, Real, Float, Double, Extended, BCD, Boolean, String, Negation von Klassen und von Pointern :shock:

[Die Muhkuh]

Zitat:

Zitat von Missionar

Negation von Klassen und von Pointern :shock:

Das ist was fürn Neutral General :zwinker:

[sirius]

Da das hier ein rein mathematisches Problem ist, muss man das auch so lösen.
Der Ansatz ist recht simpel. Man negiert eine reelle Zahl indem man sie ins Komplexe überführt und dort mit e^(i*pi) multipliziert. Das klingt jetzt etwas kompliziert, aber wenn man die eulersche Darstellung nimmt, reciht es die Phase mit pi zu summieren.

Delphi-Quellcode:

procedure TForm1.NegButtonClick(Sender: TObject);
var Kart:IKart;
    Euler:IEuler;
begin
  //Vorbereitung
  Kart:=TComplex.create as IKart;
  Kart.Imag:=0;
  Kart.Real:=StrToFloat(Eingabe.Text);
  Euler:=Kart as IEuler;

  //Negation
  Euler.Phase:=Euler.Phase+pi;

  //Ergebnis
  Ausgabe.Caption:=FloatToStr(Kart.Real);

end;

Die beiden Interfaces sehen so aus:

Delphi-Quellcode:

type
  IEuler=Interface
    ['{5EBED258-ACED-4D74-AB9D-C7048887343A}']
    procedure setPhase(value:Double);
    procedure setBetrag(value:Double);
    function getPhase:Double;
    function getBetrag:Double;
    property Phase:Double read getPhase write setPhase;
    property Betrag:Double read getBetrag write setBetrag;
  end;

  IKart=Interface
    ['{93216A14-7CB0-4377-B844-793511F3C24F}']
    procedure setReal(value:double);
    procedure setImag(value:Double);
    function getReal:Double;
    function getImag:Double;
    property Real:Double read getReal write setReal;
    property Imag:Double read getImag write setImag;
  end;

Und die Klasse dazu:

Delphi-Quellcode:

interface

type  
  TComplex=class(TInterfacedObject,IKart,IEuler)
    Constructor Create;
   private
    FReal,FImag:Double;
    FBetrag,FPhase:Double;
    procedure setReal(value:double);
    procedure setImag(value:Double);
    procedure setPhase(value:Double);
    procedure setBetrag(value:Double);

    function getReal:Double;
    function getImag:Double;
    function getPhase:Double;
    function getBetrag:Double;

    procedure Euler2Kart;
    procedure Kart2Euler;
   end;



implementation

{ TComplex }

constructor TComplex.Create;
begin
  FReal:=0;
  FImag:=0;
  FBetrag:=0;
  FPhase:=0;
end;

procedure TComplex.Euler2Kart;
begin
  FReal:=cos(FPhase)*FBetrag;
  FImag:=sin(FPhase)*FBetrag;
end;

function TComplex.getBetrag: Double;
begin
  result:=FBetrag;
end;

function TComplex.getImag: Double;
begin
  result:=FImag;
end;

function TComplex.getPhase: Double;
begin
  result:=FPhase;
end;

function TComplex.getReal: Double;
begin
  result:=FReal;
end;

procedure TComplex.Kart2Euler;
begin
  FBetrag:=sqrt(sqr(FReal)+sqr(FImag));
  asm
    MOV EAX, Self
    FLD QWORD PTR [EAX].FImag
    FLD QWORD PTR [EAX].FReal
    FPATAN
    FWAIT
    FST QWORD PTR [EAX].FPhase
  end;
  if FPhase<0 then FPhase:=FPhase+2*pi;
end;

procedure TComplex.setBetrag(value: Double);
begin
  FBetrag:=value;
  Euler2Kart;
end;

procedure TComplex.setImag(value: Double);
begin
  FImag:=value;
  Kart2Euler;
end;

procedure TComplex.setPhase(value: Double);
begin
  while value<0 do Value:=Value+2*pi;
  while value>=2*pi do Value:=Value-2*pi;
  FPhase:=Value;
  Euler2Kart;
end;

procedure TComplex.setReal(value: double);
begin
  FReal:=value;
  Kart2Euler;
end;

Achja: Für den Arctan musste ich mal kurz auf Assembler zurückgreifen (wegen FPATAN)