LCOV - code coverage report
Current view: top level - libreoffice/solver/unxlngi6.pro/inc/tools - bigint.hxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 16 68 23.5 %
Date: 2012-12-27 Functions: 4 16 25.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : #ifndef _BIGINT_HXX
      20             : #define _BIGINT_HXX
      21             : 
      22             : #include <climits>
      23             : #include <rtl/ustring.hxx>
      24             : #include "tools/toolsdllapi.h"
      25             : #include <tools/solar.h>
      26             : 
      27             : class SvStream;
      28             : 
      29             : #ifdef _TLBIGINT_INT64
      30             : struct SbxINT64;
      31             : struct SbxUINT64;
      32             : namespace binfilter { class SbxINT64Converter; }
      33             : #endif
      34             : 
      35             : #define MAX_DIGITS 8
      36             : 
      37             : class Fraction;
      38             : 
      39             : class TOOLS_DLLPUBLIC SAL_WARN_UNUSED BigInt
      40             : {
      41             : #ifdef _TLBIGINT_INT64
      42             :     friend class ::binfilter::SbxINT64Converter;
      43             : #endif
      44             : 
      45             : private:
      46             :     long            nVal;
      47             :     unsigned short  nNum[MAX_DIGITS];
      48             :     sal_uInt8       nLen        : 5;    // current length
      49             :     sal_Bool        bIsNeg      : 1,    // Is Sign negative?
      50             :                     bIsBig      : 1,    // sal_True == BigInt
      51             :                     bIsSet      : 1;    // Not "Null" (not "not 0")
      52             : 
      53             :     TOOLS_DLLPRIVATE void MakeBigInt(BigInt const &);
      54             :     TOOLS_DLLPRIVATE void Normalize();
      55             :     TOOLS_DLLPRIVATE void Mult(BigInt const &, sal_uInt16);
      56             :     TOOLS_DLLPRIVATE void Div(sal_uInt16, sal_uInt16 &);
      57             :     TOOLS_DLLPRIVATE sal_Bool IsLess(BigInt const &) const;
      58             :     TOOLS_DLLPRIVATE void AddLong(BigInt &, BigInt &);
      59             :     TOOLS_DLLPRIVATE void SubLong(BigInt &, BigInt &);
      60             :     TOOLS_DLLPRIVATE void MultLong(BigInt const &, BigInt &) const;
      61             :     TOOLS_DLLPRIVATE void DivLong(BigInt const &, BigInt &) const;
      62             :     TOOLS_DLLPRIVATE void ModLong(BigInt const &, BigInt &) const;
      63             :     TOOLS_DLLPRIVATE sal_Bool ABS_IsLess(BigInt const &) const;
      64             : 
      65             : public:
      66             :                     BigInt();
      67             :                     BigInt( short nVal );
      68             :                     BigInt( long nVal );
      69             :                     BigInt( int nVal );
      70             :                     BigInt( double nVal );
      71             :                     BigInt( sal_uInt16 nVal );
      72             :                     BigInt( sal_uInt32 nVal );
      73             :                     BigInt( const BigInt& rBigInt );
      74             :                     BigInt( const rtl::OUString& rString );
      75             : #ifdef _TLBIGINT_INT64
      76             :                     BigInt( const SbxINT64  &r );
      77             :                     BigInt( const SbxUINT64 &r );
      78             : #endif
      79             : 
      80             :     operator        short() const;
      81             :     operator        long()  const;
      82             :     operator        int()   const;
      83             :     operator        double() const;
      84             :     operator        sal_uInt16() const;
      85             :     operator        sal_uIntPtr() const;
      86             : 
      87             :     void            Set( sal_Bool bSet ) { bIsSet = bSet; }
      88             :     rtl::OUString   GetString() const;
      89             : 
      90             :     sal_Bool        IsSet() const { return bIsSet; }
      91             :     sal_Bool        IsNeg() const;
      92             :     sal_Bool        IsZero() const;
      93             :     sal_Bool        IsOne() const;
      94             :     sal_Bool        IsLong() const { return !bIsBig; }
      95             :     void            Abs();
      96             : #ifdef _TLBIGINT_INT64
      97             :     sal_Bool        INT64 ( SbxINT64  *p ) const;
      98             :     sal_Bool        UINT64( SbxUINT64 *p ) const;
      99             : #endif
     100             : 
     101             :     BigInt&         operator  =( const BigInt& rVal );
     102             :     BigInt&         operator +=( const BigInt& rVal );
     103             :     BigInt&         operator -=( const BigInt& rVal );
     104             :     BigInt&         operator *=( const BigInt& rVal );
     105             :     BigInt&         operator /=( const BigInt& rVal );
     106             :     BigInt&         operator %=( const BigInt& rVal );
     107             : 
     108             :     BigInt&         operator  =( const short      nValue );
     109             :     BigInt&         operator  =( const long       nValue );
     110             :     BigInt&         operator  =( const int        nValue );
     111             :     BigInt&         operator  =( const sal_uInt16 nValue );
     112             : 
     113             :     friend inline   BigInt operator +( const BigInt& rVal1, const BigInt& rVal2 );
     114             :     friend inline   BigInt operator -( const BigInt& rVal1, const BigInt& rVal2 );
     115             :     friend inline   BigInt operator *( const BigInt& rVal1, const BigInt& rVal2 );
     116             :     friend inline   BigInt operator /( const BigInt& rVal1, const BigInt& rVal2 );
     117             :     friend inline   BigInt operator %( const BigInt& rVal1, const BigInt& rVal2 );
     118             : 
     119             :     TOOLS_DLLPUBLIC friend          sal_Bool operator==( const BigInt& rVal1, const BigInt& rVal2 );
     120             :     friend inline   sal_Bool operator!=( const BigInt& rVal1, const BigInt& rVal2 );
     121             :     TOOLS_DLLPUBLIC friend          sal_Bool operator< ( const BigInt& rVal1, const BigInt& rVal2 );
     122             :     TOOLS_DLLPUBLIC friend          sal_Bool operator> ( const BigInt& rVal1, const BigInt& rVal2 );
     123             :     friend inline   sal_Bool operator<=( const BigInt& rVal1, const BigInt& rVal2 );
     124             :     friend inline   sal_Bool operator>=( const BigInt& rVal1, const BigInt& rVal2 );
     125             : 
     126             :     friend class Fraction;
     127             : };
     128             : 
     129           0 : inline BigInt::BigInt()
     130             : {
     131           0 :     bIsSet = sal_False;
     132           0 :     bIsBig = sal_False;
     133           0 :     nVal   = 0;
     134           0 : }
     135             : 
     136           0 : inline BigInt::BigInt( short nValue )
     137             : {
     138           0 :     bIsSet = sal_True;
     139           0 :     bIsBig = sal_False;
     140           0 :     nVal   = nValue;
     141           0 : }
     142             : 
     143      127844 : inline BigInt::BigInt( long nValue )
     144             : {
     145      127844 :     bIsSet = sal_True;
     146      127844 :     bIsBig = sal_False;
     147      127844 :     nVal   = nValue;
     148      127844 : }
     149             : 
     150           0 : inline BigInt::BigInt( int nValue )
     151             : {
     152           0 :     bIsSet = sal_True;
     153           0 :     bIsBig = sal_False;
     154           0 :     nVal   = nValue;
     155           0 : }
     156             : 
     157             : inline BigInt::BigInt( sal_uInt16 nValue )
     158             : {
     159             :     bIsSet = sal_True;
     160             :     bIsBig = sal_False;
     161             :     nVal   = nValue;
     162             : }
     163             : 
     164           0 : inline BigInt::operator short() const
     165             : {
     166           0 :     if ( !bIsBig && nVal >= SHRT_MIN && nVal <= SHRT_MAX )
     167           0 :         return (short)nVal;
     168             :     else
     169           0 :         return 0;
     170             : }
     171             : 
     172       31938 : inline BigInt::operator long() const
     173             : {
     174       31938 :     if ( !bIsBig )
     175       31938 :         return nVal;
     176             :     else
     177           0 :         return 0;
     178             : }
     179             : 
     180             : inline BigInt::operator int() const
     181             : {
     182             :     if ( !bIsBig && (nVal == (long)(int)nVal) )
     183             :         return (int)nVal;
     184             :     else
     185             :         return 0;
     186             : }
     187             : 
     188             : inline BigInt::operator sal_uInt16() const
     189             : {
     190             :     if ( !bIsBig && nVal >= 0 && nVal <= USHRT_MAX )
     191             :         return (sal_uInt16)nVal;
     192             :     else
     193             :         return 0;
     194             : }
     195             : 
     196             : inline BigInt& BigInt::operator =( const short nValue )
     197             : {
     198             :     bIsSet = sal_True;
     199             :     bIsBig = sal_False;
     200             :     nVal   = nValue;
     201             : 
     202             :     return *this;
     203             : }
     204             : 
     205           0 : inline BigInt& BigInt::operator =( const long nValue )
     206             : {
     207           0 :     bIsSet = sal_True;
     208           0 :     bIsBig = sal_False;
     209           0 :     nVal   = nValue;
     210             : 
     211           0 :     return *this;
     212             : }
     213             : 
     214           0 : inline BigInt& BigInt::operator =( const int nValue )
     215             : {
     216           0 :     bIsSet = sal_True;
     217           0 :     bIsBig = sal_False;
     218           0 :     nVal   = nValue;
     219             : 
     220           0 :     return *this;
     221             : }
     222             : 
     223             : inline BigInt& BigInt::operator =( const sal_uInt16 nValue )
     224             : {
     225             :     bIsSet = sal_True;
     226             :     bIsBig = sal_False;
     227             :     nVal   = nValue;
     228             : 
     229             :     return *this;
     230             : }
     231             : 
     232       13220 : inline sal_Bool BigInt::IsNeg() const
     233             : {
     234       13220 :     if ( !bIsBig )
     235       13218 :         return (nVal < 0);
     236             :     else
     237           2 :         return (sal_Bool)bIsNeg;
     238             : }
     239             : 
     240           0 : inline sal_Bool BigInt::IsZero() const
     241             : {
     242           0 :     if ( bIsBig )
     243           0 :         return sal_False;
     244             :     else
     245           0 :         return (nVal == 0);
     246             : }
     247             : 
     248             : inline sal_Bool BigInt::IsOne() const
     249             : {
     250             :     if ( bIsBig )
     251             :         return sal_False;
     252             :     else
     253             :         return (nVal == 1);
     254             : }
     255             : 
     256           0 : inline void BigInt::Abs()
     257             : {
     258           0 :     if ( bIsBig )
     259           0 :         bIsNeg = sal_False;
     260           0 :     else if ( nVal < 0 )
     261           0 :         nVal = -nVal;
     262           0 : }
     263             : 
     264          46 : inline BigInt operator+( const BigInt &rVal1, const BigInt &rVal2 )
     265             : {
     266          46 :     BigInt aErg( rVal1 );
     267          46 :     aErg += rVal2;
     268          46 :     return aErg;
     269             : }
     270             : 
     271             : inline BigInt operator-( const BigInt &rVal1, const BigInt &rVal2 )
     272             : {
     273             :     BigInt aErg( rVal1 );
     274             :     aErg -= rVal2;
     275             :     return aErg;
     276             : }
     277             : 
     278           0 : inline BigInt operator*( const BigInt &rVal1, const BigInt &rVal2 )
     279             : {
     280           0 :     BigInt aErg( rVal1 );
     281           0 :     aErg *= rVal2;
     282           0 :     return aErg;
     283             : }
     284             : 
     285           0 : inline BigInt operator/( const BigInt &rVal1, const BigInt &rVal2 )
     286             : {
     287           0 :     BigInt aErg( rVal1 );
     288           0 :     aErg /= rVal2;
     289           0 :     return aErg;
     290             : }
     291             : 
     292             : inline BigInt operator%( const BigInt &rVal1, const BigInt &rVal2 )
     293             : {
     294             :     BigInt aErg( rVal1 );
     295             :     aErg %= rVal2;
     296             :     return aErg;
     297             : }
     298             : 
     299           0 : inline sal_Bool operator!=( const BigInt& rVal1, const BigInt& rVal2 )
     300             : {
     301           0 :     return !(rVal1 == rVal2);
     302             : }
     303             : 
     304             : inline sal_Bool operator<=( const BigInt& rVal1, const BigInt& rVal2 )
     305             : {
     306             :     return !( rVal1 > rVal2);
     307             : }
     308             : 
     309           0 : inline sal_Bool operator>=( const BigInt& rVal1, const BigInt& rVal2 )
     310             : {
     311           0 :     return !(rVal1 < rVal2);
     312             : }
     313             : 
     314             : #endif
     315             : 
     316             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10