home *** CD-ROM | disk | FTP | other *** search
/ Delphi Programming Unleashed / Delphi_Programming_Unleashed_SAMS_Publishing_1995.iso / units / mathbox.pas < prev    next >
Pascal/Delphi Source File  |  1995-03-20  |  8KB  |  299 lines
  1. unit Mathbox;
  2. {$N+}
  3.  
  4. { 
  5.   This unit contains routines that are useful when you need to work 
  6. with numbers. The routines you find here are of one basic type:
  7.  
  8.   + Conversion programs which translate numbers into strings.
  9.  
  10. }
  11.  
  12. interface
  13.  
  14. function ArcCos(x: Real): Real;
  15. function ArcSin(x: Real): Real;
  16. function Comp2Str(N: Comp): String;
  17. function Int2StrPad0(N: LongInt; Len: Integer): String;
  18. function Int2Str(N: LongInt): String;
  19. function IsEqual(R1, R2: Double): Boolean;
  20. function LogXY(x, y: Real): Real;
  21. function Pennies2Dollars(C: Comp): String;
  22. function Power(X: Integer; Y: Integer): Real;
  23. function Real2Str(N: Real; Width, Places: integer): String;
  24. function Str2Comp(MyString: string): Comp;
  25. function Str2Pennies(S: String): Comp;
  26. function Str2Real(MyString: string): Real;
  27. function XToTheY(x, y: Real): Real;
  28.  
  29. implementation
  30.  
  31. uses
  32.   StrBox;
  33.  
  34. {----------------------------------------------------
  35.        Name: ArcCos function
  36. Declaration: function ArcCos(x: Real): Real;
  37.        Unit: MathBox
  38.        Code: N
  39.        Date: 02/20/94
  40. Description: Find the ArcCos of a Real
  41. -----------------------------------------------------}
  42. function ArcCos(x: Real): Real;
  43. begin
  44.   ArcCos := ArcTan(Sqrt(1 - Sqr(x)) / x);
  45. end;
  46.  
  47.  
  48. {----------------------------------------------------
  49.        Name: ArcSin function
  50. Declaration: function ArcSin(x: Real): Real;
  51.        Unit: MathBox
  52.        Code: N
  53.        Date: 02/20/94
  54. Description: Find the ArcSin of a Real
  55. -----------------------------------------------------}
  56. function ArcSin(x: Real): Real;
  57. begin
  58.   ArcSin := ArcTan(x / Sqrt( 1 - Sqr(x)) / x);
  59. end;
  60.  
  61. {----------------------------------------------------
  62.        Name: Comp2Str function
  63. Declaration: Comp2Str(N: real; Width, Places: integer)
  64.        Unit: MathBox
  65.        Code: N
  66.        Date: 02/17/94
  67. Description: Converts a Comp into a String
  68. -----------------------------------------------------}
  69. function Comp2Str(N: Comp): String;
  70. var
  71.   TempString: String;
  72. begin
  73.   Str(N:0:0, TempString);
  74.   Comp2Str := TempString;
  75. end;
  76.  
  77. {----------------------------------------------------
  78.        Name: Int2Str function
  79. Declaration: Int2Str(N: LongInt): String;
  80.        Unit: MathBox
  81.        Code: N
  82.        Date: 06/25/94
  83. Description: Converts a number into a string and pads
  84.              the string with zeros if it is less than
  85.              Len characters long.
  86. -----------------------------------------------------}
  87. function Int2Str(N: LongInt): String;
  88. var
  89.   S : String;
  90. begin
  91.   Str(N:0,S);
  92.   Int2Str := S;
  93. end;
  94.  
  95. {----------------------------------------------------
  96.        Name: Int2StrPad0 function
  97. Declaration: Int2StrPad0(N: LongInt; Len: Integer): String;
  98.        Unit: MathBox
  99.        Code: N
  100.        Date: 03/01/94
  101. Description: Converts a number into a string and pads
  102.              the string with zeros if it is less than
  103.              Len characters long.
  104. -----------------------------------------------------}
  105. function Int2StrPad0(N: LongInt; Len: Integer): String;
  106. var
  107.   S : String;
  108. begin
  109.   Str(N:0,S);
  110.   while Length(S) < Len do
  111.     S := '0' + S;
  112.   Int2StrPad0 := S;
  113. end;
  114.  
  115. {----------------------------------------------------
  116.        Name: IsEqual function
  117. Declaration: IsEqual(R1, R2: Double): Boolean;
  118.        Unit: MathBox
  119.        Code: N
  120.        Date: 07/04/94
  121. Description: Tests to see if two doubles are effectively
  122.              equal. Floating point numbers are never
  123.              exact, so we need an approximation.
  124. -----------------------------------------------------}
  125. function IsEqual(R1, R2: Double): Boolean;
  126. var
  127.   R : Double;
  128. begin
  129.   R := Abs(R1 - R2);
  130.   if R > 0.0001 then
  131.     IsEqual := False
  132.   else
  133.     IsEqual := True;
  134. end;
  135.  
  136. {----------------------------------------------------
  137.        Name: LogXY function
  138. Declaration: function LogXY(x: Real): Real;
  139.        Unit: MathBox
  140.        Code: N
  141.        Date: 02/20/94
  142. Description: Log of X Y
  143. -----------------------------------------------------}
  144. function LogXY(x, y: Real): Real;
  145. begin
  146.   LogXY := Ln(x) / Ln(y);
  147. end;
  148.  
  149. {----------------------------------------------------
  150.        Name: Pennies2Dollars function
  151. Declaration: Pennies2Dollars(C: Comp): String;
  152.        Unit: MathBox
  153.        Code: N
  154.        Date: 02/17/94    
  155. Description: Converts a Comp type that represents a
  156.          certain number of pennies into a string
  157.              with two decimal places. 123 => $1.23
  158. -----------------------------------------------------}
  159. function Pennies2Dollars(C: Comp): String;
  160. var
  161.   S: string;
  162. begin
  163.   S := Comp2Str(C);
  164.   Insert('.', S, Length(S) - 1);
  165.  
  166.   if S[1] = '-' then begin           { Number negative? }
  167.     S := StripFrontChars(S, '-');
  168.     S := '-$' + S;
  169.   end else
  170.     S := '$' + S;
  171.  
  172.   Pennies2Dollars := S;
  173. end;
  174.  
  175. {----------------------------------------------------
  176.        Name: Power function
  177. Declaration: Power(X: Integer; Y: Integer): Real;
  178.        Unit: MathBox
  179.        Code: N
  180.        Date: 02/20/94
  181. Description: Raise X to the Y power
  182. -----------------------------------------------------}
  183. function Power(X: Integer; Y: Integer): Real;
  184. var
  185.   Count: Integer;
  186.   OutCome: Real;
  187. begin
  188.   OutCome := 1;
  189.   for Count := 1 to Y do
  190.     OutCome := OutCome * X;
  191.   Power := OutCome;
  192. end;
  193.  
  194. {----------------------------------------------------
  195.        Name: Real2Str function
  196. Declaration: Real2Str(N: real; Width, Places: integer)
  197.        Unit: MathBox
  198.        Code: N
  199.        Date: 02/17/94
  200. Description: Converts a Real number into a String
  201. -----------------------------------------------------}
  202. function Real2Str(N: Real; Width, Places: integer): String;
  203. var
  204.   TempString: String;
  205. begin
  206.   Str(N:Width:Places, TempString);
  207.   Real2Str := TempString;
  208. end;
  209.  
  210. {----------------------------------------------------
  211.        Name: Str2Comp function
  212. Declaration: Str2Real(MyString: string)
  213.        Unit: MathBox
  214.        Code: N
  215.        Date: 02/17/94
  216. Description: Converts a String to a Comp
  217. -----------------------------------------------------}
  218. function Str2Comp(MyString: string): Comp;
  219. var
  220.   ErrCode: Integer;
  221.   Temp: Comp;
  222. begin
  223.   If Mystring[0] = #0 then Str2Comp := 0
  224.   else begin
  225.     Val(Mystring, Temp, ErrCode);
  226.     if ErrCode = 0 then
  227.       Str2Comp := temp
  228.     else
  229.       Str2Comp := 0;
  230.   end;
  231. end;
  232.  
  233. {----------------------------------------------------
  234.        Name: Str2Pennies function
  235. Declaration: Str2Pennies(MyString: string)
  236.        Unit: MathBox
  237.        Code: N
  238.        Date: 02/17/94    
  239. Description: Converts a String to a Comp
  240. -----------------------------------------------------}
  241. function Str2Pennies(S: String): Comp;
  242. var
  243.   C: Comp;
  244.   i: Integer;
  245.   begin
  246.     if S[1] = '$' then Delete(S, 1, 1);
  247.     i := Pos('.', S);
  248.     if i = Length(S) then begin   { Is last character a period? }
  249.       Delete(S, i, 1);
  250.       S := S + '00';
  251.     end else
  252.       if i <> 0 then begin        { Some pennies?               }
  253.         Delete(S, i, 1);
  254.         if i = (Length(S)) then   { Only one char after decimal?}
  255.           S := S + '0'
  256.       end else
  257.         S := S + '00';            { No decimal, no pennies       }
  258.     C := Str2Comp(S);
  259.     Str2Pennies := C;
  260. end;
  261.  
  262. {----------------------------------------------------
  263.        Name: Str2Real function
  264. Declaration: Str2Real(MyString: string)
  265.        Unit: MathBox
  266.        Code: N
  267.        Date: 02/17/94
  268. Description: Converts a String to Real number
  269. -----------------------------------------------------}
  270. function Str2Real(MyString: string): Real;
  271. var
  272.   ErrCode: Integer;
  273.   Temp: Real;
  274. begin
  275.   If Mystring[0] = #0 then Str2Real := 0
  276.   else begin
  277.     Val(Mystring, Temp, ErrCode);
  278.     if ErrCode = 0 then
  279.       Str2Real := temp
  280.     else
  281.       Str2Real := 0;
  282.   end;
  283. end;
  284.  
  285. {----------------------------------------------------
  286.        Name: XToTheY function
  287. Declaration: XToTheY(x, y: Real): Real;
  288.        Unit: MathBox
  289.        Code: N
  290.        Date: 02/20/94
  291. Description: Raise X to the Y Power
  292. -----------------------------------------------------}
  293. function XToTheY(x, y: Real): Real;
  294. begin
  295.   XToTheY := Exp(y * Ln(x));
  296. end;
  297.  
  298. end.
  299.