DataMuseum.dk

top - download

    Length: 5130 (0x140a)
    Types: TextFile
    Names: »B«

└─⟦5f3412b64⟧ Bits:30000745 8mm tape, Rational 1000, ENVIRONMENT 12_6_5 TOOLS 
    └─ ⟦91c658230⟧ »DATA« 
        └─⟦458657fb6⟧ 
            └─⟦1472c4407⟧ 
                └─⟦3d4b48c74⟧ 
└─⟦d10a02448⟧ Bits:30000409 8mm tape, Rational 1000, ENVIRONMENT, D_12_7_3
    └─ ⟦fc9b38f02⟧ »DATA« 
        └─⟦9b46a407a⟧ 
            └─⟦2e03b931c⟧ 
                └─⟦3d4b48c74⟧ 
                    └─⟦this⟧ 
└─⟦5f3412b64⟧ Bits:30000745 8mm tape, Rational 1000, ENVIRONMENT 12_6_5 TOOLS 
    └─ ⟦91c658230⟧ »DATA« 
        └─⟦458657fb6⟧ 
            └─⟦1472c4407⟧ 
                └─⟦6fef9baf9⟧ 
└─⟦d10a02448⟧ Bits:30000409 8mm tape, Rational 1000, ENVIRONMENT, D_12_7_3
    └─ ⟦fc9b38f02⟧ »DATA« 
        └─⟦9b46a407a⟧ 
            └─⟦2e03b931c⟧ 
                └─⟦6fef9baf9⟧ 
                    └─⟦this⟧ 

TextFile

with Primitive_Functions;
with Long_Primitive_Functions;
package body Generic_Primitive_Functions is

-- This is a non-portable implementation for the Motorola Mc680X0 architecture
-- and with support from the Mc68881 coprocessor

   package Single renames Primitive_Functions;
   package Double renames Long_Primitive_Functions;

   Is_Long : constant Boolean := Float_Type'Base'Digits > Float'Digits;

   function Exponent (X : Float_Type) return Exponent_Type is
   begin
      if Is_Long then
         return Exponent_Type (Double.Exponent (Long_Float (X)));
      else
         return Exponent_Type (Single.Exponent (Float (X)));
      end if;
   end Exponent;


   function Fraction (X : Float_Type) return Float_Type is
   begin
      if Is_Long then
         return Float_Type (Double.Fraction (Long_Float (X)));
      else
         return Float_Type (Single.Fraction (Float (X)));
      end if;

   end Fraction;


   procedure Decompose (X        : in  Float_Type;
                        Fraction : out Float_Type;
                        Exponent : out Exponent_Type) is
   begin
      if Is_Long then
         Double.Decompose (Long_Float (X),  
                           Long_Float (Fraction),  
                           Integer (Exponent));
      else
         Single.Decompose (Float (X),  
                           Float (Fraction),  
                           Integer (Exponent));
      end if;
   end Decompose;


   function Compose (Fraction : Float_Type;  
                     Exponent : Exponent_Type) return Float_Type is
   begin
      if Is_Long then
         return Float_Type (Double.Compose (Long_Float (Fraction),  
                                            Integer (Exponent)));
      else
         return Float_Type (Single.Compose (Float (Fraction),  
                                            Integer (Exponent)));
      end if;
   end Compose;


   function Scale (X        : Float_Type;  
                   Exponent : Exponent_Type) return Float_Type is
   begin
      if Is_Long then
         return Float_Type (Double.Scale (Long_Float (X), Integer (Exponent)));
      else
         return Float_Type (Single.Scale (Float (X), Integer (Exponent)));
      end if;
   end Scale;


   function Floor (X : Float_Type) return Float_Type is
   begin
      if Is_Long then
         return Float_Type (Double.Floor (Long_Float (X)));
      else
         return Float_Type (Single.Floor (Float (X)));
      end if;
   end Floor;


   function Ceiling (X : Float_Type) return Float_Type is
   begin
      if Is_Long then
         return Float_Type (Double.Ceiling (Long_Float (X)));
      else
         return Float_Type (Single.Ceiling (Float (X)));
      end if;

   end Ceiling;


   function Round (X : Float_Type) return Float_Type is
   begin
      if Is_Long then
         return Float_Type (Double.Round (Long_Float (X)));
      else
         return Float_Type (Single.Round (Float (X)));
      end if;

   end Round;


   function Truncate (X : Float_Type) return Float_Type is
   begin
      if Is_Long then
         return Float_Type (Double.Truncate (Long_Float (X)));
      else
         return Float_Type (Single.Truncate (Float (X)));
      end if;

   end Truncate;


   function Remainder (X, Y : Float_Type) return Float_Type is
   begin
      if Is_Long then
         return Float_Type (Double.Remainder (Long_Float (X), Long_Float (Y)));
      else
         return Float_Type (Single.Remainder (Float (X), Float (Y)));
      end if;

   end Remainder;


   function Adjacent (X, Towards : Float_Type) return Float_Type is
   begin
      if Is_Long then
         return Float_Type (Double.Adjacent
                               (Long_Float (X), Long_Float (Towards)));
      else
         return Float_Type (Single.Adjacent (Float (X), Float (Towards)));
      end if;

   end Adjacent;


   function Successor (X : Float_Type) return Float_Type is
   begin
      if Is_Long then
         return Float_Type (Double.Successor (Long_Float (X)));
      else
         return Float_Type (Single.Successor (Float (X)));
      end if;

   end Successor;


   function Predecessor (X : Float_Type) return Float_Type is
   begin
      if Is_Long then
         return Float_Type (Double.Predecessor (Long_Float (X)));
      else
         return Float_Type (Single.Predecessor (Float (X)));
      end if;

   end Predecessor;


   function Copy_Sign (Value, Sign : Float_Type) return Float_Type is
   begin
      if Is_Long then
         return Float_Type (Double.Copy_Sign (Long_Float (Value),  
                                              Long_Float (Sign)));
      else
         return Float_Type (Single.Copy_Sign (Float (Value), Float (Sign)));
      end if;

   end Copy_Sign;


   function Leading_Part (X            : Float_Type;  
                          Radix_Digits : Positive) return Float_Type is
   begin
      if Is_Long then
         return Float_Type (Double.Leading_Part (Long_Float (X), Radix_Digits));
      else
         return Float_Type (Single.Leading_Part (Float (X), Radix_Digits));
      end if;
   end Leading_Part;

end Generic_Primitive_Functions;