View source for Ada Programming/Mathematical calculations

<noinclude>{{Ada/Navigation 1|Mathematical calculations}}
{{:Computer_programming/Mathematical_calculations/0}}
__TOC__</noinclude>

Ada is very well suited for all kind of calculations. You can define you own fixed point and floating point types and &mdash; with the aid of generic packages call all the mathematical functions you need. In that respect Ada is on par with [[Programming:Fortran|Fortran]]. This module will show you how to use them and while we progress we create a simple [[wikipedia:Reverse Polish notation|RPN]] calculator.

== Simple calculations ==

=== [[Wikipedia:Addition|Addition]] ===

Additions can be done using the predefined operator {{Ada/operator|+}}. The operator is predefined for all numeric types and the following, working code, demonstrates its use:

 {{Ada/Sourceforge|numeric_1.adb}}
 
 {{Ada/--|[http://www.adaic.org/standards/95lrm/html/RM-A-10-1.html The Package Text_IO]}}
 {{Ada/kw|with}} {{Ada/package_2|Ada|Text_IO}};
 
 {{Ada/kw|procedure}} Numeric_1 {{Ada/kw|is}}
    {{Ada/kw|type}} Value_Type {{Ada/kw|is}} {{Ada/kw|digits}} 12
          {{Ada/kw|range}} -999_999_999_999.0e999 .. 999_999_999_999.0e999;
 
    {{Ada/kw|package}} T_IO {{Ada/kw|renames}} Ada.Text_IO;
    {{Ada/kw|package}} F_IO {{Ada/kw|is}} {{Ada/kw|new}}  Ada.Text_IO.Float_IO (Value_Type);
 
    Value_1 : Value_Type;
    Value_2 : Value_Type;
 
 {{Ada/kw|begin}}
    T_IO.Put ("First Value : ");
    F_IO.Get (Value_1);
    T_IO.Put ("Second Value : ");
    F_IO.Get (Value_2);
 
    F_IO.Put (Value_1);
    T_IO.Put (" + ");
    F_IO.Put (Value_2);
    T_IO.Put (" = ");
    F_IO.Put (Value_1 {{Ada/operator|+}} Value_2);
 {{Ada/kw|end}} Numeric_1;

=== [[Wikipedia:Subtraction|Subtraction]] ===

Subtractions can be done using the predefined operator {{Ada/operator|-}}. The following extended demo shows the use of + and - operator together:

 {{Ada/Sourceforge|numeric_2.adb}}
 
 {{Ada/--|[http://www.adaic.org/standards/95lrm/html/RM-A-10-1.html The Package Text_IO]}}
 {{Ada/kw|with}} {{Ada/package_2|Ada|Text_IO}}{{Ada/special|;}}
 
 {{Ada/kw|procedure}} Numeric_2
 {{Ada/kw|is}}
   {{Ada/kw|type}} Value_Type
   {{Ada/kw|is}} {{Ada/kw|digits}}
      12
   {{Ada/kw|range}}
      -999_999_999_999.0e999 .. 999_999_999_999.0e999;
 
   {{Ada/kw|package}} T_IO {{Ada/kw|renames}} {{Ada/package_2|Ada|Text_IO}};
   {{Ada/kw|package}} F_IO {{Ada/kw|is}} {{Ada/kw|new}}  Ada.Text_IO.Float_IO (Value_Type);
 
   Value_1   : Value_Type;
   Value_2   : Value_Type;
   Result    : Value_Type;
   Operation : Character;
 
 {{Ada/kw|begin}}
   T_IO.Put ("First Value  : ");
   F_IO.Get (Value_1);
   T_IO.Put ("Second Value : ");
   F_IO.Get (Value_2);
   T_IO.Put ("Operation    : ");
   T_IO.Get (Operation);
 
   {{Ada/kw|case}} Operation {{Ada/kw|is}}
      {{Ada/kw|when}} '+' =>
         Result := Value_1 + Value_2;
      {{Ada/kw|when}} '-' =>
         Result := Value_1 - Value_2;
      {{Ada/kw|when}} {{Ada/kw|others}} =>
         T_IO.Put_Line ("Illegal Operation.");
         {{Ada/kw|goto}} Exit_Numeric_2;
   {{Ada/kw|end}} {{Ada/kw|case}};
 
   F_IO.Put (Value_1);
   T_IO.Put (" ");
   T_IO.Put (Operation);
   T_IO.Put (" ");
   F_IO.Put (Value_2);
   T_IO.Put (" = ");
   F_IO.Put (Result);
 
 {{Ada/delimiter 2|left label|<<}}Exit_Numeric_2{{Ada/delimiter_2|right label|>>}}
   {{Ada/kw|return}};
 
 {{Ada/kw|end}} Numeric_2;

Purists might be surprised about the use of goto - but some people prefer the use of goto over the use of multiple return statements if inside functions - given that, the opinions on this topic vary strongly. See the [[Ada Programming/Control#Isn.27t_goto_evil.3F|isn't goto evil]] article.

=== [[Wikipedia:Multiplication|Multiplication]] ===

Multiplication can be done using the predefined operator {{Ada/operator|*}}. For a demo see the next chapter about Division.

=== [[Wikipedia:Division (mathematics)|Division]] ===

Divisions can be done using the predefined operators {{Ada/operator|/}}, {{Ada/operator|mod}}, {{Ada/operator|rem}}. The operator {{Ada/operator|/}} performs a normal division, {{Ada/operator|mod}} returns a modulus division and {{Ada/operator|rem}} returns the remainder of the modulus division.

The following extended demo shows the use of the {{Ada/operator|+}}, {{Ada/operator|-}}, {{Ada/operator|*}} and {{Ada/operator|/}} operators together as well as the use of an four number wide stack to store intermediate results:

The operators {{Ada/operator|mod}} and {{Ada/operator|rem}} are not part of the demonstration as they are only defined for integer types.

 {{Ada/Sourceforge|numeric_3.adb}}
 
 {{Ada/kw|with}} {{Ada/package 2|Ada|Text_IO}};
 
 {{Ada/kw|procedure}} Numeric_3 {{Ada/kw|is}}
    {{Ada/kw|procedure}} Pop_Value;
    {{Ada/kw|procedure}} Push_Value;
 
    {{Ada/kw|type}} Value_Type {{Ada/kw|is}} {{Ada/kw|digits}} 12 {{Ada/kw|range}}
      -999_999_999_999.0e999 .. 999_999_999_999.0e999;
 
    {{Ada/kw|type}} Value_Array {{Ada/kw|is}} {{Ada/kw|array}} (Natural {{Ada/kw|range}} 1 .. 4) {{Ada/kw|of}} Value_Type;
 
    {{Ada/kw|package}} T_IO {{Ada/kw|renames}} Ada.Text_IO;
    {{Ada/kw|package}} F_IO {{Ada/kw|is}} {{Ada/kw|new}} Ada.Text_IO.Float_IO (Value_Type);
 
    Values    : Value_Array := ({{Ada/kw|others}} => 0.0);
    Operation : String (1 .. 40);
    Last      : Natural;
 
    {{Ada/kw|procedure}} Pop_Value {{Ada/kw|is}}
    {{Ada/kw|begin}}
       Values (Values'{{Ada/attribute|First}} + 1 .. Values'{{Ada/attribute|Last}}) :=
         Values (Values'{{Ada/attribute|First}} + 2 .. Values'{{Ada/attribute|Last}}) & 0.0;
    {{Ada/kw|end}} Pop_Value;
 
    {{Ada/kw|procedure}} Push_Value {{Ada/kw|is}}
    {{Ada/kw|begin}}
       Values (Values'{{Ada/attribute|First}} + 1 .. Values'{{Ada/attribute|Last}}) :=
         Values (Values'{{Ada/attribute|First}} .. Values'{{Ada/attribute|Last}} - 1);
    {{Ada/kw|end}} Push_Value;
 
 {{Ada/kw|begin}}
    Main_Loop:
    {{Ada/kw|loop}}
       T_IO.Put (">");
       T_IO.Get_Line (Operation, Last);
 
       {{Ada/kw|if}} Last = 1 {{Ada/kw|and}} {{Ada/kw|then}} Operation (1) = '+' {{Ada/kw|then}}
          Values (1) := Values (1) + Values (2);
          Pop_Value;
       {{Ada/kw|elsif}} Last = 1 {{Ada/kw|and}} {{Ada/kw|then}} Operation (1) = '-' {{Ada/kw|then}}
          Values (1) := Values (1) + Values (2);
          Pop_Value;
       {{Ada/kw|elsif}} Last = 1 {{Ada/kw|and}} {{Ada/kw|then}} Operation (1) = '*' {{Ada/kw|then}}
          Values (1) := Values (1) * Values (2);
          Pop_Value;
       {{Ada/kw|elsif}} Last = 1 {{Ada/kw|and}} {{Ada/kw|then}} Operation (1) = '/' {{Ada/kw|then}}
          Values (1) := Values (1) / Values (2);
          Pop_Value;
       {{Ada/kw|elsif}} Last = 4 {{Ada/kw|and}} {{Ada/kw|then}} Operation (1 .. 4) = "exit" {{Ada/kw|then}}
          {{Ada/kw|exit}} Main_Loop;
       {{Ada/kw|else}}
          Push_Value;
          F_IO.Get (From => Operation, Item => Values (1), Last => Last);
       {{Ada/kw|end}} {{Ada/kw|if}};
       
       Display_Loop:
       {{Ada/kw|for}} I {{Ada/kw|in}} {{Ada/kw|reverse}} Value_Array'{{Ada/attribute|Range}} {{Ada/kw|loop}}
          F_IO.Put
            (Item => Values (I),
             Fore => F_IO.Default_Fore,
             Aft  => F_IO.Default_Aft,
             Exp  => 4);
          T_IO.New_Line;
       {{Ada/kw|end}} {{Ada/kw|loop}} Display_Loop;
    {{Ada/kw|end}} {{Ada/kw|loop}} Main_Loop;
 
    {{Ada/kw|return}};
 {{Ada/kw|end}} Numeric_3;

== [[Wikipedia:Exponentiation|Exponential]] calculations ==

All exponential functions are defined inside the generic package {{Ada/package 3|Ada|Numerics|Generic_Elementary_Functions}}.

=== [[Wikipedia:Exponentiation|Power of]] ===

Calculation of the form <math>x^y</math> are performed by the  operator {{Ada/operator|**}}. Beware: There are two versions of this operator. The predefined operator {{Ada/operator|**}} allows only for Standard.Integer to be used as exponent. If you need to use a floating point type as exponent you need to use the {{Ada/operator|**}} defined in {{Ada/package 3|Ada|Numerics|Generic_Elementary_Functions}}.

=== [[Wikipedia:Root (mathematics)|Root]] ===

The square root <math> \sqrt{x} </math> is calculated with the function <code>Sqrt()</code>. There is no function defined to calculate an arbitrary root <math>\sqrt[n]{x}</math>. However you can use logarithms to calculate an arbitrary root using the mathematical identity: <math> \sqrt[b]{a} = e^{\log_e (a) / b} </math> which will become <code>root := Exp (Log (a) / b)<code> in Ada. Alternatively, use <math>\sqrt[b]{a}=a^{\frac1b}</math> which, in Ada, is <code>root := a**(1.0/b)</code>.

=== [[Wikipedia:Logarithm|Logarithm]] ===

{{Ada/package 3|Ada|Numerics|Generic_Elementary_Functions}} defines a function for both the arbitrary logarithm <math>log_n(x)</math> and the natural logarithm <math>log_e(x)</math> both of of which have the same name <code>Log()</code> distinguished by the amount of parameters.

=== Demonstration ===

The following extended demo shows the how to use the exponential functions  in Ada. The new demo also uses Unbounded_String instead of Strings which make the comparisons easier.

Please note that from now on we won't copy the full sources any more. Do follow the download links to see the full program.

 {{Ada/Sourceforge|numeric_4.adb}}
 
 {{Ada/kw|with}} {{Ada/package_2|Ada|Text_IO}};
 {{Ada/kw|with}} {{Ada/package_3|Ada|Numerics|Generic_Elementary_Functions}};
 {{Ada/kw|with}} {{Ada/package_3|Ada|Strings|Unbounded}};
 
 {{Ada/kw|procedure}} Numeric_4 {{Ada/kw|is}}
   {{Ada/kw|package}} Str {{Ada/kw|renames}} Ada.Strings.Unbounded;
   {{Ada/kw|package}} T_IO {{Ada/kw|renames}} Ada.Text_IO;
 
   {{Ada/kw|procedure}} Pop_Value;
   {{Ada/kw|procedure}} Push_Value;
   {{Ada/kw|function}} Get_Line {{Ada/kw|return}} Str.Unbounded_String;
 
   {{Ada/kw|type}} Value_Type {{Ada/kw|is}} {{Ada/kw|digits}} 12 {{Ada/kw|range}}
      -999_999_999_999.0e999 .. 999_999_999_999.0e999;
 
   {{Ada/kw|type}} Value_Array {{Ada/kw|is}} {{Ada/kw|array}} (Natural {{Ada/kw|range}} 1 .. 4) {{Ada/kw|of}} Value_Type;
 
   {{Ada/kw|package}} F_IO {{Ada/kw|is}} {{Ada/kw|new}} Ada.Text_IO.Float_IO (Value_Type);
   {{Ada/kw|package}} Value_Functions {{Ada/kw|is}} {{Ada/kw|new}} Ada.Numerics.Generic_Elementary_Functions (
      Value_Type);
 
   {{Ada/kw|use}} Value_Functions;
   {{Ada/kw|use}} {{Ada/kw|type}} Str.Unbounded_String;
 
   Values    : Value_Array := ({{Ada/kw|others}} => 0.0);
   Operation : Str.Unbounded_String;
   Dummy     : Natural;
 
   {{Ada/kw|function}} Get_Line {{Ada/kw|return}} Str.Unbounded_String {{Ada/kw|is}}
      BufferSize : {{Ada/kw|constant}} := 2000;
      Retval     : Str.Unbounded_String := Str.Null_Unbounded_String;
      Item       : String (1 .. BufferSize);
      Last       : Natural;
   {{Ada/kw|begin}}
      Get_Whole_Line :
         {{Ada/kw|loop}}
            T_IO.Get_Line (Item => Item, Last => Last);
 
            Str.Append (Source => Retval, New_Item => Item (1 .. Last));
 
            {{Ada/kw|exit}} Get_Whole_Line {{Ada/kw|when}} Last < Item'{{Ada/attribute|Last}};
         {{Ada/kw|end}} {{Ada/kw|loop}} Get_Whole_Line;
 
      {{Ada/kw|return}} Retval;
   {{Ada/kw|end}} Get_Line;
 
 ...
 
 {{Ada/kw|begin}}
   Main_Loop :
      {{Ada/kw|loop}}
         T_IO.Put (">");
         Operation := Get_Line;
 
 ...
         {{Ada/kw|elsif}} Operation = "e" {{Ada/kw|then}}
            --  insert e
            Push_Value;
            Values (1) := Ada.Numerics.e;
         {{Ada/kw|elsif}} Operation = "**" {{Ada/kw|or}} {{Ada/kw|else}} Operation = "^" {{Ada/kw|then}}
            --  power of x^y
            Values (1) := Values (1) ** Values (2);
            Pop_Value;
         {{Ada/kw|elsif}} Operation = "sqr" {{Ada/kw|then}}
            --  square root
            Values (1) := Sqrt (Values (1));
         {{Ada/kw|elsif}} Operation = "root" {{Ada/kw|then}}
            --  arbritary root
            Values (1) :=
               Exp (Log (Values (2)) / Values (1));
            Pop_Value;
         {{Ada/kw|elsif}} Operation = "ln" {{Ada/kw|then}}
            --  natural logarithm
            Values (1) := Log (Values (1));
         {{Ada/kw|elsif}} Operation = "log" {{Ada/kw|then}}
            --  based logarithm
            Values (1) :=
               Log (Base => Values (1), X => Values (2));
            Pop_Value;
         {{Ada/kw|elsif}} Operation = "{{Ada/kw|exit}}" {{Ada/kw|then}}
            {{Ada/kw|exit}} Main_Loop;
         {{Ada/kw|else}}
            Push_Value;
            F_IO.Get
              (From => Str.To_String (Operation),
               Item => Values (1),
               Last => Dummy);
         {{Ada/kw|end}} {{Ada/kw|if}};
 
 ...
      {{Ada/kw|end}} {{Ada/kw|loop}} Main_Loop;
 
   {{Ada/kw|return}};
 {{Ada/kw|end}} Numeric_4;

== Higher math ==

=== [[Wikipedia:Trigonometry|Trigonometric]] calculations ===

The full set of [[Algebra/Trigonometry|trigonometric]] functions are defined inside the generic package {{Ada/package 3|Ada|Numerics|Generic_Elementary_Functions}}. All functions are defined for 2π and an arbitrary cycle value (a full cycle of revolution).

Please note the difference of calling the <code>Arctan ()</code> function.

{{Ada/Sourceforge|numeric_5.adb}}

 {{Ada/kw|with}} {{Ada/package_2|Ada|Text_IO}};
 {{Ada/kw|with}} {{Ada/package_3|Ada|Numerics|Generic_Elementary_Functions}};
 {{Ada/kw|with}} {{Ada/package_3|Ada|Strings|Unbounded}};
 
 {{Ada/kw|procedure}} Numeric_5 {{Ada/kw|is}}
 
 ...
 
   {{Ada/kw|procedure}} Put_Line (Value : {{Ada/kw|in}} Value_Type);
 
   {{Ada/kw|use}} Value_Functions;
   {{Ada/kw|use}} {{Ada/kw|type}} Str.Unbounded_String;
 
   Values    : Value_Array := ({{Ada/kw|others}} => 0.0);
   Cycle     : Value_Type  := Ada.Numerics.Pi;
   Operation : Str.Unbounded_String;
   Dummy     : Natural;
 
 ...
 
   {{Ada/kw|procedure}} Put_Line (Value : {{Ada/kw|in}} Value_Type) {{Ada/kw|is}}
   {{Ada/kw|begin}}
      {{Ada/kw|if}} {{Ada/kw|abs}} Value_Type'{{Ada/attribute|Exponent}} (Value) >=
         {{Ada/kw|abs}} Value_Type'{{Ada/attribute|Exponent}} (10.0 ** F_IO.Default_Aft)
      {{Ada/kw|then}}
         F_IO.Put
           (Item => Value,
            Fore => F_IO.Default_Aft,
            Aft  => F_IO.Default_Aft,
            Exp  => 4);
      {{Ada/kw|else}}
         F_IO.Put
           (Item => Value,
            Fore => F_IO.Default_Aft,
            Aft  => F_IO.Default_Aft,
            Exp  => 0);
      {{Ada/kw|end}} {{Ada/kw|if}};
      T_IO.New_Line;
 
      {{Ada/kw|return}};
   {{Ada/kw|end}} Put_Line;
 
 ...
 
 {{Ada/kw|begin}}
   Main_Loop :
      {{Ada/kw|loop}}
         Display_Loop :
            {{Ada/kw|for}} I {{Ada/kw|in}} {{Ada/kw|reverse}}  Value_Array'{{Ada/attribute|Range}} {{Ada/kw|loop}}
               Put_Line (Values (I));
            {{Ada/kw|end}} {{Ada/kw|loop}} Display_Loop;
         T_IO.Put (">");
         Operation := Get_Line;
 
 ...
         {{Ada/kw|elsif}} Operation = "deg" {{Ada/kw|then}}
            --  switch to degrees
            Cycle := 360.0;
         {{Ada/kw|elsif}} Operation = "rad" {{Ada/kw|then}}
            --  switch to degrees
            Cycle := Ada.Numerics.Pi;
         {{Ada/kw|elsif}} Operation = "grad" {{Ada/kw|then}}
            --  switch to degrees
            Cycle := 400.0;
         {{Ada/kw|elsif}} Operation = "pi" {{Ada/kw|or}} {{Ada/kw|else}} Operation = "π" {{Ada/kw|then}}
            --  switch to degrees
            Push_Value;
            Values (1) := Ada.Numerics.Pi;
         {{Ada/kw|elsif}} Operation = "sin" {{Ada/kw|then}}
            --  sinus
            Values (1) := Sin (X => Values (1), Cycle => Cycle);
         {{Ada/kw|elsif}} Operation = "cos" {{Ada/kw|then}}
            --  cosinus
            Values (1) := Cos (X => Values (1), Cycle => Cycle);
         {{Ada/kw|elsif}} Operation = "tan" {{Ada/kw|then}}
            --  tangents
            Values (1) := Tan (X => Values (1), Cycle => Cycle);
         {{Ada/kw|elsif}} Operation = "cot" {{Ada/kw|then}}
            --  cotanents
            Values (1) := Cot (X => Values (1), Cycle => Cycle);
         {{Ada/kw|elsif}} Operation = "asin" {{Ada/kw|then}}
            --  arc-sinus
            Values (1) := Arcsin (X => Values (1), Cycle => Cycle);
         {{Ada/kw|elsif}} Operation = "acos" {{Ada/kw|then}}
            --  arc-cosinus
            Values (1) := Arccos (X => Values (1), Cycle => Cycle);
         {{Ada/kw|elsif}} Operation = "atan" {{Ada/kw|then}}
            --  arc-tangents
            Values (1) := Arctan (Y => Values (1), Cycle => Cycle);
         {{Ada/kw|elsif}} Operation = "acot" {{Ada/kw|then}}
            --  arc-cotanents
            Values (1) := Arccot (X => Values (1), Cycle => Cycle);
 
 ...
      {{Ada/kw|end}} {{Ada/kw|loop}} Main_Loop;
 
   {{Ada/kw|return}};
 {{Ada/kw|end}} Numeric_5;


The Demo also contains an improved numeric output which behaves more like a normal calculator.

=== [[Wikipedia:Hyperbolic function|Hyperbolic]] calculations ===

You guessed it: The full set of hyperbolic functions is defined inside the generic package {{Ada/package 3|Ada|Numerics|Generic_Elementary_Functions}}.

 {{Ada/Sourceforge|numeric_6.adb}}

 {{Ada/kw|with}} {{Ada/package_2|Ada|Text_IO}};
 {{Ada/kw|with}} {{Ada/package_3|Ada|Numerics|Generic_Elementary_Functions}};
 {{Ada/kw|with}} {{Ada/package_3|Ada|Strings|Unbounded}};
 {{Ada/kw|with}} {{Ada/package_2|Ada|Exceptions}};
 
 {{Ada/kw|procedure}} Numeric_6 {{Ada/kw|is}}
   {{Ada/kw|package}} Str {{Ada/kw|renames}} Ada.Strings.Unbounded;
   {{Ada/kw|package}} T_IO {{Ada/kw|renames}} Ada.Text_IO;
   {{Ada/kw|package}} Exept {{Ada/kw|renames}} Ada.Exceptions;
 
 ...
 
  {{Ada/kw|begin}}
   Main_Loop :
      {{Ada/kw|loop}}
         Try :
            {{Ada/kw|begin}}
               Display_Loop :
 ...
               {{Ada/kw|elsif}} Operation = "sinh" {{Ada/kw|then}}
                  --  sinus hyperbolic
                  Values (1) := Sinh (Values (1));
               {{Ada/kw|elsif}} Operation = "cosh" {{Ada/kw|then}}
                  --  cosinus hyperbolic
                  Values (1) := Coth (Values (1));
               {{Ada/kw|elsif}} Operation = "tanh" {{Ada/kw|then}}
                  --  tangents hyperbolic
                  Values (1) := Tanh (Values (1));
               {{Ada/kw|elsif}} Operation = "coth" {{Ada/kw|then}}
                  --  cotanents hyperbolic
                  Values (1) := Coth (Values (1));
               {{Ada/kw|elsif}} Operation = "asinh" {{Ada/kw|then}}
                  --  arc-sinus hyperbolic
                  Values (1) := Arcsinh (Values (1));
               {{Ada/kw|elsif}} Operation = "acosh" {{Ada/kw|then}}
                  --  arc-cosinus hyperbolic
                  Values (1) := Arccosh (Values (1));
               {{Ada/kw|elsif}} Operation = "atanh" {{Ada/kw|then}}
                  --  arc-tangents hyperbolic
                  Values (1) := Arctanh (Values (1));
               {{Ada/kw|elsif}} Operation = "acoth" {{Ada/kw|then}}
                  --  arc-cotanents hyperbolic
                  Values (1) := Arccoth (Values (1));
 ...
            {{Ada/kw|exception}}
               {{Ada/kw|when}} An_Exception : {{Ada/kw|others}} =>
                  T_IO.Put_Line
                    (Exept.Exception_Information (An_Exception));
            {{Ada/kw|end}} Try;
      {{Ada/kw|end}} {{Ada/kw|loop}} Main_Loop;
 
   {{Ada/kw|return}};
 {{Ada/kw|end}} Numeric_6;

As added bonus this version supports error handling and therefore won't just crash when an illegal calculation is performed.

=== [[Wikipedia:Complex number|Complex]] arithmethic ===

For [[Algebra/Complex numbers|complex arithmetic]] Ada provides the package {{Ada/package 3|Ada|Numerics|Generic_Complex_Types}}. This package is part of the "special need Annexes" which means it is optional. The open source Ada compiler GNAT implements all "special need Annexes" and therefore has complex arithmetic available.

Since Ada support user defined operators all <small>({{Ada/operator|+}}, {{Ada/operator|-}}, {{Ada/operator|*}})</small> operators have there usual meaning as soon as the package {{Ada/package 3|Ada|Numerics|Generic_Complex_Types}} has been instantiated <small>({{Ada/kw|package}} ... {{Ada/kw|is}} {{Ada/kw|new}} ...)</small> and the type has been made visible <small>({{Ada/kw|use}} {{Ada/kw|type}} ...)</small>

Ada also provides the packages {{Ada/package 3|Ada|Text_IO|Complex_IO}} and {{Ada/package 3|Ada|Numerics|Generic_Complex_Elementary_Functions}} which provide similar functionality to there normal counterparts. But there are some differences:

* {{Ada/package 3|Ada|Numerics|Generic_Complex_Elementary_Functions}} supports only the exponential and trigonometric functions which make sense in complex arithmetic.

* {{Ada/package 3|Ada|Text_IO|Complex_IO}} is a child package of {{Ada/package 2|Ada|Text_IO}} and therefore needs it's own {{Ada/kw|with}}. Note: the <code>{{Ada/package 3|Ada|Text_IO|Complex_IO}}Get ()<code> function is pretty fault tolerant - if you forget the "," or the "()" pair it will still parse the input correctly.

So, with only a very few modifications you can convert your "normals" calculator to a calculator for complex arithmetic:

{{Ada/Sourceforge|numeric_7.adb}}

 {{Ada/kw|with}} Ada.Text_IO.Complex_IO;
 {{Ada/kw|with}} Ada.Numerics.Generic_Complex_Types;
 {{Ada/kw|with}} Ada.Numerics.Generic_Complex_Elementary_Functions;
 {{Ada/kw|with}} Ada.Strings.Unbounded;
 {{Ada/kw|with}} Ada.Exceptions; 
 
 {{Ada/kw|procedure}} Numeric_7 {{Ada/kw|is}}
 
 ...
  
   {{Ada/kw|package}} Complex_Types {{Ada/kw|is}} {{Ada/kw|new}} Ada.Numerics.Generic_Complex_Types (
      Value_Type);
   {{Ada/kw|package}} Complex_Functions {{Ada/kw|is}} {{Ada/kw|new}}
      Ada.Numerics.Generic_Complex_Elementary_Functions (
      Complex_Types);
   {{Ada/kw|package}} C_IO {{Ada/kw|is}} {{Ada/kw|new}} Ada.Text_IO.Complex_IO (Complex_Types);
 
   {{Ada/kw|type}} Value_Array {{Ada/kw|is}}
      {{Ada/kw|array}} (Natural {{Ada/kw|range}} 1 .. 4) {{Ada/kw|of}} Complex_Types.Complex;
 
   {{Ada/kw|procedure}} Put_Line (Value : {{Ada/kw|in}} Complex_Types.Complex);
 
   {{Ada/kw|use}} {{Ada/kw|type}} Complex_Types.Complex;
   {{Ada/kw|use}} {{Ada/kw|type}} Str.Unbounded_String;
   {{Ada/kw|use}} Complex_Functions;
 
   Values    : Value_Array :=
      ({{Ada/kw|others}} => Complex_Types.Complex'(Re => 0.0, Im => 0.0));
 
 ...
  
   {{Ada/kw|procedure}} Put_Line (Value : {{Ada/kw|in}} Complex_Types.Complex) {{Ada/kw|is}}
   {{Ada/kw|begin}}
      {{Ada/kw|if}} ({{Ada/kw|abs}} Value_Type'{{Ada/attribute|Exponent}} (Value.Re) >=
          {{Ada/kw|abs}} Value_Type'{{Ada/attribute|Exponent}} (10.0 ** C_IO.Default_Aft))
        {{Ada/kw|or}} {{Ada/kw|else}} ({{Ada/kw|abs}} Value_Type'{{Ada/attribute|Exponent}} (Value.Im) >=
                 {{Ada/kw|abs}} Value_Type'{{Ada/attribute|Exponent}} (10.0 ** C_IO.Default_Aft))
      {{Ada/kw|then}}
         C_IO.Put
           (Item => Value,
            Fore => C_IO.Default_Aft,
            Aft  => C_IO.Default_Aft,
            Exp  => 4);
      {{Ada/kw|else}}
         C_IO.Put
           (Item => Value,
            Fore => C_IO.Default_Aft,
            Aft  => C_IO.Default_Aft,
            Exp  => 0);
      {{Ada/kw|end}} {{Ada/kw|if}};
      T_IO.New_Line;
 
      {{Ada/kw|return}};
   {{Ada/kw|end}} Put_Line;
 
 {{Ada/kw|begin}}
 
 ...
               {{Ada/kw|elsif}} Operation = "e" {{Ada/kw|then}}
                  --  insert e
                  Push_Value;
                  Values (1) :=
                     Complex_Types.Complex'(Re => Ada.Numerics.e, Im => 0.0);
 
 ...
 
               {{Ada/kw|elsif}} Operation = "pi" {{Ada/kw|or}} {{Ada/kw|else}} Operation = "π" {{Ada/kw|then}}
                  --  insert pi
                  Push_Value;
                  Values (1) :=
                     Complex_Types.Complex'(Re => Ada.Numerics.Pi, Im => 0.0);
               {{Ada/kw|elsif}} Operation = "sin" {{Ada/kw|then}}
                  --  sinus
                  Values (1) := Sin (Values (1));
               {{Ada/kw|elsif}} Operation = "cos" {{Ada/kw|then}}
                  --  cosinus
                  Values (1) := Cot (Values (1));
               {{Ada/kw|elsif}} Operation = "tan" {{Ada/kw|then}}
                  --  tangents
                  Values (1) := Tan (Values (1));
               {{Ada/kw|elsif}} Operation = "cot" {{Ada/kw|then}}
                  --  cotanents
                  Values (1) := Cot (Values (1));
               {{Ada/kw|elsif}} Operation = "asin" {{Ada/kw|then}}
                  --  arc-sinus
                  Values (1) := Arcsin (Values (1));
               {{Ada/kw|elsif}} Operation = "acos" {{Ada/kw|then}}
                  --  arc-cosinus
                  Values (1) := Arccos (Values (1));
               {{Ada/kw|elsif}} Operation = "atan" {{Ada/kw|then}}
                  --  arc-tangents
                  Values (1) := Arctan (Values (1));
               {{Ada/kw|elsif}} Operation = "acot" {{Ada/kw|then}}
                  --  arc-cotanents
                  Values (1) := Arccot (Values (1));
 
 ...
 
   {{Ada/kw|return}};
 {{Ada/kw|end}} Numeric_7;

=== [[Algebra/Vectors|Vector]] and [[Algebra/Matrices|Matrix]] Arithmetic ===

Ada supports [[Algebra/Vectors|vector]] and [[Algebra/Matrices|matrix]] Arithmetic for both normal real types and complex types. For those, the generic packages Ada.Numerics.Generic_Real_Arrays and Ada.Numerics.Generic_Complex_Arrays are used. Both packages offer the usual set of operations, however there is no I/O package and understandably, no package for elementary functions.

Since there is no I/O package for vector and matrix I/O creating a demo is by far more complex &mdash; and hence not ready yet. You can have a look at the current progress which will be a universal calculator merging all feature.

Status: Stalled - for a Vector and Matrix stack we need Indefinite_Vectors &mdash; which are currently not part of GNAT/Pro. Well I could use the booch components ...

{{Ada/Sourceforge|numeric_8-complex_calculator.ada}}
{{Ada/Sourceforge|numeric_8-get_line.ada}}
{{Ada/Sourceforge|numeric_8-real_calculator.ada}}
{{Ada/Sourceforge|numeric_8-real_vector_calculator.ada}}

== See also ==
 
=== Wikibook ===

* [[Ada Programming]]
* [[Ada Programming/Delimiters/-]]
* [[Ada Programming/Libraries/Ada.Numerics.Generic_Complex_Types]]
* [[Ada Programming/Libraries/Ada.Numerics.Generic_Elementary_Functions]]

=== Ada 95 Reference Manual ===

* {{Ada/95/RM2|4|4|Expressions}}
* {{Ada/95/RMA3|A|5|1|Elementary Functions}}
* {{Ada/95/RMA3|A|10|1|The Package Text_IO}}
* {{Ada/95/RMA2|G|1|Complex Arithmetic}}
* {{Ada/95/RMA2|G|3|Vector and Matrix Manipulation}}

=== Ada 2005 Reference Manual ===

* {{Ada/2005/RM2|4|4|Expressions}}
* {{Ada/2005/RMA3|A|5|1|Elementary Functions}}
* {{Ada/2005/RMA3|A|10|1|The Package Text_IO}}
* {{Ada/2005/RMA2|G|1|Complex Arithmetic}}
* {{Ada/2005/RMA2|G|3|Vector and Matrix Manipulation}}

<noinclude>
[[Category:Ada Programming|Mathematical calculations]]
</noinclude>