jcl-checkins-diff Mailing List for JEDI Code Library (Page 35)

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 3042
          http://jcl.svn.sourceforge.net/jcl/?rev=3042&view=rev
Author:   rrossmair
Date:     2009-10-08 04:55:10 +0000 (Thu, 08 Oct 2009)

Log Message:
-----------
additions to complex number code

Modified Paths:
--------------
    trunk/jcl/source/common/JclMath.pas

Modified: trunk/jcl/source/common/JclMath.pas
===================================================================

--- trunk/jcl/source/common/JclMath.pas	2009-10-05 17:06:06 UTC (rev 3041)
+++ trunk/jcl/source/common/JclMath.pas	2009-10-08 04:55:10 UTC (rev 3042)
@@ -693,31 +693,11 @@
 { Complex numbers }
 
 type
-  TPolarComplex = record
-    Radius: Float;
-    Angle: Float;
-    {$IFDEF SUPPORTS_CLASS_OPERATORS}
-    class operator Implicit(const Value: Float): TPolarComplex;
-    class operator Equal(const Z1, Z2: TPolarComplex): Boolean;
-    class operator NotEqual(const Z1, Z2: TPolarComplex): Boolean;
-    class operator Add(const Z1, Z2: TPolarComplex): TPolarComplex;
-    class operator Subtract(const Z1, Z2: TPolarComplex): TPolarComplex;
-    class operator Multiply(const Z1, Z2: TPolarComplex): TPolarComplex;
-    class operator Divide(const Z1, Z2: TPolarComplex): TPolarComplex;
-    class operator Negative(const Z: TPolarComplex): TPolarComplex;
-    {$ENDIF SUPPORTS_CLASS_OPERATORS}
-  end;
-
   TRectComplex = record
     Re: Float;
     Im: Float;
     {$IFDEF SUPPORTS_CLASS_OPERATORS}
     class operator Implicit(const Value: Float): TRectComplex;
-    class operator Implicit(const Z: TPolarComplex): TRectComplex;
-    class operator Implicit(const Z: TRectComplex): TPolarComplex;
-    // OK with Delphi, but will yield errors in .hpp files:
-    // class operator Explicit(const Z: TPolarComplex): TRectComplex;
-    // class operator Explicit(const Z: TRectComplex): TPolarComplex;
     class operator Equal(const Z1, Z2: TRectComplex): Boolean;
     class operator NotEqual(const Z1, Z2: TRectComplex): Boolean;
     class operator Add(const Z1, Z2: TRectComplex): TRectComplex;
@@ -725,11 +705,60 @@
     class operator Multiply(const Z1, Z2: TRectComplex): TRectComplex;
     class operator Divide(const Z1, Z2: TRectComplex): TRectComplex;
     class operator Negative(const Z: TRectComplex): TRectComplex;
-    // added in rev. 1482; what does it offer over function Exp below??
-    class function Exp(const Z: TRectComplex): TPolarComplex; static; inline;
+    class operator Positive(const Z: TRectComplex): TRectComplex;
+    function AsString: string;
+    function Conjugate: TRectComplex;
+    function IsZero: Boolean;
+    function IsInfinite: Boolean;
     {$ENDIF SUPPORTS_CLASS_OPERATORS}
   end;
 
+  TPolarComplex = record
+    Radius: Float;
+    Angle: Float;
+    {$IFDEF SUPPORTS_CLASS_OPERATORS}
+    class operator Implicit(const Value: Float): TPolarComplex;
+    class operator Implicit(const Z: TPolarComplex): TRectComplex;
+    class operator Implicit(const Z: TRectComplex): TPolarComplex;
+    {$IFNDEF CPPBUILDER}
+    // OK with Delphi, but will yield errors in .hpp files:
+    class operator Explicit(const Z: TPolarComplex): TRectComplex;
+    class operator Explicit(const Z: TRectComplex): TPolarComplex;
+    {$ENDIF CPPBUILDER}
+    class operator Equal(const Z1, Z2: TPolarComplex): Boolean;
+    class operator NotEqual(const Z1, Z2: TPolarComplex): Boolean;
+    class operator Add(const Z1, Z2: TPolarComplex): TRectComplex;
+    class operator Subtract(const Z1, Z2: TPolarComplex): TRectComplex;
+    class operator Multiply(const Z1, Z2: TPolarComplex): TPolarComplex;
+    class operator Divide(const Z1, Z2: TPolarComplex): TPolarComplex;
+    class operator Negative(const Z: TPolarComplex): TPolarComplex;
+    class operator Positive(const Z: TPolarComplex): TPolarComplex;
+    function AsString: string;
+    function Conjugate: TPolarComplex;
+    function IsZero: Boolean;
+    function IsInfinite: Boolean;
+    function Power(const Exponent: TRectComplex): TPolarComplex; overload;
+    function Power(const Exponent: Float): TPolarComplex; overload;
+    function Power(const Exponent: Integer): TPolarComplex; overload;
+    // computes the kth nth root, k in 1..n
+    function Root(const K, N: Cardinal): TPolarComplex;
+    {$ENDIF SUPPORTS_CLASS_OPERATORS}
+  end;
+
+{$IFDEF DEBUG}
+var
+  // accumulated count of (computational costly) TRectComplex <-> TPolarComplex conversions
+  ComplexTypeConversions: Cardinal;
+{$ENDIF DEBUG}
+
+// sets format string for ComplexToStr(TRectComplex) and TRectComplex.AsString
+procedure SetRectComplexFormatStr(const S: string);
+// sets format string for ComplexToStr(TPolarComplex) and TPolarComplex.AsString
+procedure SetPolarComplexFormatStr(const S: string);
+
+function ComplexToStr(const Z: TRectComplex): string; overload;
+function ComplexToStr(const Z: TPolarComplex): string; overload;
+
 function RectComplex(const Re: Float; const Im: Float = 0): TRectComplex; overload;
 function RectComplex(const Z: TPolarComplex): TRectComplex; overload;
 function PolarComplex(const Radius: Float; const Angle: Float = 0): TPolarComplex; overload;
@@ -759,6 +788,7 @@
 function Diff(const Z1, Z2: TRectComplex): TRectComplex;
 function Product(const Z1, Z2: TRectComplex): TRectComplex; overload;
 function Product(const Z1, Z2: TPolarComplex): TPolarComplex; overload;
+function Product(const Z: array of TPolarComplex): TPolarComplex; overload;
 function Quotient(const Z1, Z2: TRectComplex): TRectComplex; overload;
 function Quotient(const Z1, Z2: TPolarComplex): TPolarComplex; overload;
 
@@ -767,6 +797,8 @@
 function Power(const Z: TPolarComplex; const Exponent: TRectComplex): TPolarComplex; overload;
 function Power(const Z: TPolarComplex; const Exponent: Float): TPolarComplex; overload;
 function PowerInt(const Z: TPolarComplex; const Exponent: Integer): TPolarComplex; overload;
+// a complex number has n different nth roots in the complex plane
+// Root() computes the kth nth root, k in 1..n
 function Root(const Z: TPolarComplex; const K, N: Cardinal): TPolarComplex;
 
 function Cos(const Z: TRectComplex): TRectComplex; overload;
@@ -4064,8 +4096,31 @@
 const
   RectOne: TRectComplex = (Re: 1.0; Im: 0.0);
   RectZero: TRectComplex = (Re: 0.0; Im: 0.0);
-  //RectInfinity: TRectComplex = (Re: Infinity; Im: Infinity);
 
+var
+  RectComplexFormatStr: string = '%g + %gi';
+  PolarComplexFormatStr: string = '%g e^%gi';
+
+procedure SetRectComplexFormatStr(const S: string);
+begin
+  RectComplexFormatStr := S;
+end;
+
+procedure SetPolarComplexFormatStr(const S: string);
+begin
+  PolarComplexFormatStr := S;
+end;
+
+function ComplexToStr(const Z: TRectComplex): string;
+begin
+  Result := Format(RectComplexFormatStr, [Z.Re, Z.Im]);
+end;
+
+function ComplexToStr(const Z: TPolarComplex): string;
+begin
+  Result := Format(PolarComplexFormatStr, [Z.Radius, Z.Angle]);
+end;
+
 function RectComplex(const Re: Float; const Im: Float = 0): TRectComplex;
 begin
   Result.Re := Re;
@@ -4076,6 +4131,9 @@
 var
   ASin, ACos: Float;
 begin
+  {$IFDEF DEBUG}
+  Inc(ComplexTypeConversions);
+  {$ENDIF DEBUG}
   SinCos(Z.Angle, ASin, ACos);
   Result.Re := Z.Radius * ACos;
   Result.Im := Z.Radius * ASin;
@@ -4085,7 +4143,7 @@
 begin
   if Radius < 0 then
   begin
-    Result.Radius := Abs(Radius);
+    Result.Radius := -Radius;
     Result.Angle := Pi;
   end
   else
@@ -4097,6 +4155,9 @@
 
 function PolarComplex(const Z: TRectComplex): TPolarComplex;
 begin
+  {$IFDEF DEBUG}
+  Inc(ComplexTypeConversions);
+  {$ENDIF DEBUG}
   Result.Radius := Norm(Z);
   Result.Angle := ArcTan2(Z.Im, Z.Re);
 end;
@@ -4152,13 +4213,13 @@
   Result := Sqr(Z.Radius);
 end;
 
-function Conjugate(const Z: TRectComplex): TRectComplex; overload;
+function Conjugate(const Z: TRectComplex): TRectComplex;
 begin
   Result.Re :=  Z.Re;
   Result.Im := -Z.Im;
 end;
 
-function Conjugate(const Z: TPolarComplex): TPolarComplex; overload;
+function Conjugate(const Z: TPolarComplex): TPolarComplex;
 begin
   Result.Radius :=  Z.Radius;
   Result.Angle := -Z.Angle;
@@ -4179,13 +4240,13 @@
   Result.Angle := - Z.Angle;
 end;
 
-function Neg(const Z: TRectComplex): TRectComplex; overload;
+function Neg(const Z: TRectComplex): TRectComplex;
 begin
   Result.Re := -Z.Re;
   Result.Im := -Z.Im;
 end;
 
-function Neg(const Z: TPolarComplex): TPolarComplex; overload;
+function Neg(const Z: TPolarComplex): TPolarComplex;
 begin
   Result.Radius := Z.Radius;
   Result.Angle := NormalizeAngle(Z.Angle + Pi);
@@ -4227,6 +4288,21 @@
   Result.Angle := NormalizeAngle(Z1.Angle + Z2.Angle);
 end;
 
+function Product(const Z: array of TPolarComplex): TPolarComplex;
+var
+  I: Integer;
+begin
+  Result.Radius := 1.0;
+  Result.Angle := 0;
+  for I := Low(Z) to High(Z) do
+  begin
+    Result.Radius := Result.Radius * Z[I].Radius;
+    Result.Angle := Result.Angle + Z[I].Angle;
+  end;
+  Result.Angle := NormalizeAngle(Result.Angle);
+end;
+
+
 function Quotient(const Z1, Z2: TRectComplex): TRectComplex;
 var
   Denom: Float;
@@ -4383,115 +4459,182 @@
 
 {$IFDEF SUPPORTS_CLASS_OPERATORS}
 
-{ TPolarComplex }
+{ TRectComplex }
 
-class operator TPolarComplex.Implicit(const Value: Float): TPolarComplex;
+class operator TRectComplex.Implicit(const Value: Float): TRectComplex;
 begin
-  Result := PolarComplex(Value);
+  Result := RectComplex(Value);
 end;
 
-class operator TPolarComplex.Equal(const Z1, Z2: TPolarComplex): Boolean;
+class operator TRectComplex.Equal(const Z1, Z2: TRectComplex): Boolean;
 begin
   Result := Equal(Z1, Z2);
 end;
 
-class operator TPolarComplex.NotEqual(const Z1, Z2: TPolarComplex): Boolean;
+class operator TRectComplex.NotEqual(const Z1, Z2: TRectComplex): Boolean;
 begin
   Result := not Equal(Z1, Z2);
 end;
 
-class operator TPolarComplex.Add(const Z1, Z2: TPolarComplex): TPolarComplex;
+class operator TRectComplex.Add(const Z1, Z2: TRectComplex): TRectComplex;
 begin
   Result := Sum(Z1, Z2);
 end;
 
-class operator TPolarComplex.Subtract(const Z1, Z2: TPolarComplex): TPolarComplex;
+class operator TRectComplex.Subtract(const Z1, Z2: TRectComplex): TRectComplex;
 begin
   Result := Diff(Z1, Z2);
 end;
 
-class operator TPolarComplex.Multiply(const Z1, Z2: TPolarComplex): TPolarComplex;
+class operator TRectComplex.Multiply(const Z1, Z2: TRectComplex): TRectComplex;
 begin
   Result := Product(Z1, Z2);
 end;
 
-class operator TPolarComplex.Divide(const Z1, Z2: TPolarComplex): TPolarComplex;
+class operator TRectComplex.Divide(const Z1, Z2: TRectComplex): TRectComplex;
 begin
   Result := Quotient(Z1, Z2);
 end;
 
-class operator TPolarComplex.Negative(const Z: TPolarComplex): TPolarComplex;
+class operator TRectComplex.Negative(const Z: TRectComplex): TRectComplex;
 begin
   Result := Neg(Z);
 end;
 
-{ TRectComplex }
+class operator TRectComplex.Positive(const Z: TRectComplex): TRectComplex;
+begin
+  Result := Z;
+end;
 
-class operator TRectComplex.Implicit(const Value: Float): TRectComplex;
+function TRectComplex.AsString: string;
 begin
-  Result := RectComplex(Value);
+  Result := ComplexToStr(Self);
 end;
 
-class operator TRectComplex.Implicit(const Z: TPolarComplex): TRectComplex;
+function TRectComplex.Conjugate: TRectComplex;
 begin
+  Result := JclMath.Conjugate(Self);
+end;
+
+function TRectComplex.IsZero: Boolean;
+begin
+  Result := JclMath.IsZero(Self);
+end;
+
+function TRectComplex.IsInfinite: Boolean;
+begin
+  Result := JclMath.IsInfinite(Self);
+end;
+
+{ TPolarComplex }
+
+class operator TPolarComplex.Implicit(const Value: Float): TPolarComplex;
+begin
+  Result := PolarComplex(Value);
+end;
+
+class operator TPolarComplex.Implicit(const Z: TPolarComplex): TRectComplex;
+begin
   Result := RectComplex(Z);
 end;
 
-class operator TRectComplex.Implicit(const Z: TRectComplex): TPolarComplex;
+class operator TPolarComplex.Implicit(const Z: TRectComplex): TPolarComplex;
 begin
   Result := PolarComplex(Z);
 end;
-{
-class operator TRectComplex.Explicit(const Z: TPolarComplex): TRectComplex;
+
+{$IFNDEF CPPBUILDER}
+class operator TPolarComplex.Explicit(const Z: TPolarComplex): TRectComplex;
 begin
   Result := RectComplex(Z);
 end;
 
-class operator TRectComplex.Explicit(const Z: TRectComplex): TPolarComplex;
+class operator TPolarComplex.Explicit(const Z: TRectComplex): TPolarComplex;
 begin
   Result := PolarComplex(Z);
 end;
-}
-class operator TRectComplex.Equal(const Z1, Z2: TRectComplex): Boolean;
+{$ENDIF CPPBUILDER}
+
+class operator TPolarComplex.Equal(const Z1, Z2: TPolarComplex): Boolean;
 begin
   Result := Equal(Z1, Z2);
 end;
 
-class operator TRectComplex.NotEqual(const Z1, Z2: TRectComplex): Boolean;
+class operator TPolarComplex.NotEqual(const Z1, Z2: TPolarComplex): Boolean;
 begin
   Result := not Equal(Z1, Z2);
 end;
 
-class operator TRectComplex.Add(const Z1, Z2: TRectComplex): TRectComplex;
+class operator TPolarComplex.Add(const Z1, Z2: TPolarComplex): TRectComplex;
 begin
   Result := Sum(Z1, Z2);
 end;
 
-class operator TRectComplex.Subtract(const Z1, Z2: TRectComplex): TRectComplex;
+class operator TPolarComplex.Subtract(const Z1, Z2: TPolarComplex): TRectComplex;
 begin
   Result := Diff(Z1, Z2);
 end;
 
-class operator TRectComplex.Multiply(const Z1, Z2: TRectComplex): TRectComplex;
+class operator TPolarComplex.Multiply(const Z1, Z2: TPolarComplex): TPolarComplex;
 begin
   Result := Product(Z1, Z2);
 end;
 
-class operator TRectComplex.Divide(const Z1, Z2: TRectComplex): TRectComplex;
+class operator TPolarComplex.Divide(const Z1, Z2: TPolarComplex): TPolarComplex;
 begin
   Result := Quotient(Z1, Z2);
 end;
 
-class operator TRectComplex.Negative(const Z: TRectComplex): TRectComplex;
+class operator TPolarComplex.Negative(const Z: TPolarComplex): TPolarComplex;
 begin
   Result := Neg(Z);
 end;
 
-class function TRectComplex.Exp(const Z: TRectComplex): TPolarComplex;
+class operator TPolarComplex.Positive(const Z: TPolarComplex): TPolarComplex;
 begin
-  Result := JclMath.Exp(Z);
+  Result := Z;
 end;
 
+function TPolarComplex.AsString: string;
+begin
+  Result := ComplexToStr(Self);
+end;
+
+function TPolarComplex.Conjugate: TPolarComplex;
+begin
+  Result := JclMath.Conjugate(Self);
+end;
+
+function TPolarComplex.IsZero: Boolean;
+begin
+  Result := JclMath.IsZero(Self);
+end;
+
+function TPolarComplex.IsInfinite: Boolean;
+begin
+  Result := JclMath.IsInfinite(Self);
+end;
+
+function TPolarComplex.Power(const Exponent: TRectComplex): TPolarComplex;
+begin
+  Result := JclMath.Power(Self, Exponent);
+end;
+
+function TPolarComplex.Power(const Exponent: Float): TPolarComplex;
+begin
+  Result := JclMath.Power(Self, Exponent);
+end;
+
+function TPolarComplex.Power(const Exponent: Integer): TPolarComplex;
+begin
+  Result := JclMath.PowerInt(Self, Exponent);
+end;
+
+function TPolarComplex.Root(const K, N: Cardinal): TPolarComplex;
+begin
+  Result := JclMath.Root(Self, K, N);
+end;
+
 {$ENDIF SUPPORTS_CLASS_OPERATORS}
 
 {$IFDEF UNITVERSIONING}


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




2006	Jan	Feb	Mar	Apr (20)	May (48)	Jun (8)	Jul (23)	Aug (41)	Sep (42)	Oct (22)	Nov (17)	Dec (36)
2007	Jan (43)	Feb (42)	Mar (17)	Apr (39)	May (16)	Jun (35)	Jul (37)	Aug (47)	Sep (49)	Oct (9)	Nov (52)	Dec (37)
2008	Jan (48)	Feb (21)	Mar (7)	Apr (2)	May (5)	Jun (17)	Jul (17)	Aug (40)	Sep (58)	Oct (38)	Nov (19)	Dec (32)
2009	Jan (67)	Feb (46)	Mar (54)	Apr (34)	May (37)	Jun (52)	Jul (67)	Aug (72)	Sep (48)	Oct (35)	Nov (27)	Dec (12)
2010	Jan (56)	Feb (46)	Mar (19)	Apr (14)	May (21)	Jun (3)	Jul (13)	Aug (48)	Sep (34)	Oct (51)	Nov (16)	Dec (32)
2011	Jan (36)	Feb (14)	Mar (12)	Apr (3)	May (5)	Jun (24)	Jul (15)	Aug (30)	Sep (21)	Oct (4)	Nov (25)	Dec (23)
2012	Jan (45)	Feb (42)	Mar (19)	Apr (14)	May (13)	Jun (7)	Jul (3)	Aug (46)	Sep (21)	Oct (10)	Nov (2)	Dec
2013	Jan (5)	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec

jcl-checkins-diff Mailing List for JEDI Code Library (Page 35)

jcl-checkins-diff — SVN file check-in notifications with file differences included