DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400 Tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400 Tapes

Excavated with: AutoArchaeologist - Free & Open Source Software. 

top - metrics - download
Index: B T

⟦250a863c9⟧ TextFile

    Length: 11518 (0x2cfe)
    Types: TextFile
    Names: »B«

Derivation

└─⟦180fe333a⟧ Bits:30000405 8mm tape, Rational 1000, SW CATALOG, 10_20_0
└─⟦180fe333a⟧ Bits:30000537 8mm tape, Rational 1000, SW Catalog 10_20_0
    └─⟦5cb1d1d7f⟧ »DATA« 
        └─⟦3b1ee7bd8⟧ 
            └─⟦this⟧

TextFile

with Transport_Stream;
with Interchange;
with Transport_Interchange;
with Float_Math_Lib_Defs;
with Transport_Defs;
with Rpc_Client;
with Transport_Name;  
with Rpc;
package body Flt_Math_Lib is


    Remote_Host : constant Transport_Defs.Host_Id :=
       Transport_Name.Host_To_Host_Id ("shemp");

    procedure Start_Request is
       new Rpc_Client.Start_Request_Generic
              (Float_Math_Lib_Defs.Network,  
               Remote_Host,  
               Float_Math_Lib_Defs.Socket, Float_Math_Lib_Defs.Program,
               Float_Math_Lib_Defs.Version);


    procedure Raise_Exception (Excep : Rpc.Exception_Number) is
    begin
        case Excep is
            when Float_Math_Lib_Defs.Exception_Number.Roprand =>
                raise Roprand;
            when Float_Math_Lib_Defs.Exception_Number.Invargmat =>
                raise Invargmat;
            when Float_Math_Lib_Defs.Exception_Number.Squrooneg =>
                raise Squrooneg;
            when Float_Math_Lib_Defs.Exception_Number.Logzerneg =>
                raise Logzerneg;
            when Float_Math_Lib_Defs.Exception_Number.Floundmat =>
                raise Floundmat;
            when Float_Math_Lib_Defs.Exception_Number.Floovemat =>
                raise Floovemat;
            when others =>
                raise Rpc.Other_Error;
        end case;
    end Raise_Exception;

    procedure End_Request is
       new Rpc_Client.End_Request_With_Exception (Raise_Exception);

    procedure Finalize is
    begin
        Transport_Stream.Finalize;
    end Finalize;
    function Sqrt (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Sqrt);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);
    end Sqrt;

    function Log (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Log);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Log;

    function Log10 (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Log10);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Log10;

    function Log2 (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Log2);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Log2;

    function Exp (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Exp);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Exp;

    function Sin (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Exp);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Sin;

    function Cos (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Cos);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Cos;

    function Tan (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Tan);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Tan;

    function Asin (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Asin);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Asin;

    function Acos (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Acos);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Acos;

    function Atan (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Atan);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Atan;

    function Atan2 (A1, A2 : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Atan2);
        Transport_Interchange.Put (Stream, Interchange.Float (A1));
        Transport_Interchange.Put (Stream, Interchange.Float (A2));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Atan2;

    function Sinh (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Sinh);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Sinh;

    function Cosh (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Cosh);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Cosh;

    function Tanh (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Tanh);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Tanh;

    function Sind (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Sind);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Sind;

    function Cosd (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Cosd);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Cosd;

    function Tand (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Tand);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Tand;

    function Asind (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Asind);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Asind;

    function Acosd (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Acosd);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Acosd;

    function Atand (A : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Atand);
        Transport_Interchange.Put (Stream, Interchange.Float (A));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Atand;

    function Atan2d (A1, A2 : Float) return Float is
        Stream : Transport_Stream.Stream_Id;
        Answer : Interchange.Float;
    begin
        Start_Request (Stream, Float_Math_Lib_Defs.Proc_Number.Atan2d);
        Transport_Interchange.Put (Stream, Interchange.Float (A1));
        Transport_Interchange.Put (Stream, Interchange.Float (A2));
        End_Request (Stream);
        Transport_Interchange.Get (Stream, Answer);
        Rpc_Client.End_Response (Stream);
        return Float (Answer);

    end Atan2d;
end Flt_Math_Lib;