Subversion Repositories thor

#pragma once

// ============================================================================

//        __

//   \\__/ o\    (C) 2016-2017  Robert Finch, Waterloo

//    \  __ /    All rights reserved.

//     \/_//     robfinch<remove>@finitron.ca

//       ||

//

// 128 bit floating point class

//

// This source file is free software: you can redistribute it and/or modify 

// it under the terms of the GNU Lesser General Public License as published 

// by the Free Software Foundation, either version 3 of the License, or     

// (at your option) any later version.                                      

//                                                                          

// This source file is distributed in the hope that it will be useful,      

// but WITHOUT ANY WARRANTY; without even the implied warranty of           

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            

// GNU General Public License for more details.                             

//                                                                          

// You should have received a copy of the GNU General Public License        

// along with this program.  If not, see <http://www.gnu.org/licenses/>.    

//                                                                          

// Floats here are actually represented with a 128 bit mantissa for simpliity

// rather than 112 bits.

// ============================================================================

//

#define FLT128_WORDS    4

#define FLT_PREC                64

class Float128

{

public:

        static const __int16 bias = 0x3FFF;

        static const __int16 infxp = 0x7FFF;

public:

        unsigned __int32 pack[4];

        unsigned __int32 man[FLT128_WORDS];

        unsigned __int16 exp;

        bool sign;

        // The following is for compiler use

        //-----------------------------------

        Float128 *next; // next in a list

        int label;

        char *nmspace;

        //-----------------------------------

        void ShiftManLeft();

private:

        void ShiftManRight();

        static bool ManEQ(Float128 *a, Float128 *b);

        static bool ManGT(Float128 *a, Float128 *b);

        static bool ManGE(Float128 *a, Float128 *b) {

                if (ManGT(a,b))

                        return (true);

                if (ManEQ(a,b))

                        return (true);

                return (false);

        };

        static bool AddMan(Float128 *s, Float128 *a, Float128 *b);

        static bool SubMan(Float128 *d, Float128 *a, Float128 *b);

        void Denormalize(unsigned __int16 xp);

        void Denorm1();

public:

        Float128() {

                Zeroman();

                exp = 0;

                sign = false;

        };

        Float128(Float128 *a);

        void Zeroman() {

                int nn;

                for (nn = 0; nn < FLT128_WORDS; nn++)

                        man[nn] = 0;

        };

        static Float128 *Zero() {

                static Float128 p;

                p.Zeroman();

                p.exp = 0x0000;

                return (&p);

        };

        static Float128 *One() {

                static Float128 p;

                p.Zeroman();

                p.man[FLT128_WORDS-1] = 0x40000000;

                p.exp = 0x3FFF;

                return (&p);

        };

        static Float128 *Ten() {

                static Float128 p;

                p.Zeroman();

                p.man[FLT128_WORDS-1] = 0x50000000;

                p.exp = 0x4002;

                return (&p);

        };

        static Float128 *OneTenth() {

                int nn;

                static Float128 p;

                for (nn = 0; nn < FLT128_WORDS; nn++)

                        p.man[nn] = 0x66666666;

                p.exp = 0x3FFB;

                return (&p);

        };

        static Float128 *FloatMax() {

                int nn;

                static Float128 p;

                for (nn = 0; nn < FLT128_WORDS; nn++)

                        p.man[nn] = 0xFFFFFFFF;

                for (nn = 0; nn < FLT128_WORDS/2; nn++)

                        p.man[nn] = 0;

                for (; nn < FLT128_WORDS-1; nn++)

                        p.man[nn] = 0xFFFFFFFF;

                p.man[FLT128_WORDS/2-1] = 0x80000000;

                p.man[FLT128_WORDS-1] = 0x7FFFFFFF;

                p.exp = 0x7FFE;

                return (&p);

        };

        static Float128 *Neg(Float128 *p) {

                Float128 *q = new Float128;

                q->sign = !p->sign;

                return q;

        };

        static void Add(Float128 *s, Float128 *a, Float128 *b);

        static void Sub(Float128 *d, Float128 *a, Float128 *b) {

                Float128 *b1 = Neg(b);

                Add(d, a, b1);

                delete b1;

        };

        static void Mul(Float128 *p, Float128 *a, Float128 *b);

        static void Div(Float128 *q, Float128 *a, Float128 *b);

        static void Assign(Float128 *d, Float128 *s) {

                int nn;

                for (nn = 0; nn < FLT128_WORDS; nn++)

                        d->man[nn] = s->man[nn];

                d->exp = s->exp;

                d->sign = s->sign;

        };

        static void Normalize(Float128 *a);

        static void IntToFloat(Float128 *d, __int64 v);

        static void FloatToInt(__int64 *i, Float128 *a);

        static void Float128ToDouble(double *d, Float128 *a);

        void Pack(int);

        char *ToString();

        char *ToString(int);

        bool IsManZero() const;

        bool IsZero() const;

        bool IsInfinite() const;

        static bool IsEqual(Float128 *a, Float128 *b);

        static bool IsEqualNZ(Float128 *a, Float128 *b);

        static bool IsNaN(Float128 *a);

        bool IsNaN() { return (IsNaN(this)); };

};