Changeset 65240bb


Ignore:
Timestamp:
Jul 12, 2019, 1:46:10 PM (2 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
arm-eh, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
302d84c2
Parents:
1d760934
Message:

first attempt to add streams exit and abort, rename private iostream nl function to ends

Files:
11 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/fstream.cfa

    r1d760934 r65240bb  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu May 16 08:33:28 2019
    13 // Update Count     : 328
     12// Last Modified On : Fri Jul 12 12:03:53 2019
     13// Update Count     : 344
    1414//
    1515
     
    2424#include <assert.h>
    2525#include <errno.h>                                                                              // errno
     26
     27
     28//*********************************** ofstream ***********************************
     29
    2630
    2731#define IO_MSG "I/O error: "
     
    3741        sepSetCur( os, sepGet( os ) );
    3842        sepSetTuple( os, ", " );
    39 }
     43} // ?{}
    4044
    4145// private
     
    5660void ?{}( ofstream & os, const char * name, const char * mode ) {
    5761        open( os, name, mode );
    58 }
     62} // ?{}
     63
    5964void ?{}( ofstream & os, const char * name ) {
    6065        open( os, name, "w" );
    61 }
     66} // ?{}
    6267
    6368void sepOn( ofstream & os ) { os.sepOnOff = ! getNL( os ); }
     
    9499        os.tupleSeparator[sepSize - 1] = '\0';
    95100} // sepSet
     101
     102void ends( ofstream & os ) {
     103        if ( getANL( os ) ) nl( os );
     104        else setPrt( os, false );                                                       // turn off
     105        if ( &os == &exit ) exit( EXIT_FAILURE );
     106        if ( &os == &abort ) abort();
     107} // ends
    96108
    97109int fail( ofstream & os ) {
     
    157169ofstream & serr = serrFile;
    158170
    159 // static ofstream sexitFile = { (FILE *)(&_IO_2_1_stdout_) };
    160 // ofstream & sexit = sexitFile;
    161 // static ofstream sabortFile = { (FILE *)(&_IO_2_1_stderr_) };
    162 // ofstream & sabort = sabortFile;
    163 
    164 void nl( ofstream & os ) {
    165         if ( getANL( os ) ) (ofstream &)(nl( os ));                     // implementation only
    166         else setPrt( os, false );                                                       // turn off
    167 }
    168 
    169 //---------------------------------------
     171static ofstream exitFile = { (FILE *)(&_IO_2_1_stdout_) };
     172ofstream & exit = exitFile;
     173static ofstream abortFile = { (FILE *)(&_IO_2_1_stderr_) };
     174ofstream & abort = abortFile;
     175
     176
     177//*********************************** ifstream ***********************************
     178
    170179
    171180// private
     
    173182        is.file = file;
    174183        is.nlOnOff = false;
    175 }
     184} // ?{}
    176185
    177186// public
     
    180189void ?{}( ifstream & is, const char * name, const char * mode ) {
    181190        open( is, name, mode );
    182 }
     191} // ?{}
     192
    183193void ?{}( ifstream & is, const char * name ) {
    184194        open( is, name, "r" );
    185 }
     195} // ?{}
    186196
    187197void nlOn( ifstream & os ) { os.nlOnOff = true; }
  • libcfa/src/fstream.hfa

    r1d760934 r65240bb  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu May 16 08:34:10 2019
    13 // Update Count     : 157
     12// Last Modified On : Fri Jul 12 12:03:54 2019
     13// Update Count     : 165
    1414//
    1515
     
    1717
    1818#include "iostream.hfa"
     19
     20
     21//*********************************** ofstream ***********************************
     22
    1923
    2024enum { sepSize = 16 };
     
    5660void sepSetTuple( ofstream &, const char * );
    5761
     62void ends( ofstream & os );
    5863int fail( ofstream & );
    5964int flush( ofstream & );
     
    6974
    7075extern ofstream & sout, & serr;
     76extern ofstream & exit, & abort;
    7177
    72 // extern ofstream & sout, & serr, & sexit, & sabort;
    73 // void nl( ofstream & os );
     78
     79//*********************************** ifstream ***********************************
    7480
    7581
  • libcfa/src/gmp.hfa

    r1d760934 r65240bb  
    1010// Created On       : Tue Apr 19 08:43:43 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Apr 20 09:01:52 2019
    13 // Update Count     : 24
     12// Last Modified On : Fri Jul 12 12:02:55 2019
     13// Update Count     : 26
    1414//
    1515
     
    1919
    2020#include <gmp.h>                                                                                // GNU multi-precise integers
    21 #include <fstream.hfa>                                                                          // sout
     21#include <fstream.hfa>                                                                  // sout
    2222
    2323struct Int { mpz_t mpz; };                                                              // wrap GMP implementation
    2424
    25 // constructor
    26 static inline void ?{}( Int & this ) { mpz_init( this.mpz ); }
    27 static inline void ?{}( Int & this, Int init ) { mpz_init_set( this.mpz, init.mpz ); }
    28 static inline void ?{}( Int & this, zero_t ) { mpz_init_set_si( this.mpz, 0 ); }
    29 static inline void ?{}( Int & this, one_t ) { mpz_init_set_si( this.mpz, 1 ); }
    30 static inline void ?{}( Int & this, signed long int init ) { mpz_init_set_si( this.mpz, init ); }
    31 static inline void ?{}( Int & this, unsigned long int init ) { mpz_init_set_ui( this.mpz, init ); }
    32 static inline void ?{}( Int & this, const char * val ) { if ( mpz_init_set_str( this.mpz, val, 0 ) ) abort(); }
    33 static inline void ^?{}( Int & this ) { mpz_clear( this.mpz ); }
    34 
    35 // literal
    36 static inline Int ?`mp( signed long int init ) { return (Int){ init }; }
    37 static inline Int ?`mp( unsigned long int init ) { return (Int){ init }; }
    38 static inline Int ?`mp( const char * init ) { return (Int){ init }; }
    39 
    40 // assignment
    41 static inline Int ?=?( Int & lhs, Int rhs ) { mpz_set( lhs.mpz, rhs.mpz ); return lhs; }
    42 static inline Int ?=?( Int & lhs, long int rhs ) { mpz_set_si( lhs.mpz, rhs ); return lhs; }
    43 static inline Int ?=?( Int & lhs, unsigned long int rhs ) { mpz_set_ui( lhs.mpz, rhs ); return lhs; }
    44 static inline Int ?=?( Int & lhs, const char * rhs ) { if ( mpz_set_str( lhs.mpz, rhs, 0 ) ) { printf( "invalid string conversion\n" ); abort(); } return lhs; }
    45 
    46 static inline char ?=?( char & lhs, Int rhs ) { char val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
    47 static inline short int ?=?( short int & lhs, Int rhs ) { short int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
    48 static inline int ?=?( int & lhs, Int rhs ) { int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
    49 static inline long int ?=?( long int & lhs, Int rhs ) { long int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
    50 static inline unsigned char ?=?( unsigned char & lhs, Int rhs ) { unsigned char val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; }
    51 static inline unsigned short int ?=?( unsigned short int & lhs, Int rhs ) { unsigned short int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; }
    52 static inline unsigned int ?=?( unsigned int & lhs, Int rhs ) { unsigned int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; }
    53 static inline unsigned long int ?=?( unsigned long int & lhs, Int rhs ) { unsigned long int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; }
    54 
    55 // conversions
    56 static inline long int narrow( Int val ) { return mpz_get_si( val.mpz ); }
    57 static inline unsigned long int narrow( Int val ) { return mpz_get_ui( val.mpz ); }
    58 
    59 // comparison
    60 static inline int ?==?( Int oper1, Int oper2 ) { return mpz_cmp( oper1.mpz, oper2.mpz ) == 0; }
    61 static inline int ?==?( Int oper1, long int oper2 ) { return mpz_cmp_si( oper1.mpz, oper2 ) == 0; }
    62 static inline int ?==?( long int oper2, Int oper1 ) { return mpz_cmp_si( oper1.mpz, oper2 ) == 0; }
    63 static inline int ?==?( Int oper1, unsigned long int oper2 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) == 0; }
    64 static inline int ?==?( unsigned long int oper2, Int oper1 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) == 0; }
    65 
    66 static inline int ?!=?( Int oper1, Int oper2 ) { return ! ( oper1 == oper2 ); }
    67 static inline int ?!=?( Int oper1, long int oper2 ) { return ! ( oper1 == oper2 ); }
    68 static inline int ?!=?( long int oper1, Int oper2 ) { return ! ( oper1 == oper2 ); }
    69 static inline int ?!=?( Int oper1, unsigned long int oper2 ) { return ! ( oper1 == oper2 ); }
    70 static inline int ?!=?( unsigned long int oper1, Int oper2 ) { return ! ( oper1 == oper2 ); }
    71 
    72 static inline int ?<?( Int oper1, Int oper2 ) { return mpz_cmp( oper1.mpz, oper2.mpz ) < 0; }
    73 static inline int ?<?( Int oper1, long int oper2 ) { return mpz_cmp_si( oper1.mpz, oper2 ) < 0; }
    74 static inline int ?<?( long int oper2, Int oper1 ) { return mpz_cmp_si( oper1.mpz, oper2 ) < 0; }
    75 static inline int ?<?( Int oper1, unsigned long int oper2 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) < 0; }
    76 static inline int ?<?( unsigned long int oper2, Int oper1 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) < 0; }
    77 
    78 static inline int ?<=?( Int oper1, Int oper2 ) { return mpz_cmp( oper1.mpz, oper2.mpz ) <= 0; }
    79 static inline int ?<=?( Int oper1, long int oper2 ) { return mpz_cmp_si( oper1.mpz, oper2 ) <= 0; }
    80 static inline int ?<=?( long int oper2, Int oper1 ) { return mpz_cmp_si( oper1.mpz, oper2 ) <= 0; }
    81 static inline int ?<=?( Int oper1, unsigned long int oper2 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) <= 0; }
    82 static inline int ?<=?( unsigned long int oper2, Int oper1 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) <= 0; }
    83 
    84 static inline int ?>?( Int oper1, Int oper2 ) { return ! ( oper1 <= oper2 ); }
    85 static inline int ?>?( Int oper1, long int oper2 ) { return ! ( oper1 <= oper2 ); }
    86 static inline int ?>?( long int oper1, Int oper2 ) { return ! ( oper1 <= oper2 ); }
    87 static inline int ?>?( Int oper1, unsigned long int oper2 ) { return ! ( oper1 <= oper2 ); }
    88 static inline int ?>?( unsigned long int oper1, Int oper2 ) { return ! ( oper1 <= oper2 ); }
    89 
    90 static inline int ?>=?( Int oper1, Int oper2 ) { return ! ( oper1 < oper2 ); }
    91 static inline int ?>=?( Int oper1, long int oper2 ) { return ! ( oper1 < oper2 ); }
    92 static inline int ?>=?( long int oper1, Int oper2 ) { return ! ( oper1 < oper2 ); }
    93 static inline int ?>=?( Int oper1, unsigned long int oper2 ) { return ! ( oper1 < oper2 ); }
    94 static inline int ?>=?( unsigned long int oper1, Int oper2 ) { return ! ( oper1 < oper2 ); }
    95 
    96 // arithmetic
    97 static inline Int +?( Int oper ) { Int pos; mpz_set( pos.mpz, oper.mpz ); return pos; }
    98 static inline Int -?( Int oper ) { Int neg; mpz_neg( neg.mpz, oper.mpz ); return neg; }
    99 static inline Int ~?( Int oper ) { Int comp; mpz_com( comp.mpz, oper.mpz ); return comp; }
    100 
    101 static inline Int ?&?( Int oper1, Int oper2 ) { Int conjunction; mpz_and( conjunction.mpz, oper1.mpz, oper2.mpz ); return conjunction; }
    102 static inline Int ?&?( Int oper1, long int oper2 ) { Int conjunction, temp; mpz_set_si( temp.mpz, oper2 ); mpz_and( conjunction.mpz, oper1.mpz, temp.mpz ); return conjunction; }
    103 static inline Int ?&?( long int oper1, Int oper2 ) { Int conjunction, temp; mpz_set_si( temp.mpz, oper1 ); mpz_and( conjunction.mpz, temp.mpz, oper2.mpz ); return conjunction; }
    104 static inline Int ?&?( Int oper1, unsigned long int oper2 ) { Int conjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_and( conjunction.mpz, oper1.mpz, temp.mpz ); return conjunction; }
    105 static inline Int ?&?( unsigned long int oper1, Int oper2 ) { Int conjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_and( conjunction.mpz, temp.mpz, oper2.mpz ); return conjunction; }
    106 static inline Int ?&=?( Int & lhs, Int rhs ) { return lhs = lhs & rhs; }
    107 
    108 static inline Int ?|?( Int oper1, Int oper2 ) { Int disjunction; mpz_ior( disjunction.mpz, oper1.mpz, oper2.mpz ); return disjunction; }
    109 static inline Int ?|?( Int oper1, long int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
    110 static inline Int ?|?( long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
    111 static inline Int ?|?( Int oper1, unsigned long int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
    112 static inline Int ?|?( unsigned long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
    113 static inline Int ?|=?( Int & lhs, Int rhs ) { return lhs = lhs | rhs; }
    114 
    115 static inline Int ?^?( Int oper1, Int oper2 ) { Int disjunction; mpz_xor( disjunction.mpz, oper1.mpz, oper2.mpz ); return disjunction; }
    116 static inline Int ?^?( Int oper1, long int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
    117 static inline Int ?^?( long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
    118 static inline Int ?^?( Int oper1, unsigned long int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
    119 static inline Int ?^?( unsigned long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
    120 static inline Int ?^=?( Int & lhs, Int rhs ) { return lhs = lhs ^ rhs; }
    121 
    122 static inline Int ?+?( Int addend1, Int addend2 ) { Int sum; mpz_add( sum.mpz, addend1.mpz, addend2.mpz ); return sum; }
    123 static inline Int ?+?( Int addend1, long int addend2 ) { Int sum; if ( addend2 >= 0 ) mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); else mpz_sub_ui( sum.mpz, addend1.mpz, -addend2 ); return sum; }
    124 static inline Int ?+?( long int addend2, Int addend1 ) { Int sum; if ( addend2 >= 0 ) mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); else mpz_sub_ui( sum.mpz, addend1.mpz, -addend2 ); return sum; }
    125 static inline Int ?+?( Int addend1, unsigned long int addend2 ) { Int sum; mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); return sum; }
    126 static inline Int ?+?( unsigned long int addend2, Int addend1 ) { Int sum; mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); return sum; }
    127 static inline Int ?+=?( Int & lhs, Int rhs ) { return lhs = lhs + rhs; }
    128 static inline Int ?+=?( Int & lhs, long int rhs ) { return lhs = lhs + rhs; }
    129 static inline Int ?+=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs + rhs; }
    130 static inline Int ++?( Int & lhs ) { return lhs += 1; }
    131 static inline Int ?++( Int & lhs ) { Int ret = lhs; lhs += 1; return ret; }
    132 
    133 static inline Int ?-?( Int minuend, Int subtrahend ) { Int diff; mpz_sub( diff.mpz, minuend.mpz, subtrahend.mpz ); return diff; }
    134 static inline Int ?-?( Int minuend, long int subtrahend ) { Int diff; if ( subtrahend >= 0 ) mpz_sub_ui( diff.mpz, minuend.mpz, subtrahend ); else mpz_add_ui( diff.mpz, minuend.mpz, -subtrahend ); return diff; }
    135 static inline Int ?-?( long int minuend, Int subtrahend ) { Int diff; if ( subtrahend >= 0 ) mpz_ui_sub( diff.mpz, minuend, subtrahend.mpz ); else { mpz_add_ui( diff.mpz, subtrahend.mpz, -minuend ); mpz_neg( diff.mpz, diff.mpz ); } return diff; }
    136 static inline Int ?-?( Int minuend, unsigned long int subtrahend ) { Int diff; mpz_sub_ui( diff.mpz, minuend.mpz, subtrahend ); return diff; }
    137 static inline Int ?-?( unsigned long int minuend, Int subtrahend ) { Int diff; mpz_ui_sub( diff.mpz, minuend, subtrahend.mpz ); return diff; }
    138 static inline Int ?-=?( Int & lhs, Int rhs ) { return lhs = lhs - rhs; }
    139 static inline Int ?-=?( Int & lhs, long int rhs ) { return lhs = lhs - rhs; }
    140 static inline Int ?-=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs - rhs; }
    141 static inline Int --?( Int & lhs ) { return lhs -= 1; }
    142 static inline Int ?--( Int & lhs ) { Int ret = lhs; lhs -= 1; return ret; }
    143 
    144 static inline Int ?*?( Int multiplicator, Int multiplicand ) { Int product; mpz_mul( product.mpz, multiplicator.mpz, multiplicand.mpz ); return product; }
    145 static inline Int ?*?( Int multiplicator, long int multiplicand ) { Int product; mpz_mul_si( product.mpz, multiplicator.mpz, multiplicand ); return product; }
    146 static inline Int ?*?( long int multiplicand, Int multiplicator ) { Int product; mpz_mul_si( product.mpz, multiplicator.mpz, multiplicand ); return product; }
    147 static inline Int ?*?( Int multiplicator, unsigned long int multiplicand ) { Int product; mpz_mul_ui( product.mpz, multiplicator.mpz, multiplicand ); return product; }
    148 static inline Int ?*?( unsigned long int multiplicand, Int multiplicator ) { Int product; mpz_mul_ui( product.mpz, multiplicator.mpz, multiplicand ); return product; }
    149 static inline Int ?*=?( Int & lhs, Int rhs ) { return lhs = lhs * rhs; }
    150 static inline Int ?*=?( Int & lhs, long int rhs ) { return lhs = lhs * rhs; }
    151 static inline Int ?*=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs * rhs; }
    152 
    153 // some code for operators "/" and "%" taken from g++ gmpxx.h
    154 static inline Int ?/?( Int dividend, Int divisor ) { Int quotient; mpz_tdiv_q( quotient.mpz, dividend.mpz, divisor.mpz ); return quotient; }
    155 static inline Int ?/?( Int dividend, unsigned long int divisor ) { Int quotient; mpz_tdiv_q_ui( quotient.mpz, dividend.mpz, divisor ); return quotient; }
    156 static inline Int ?/?( unsigned long int dividend, Int divisor ) {
    157         Int quotient;
    158     if ( mpz_sgn( divisor.mpz ) >= 0 ) {
    159                 if ( mpz_fits_ulong_p( divisor.mpz ) )
    160                         mpz_set_ui( quotient.mpz, dividend / mpz_get_ui( divisor.mpz ) );
    161                 else
    162                         mpz_set_ui( quotient.mpz, 0 );
    163         } else {
    164                 mpz_neg( quotient.mpz, divisor.mpz );
    165                 if ( mpz_fits_ulong_p( quotient.mpz ) ) {
    166                         mpz_set_ui( quotient.mpz, dividend / mpz_get_ui( quotient.mpz ) );
     25static inline {
     26        // constructor
     27        void ?{}( Int & this ) { mpz_init( this.mpz ); }
     28        void ?{}( Int & this, Int init ) { mpz_init_set( this.mpz, init.mpz ); }
     29        void ?{}( Int & this, zero_t ) { mpz_init_set_si( this.mpz, 0 ); }
     30        void ?{}( Int & this, one_t ) { mpz_init_set_si( this.mpz, 1 ); }
     31        void ?{}( Int & this, signed long int init ) { mpz_init_set_si( this.mpz, init ); }
     32        void ?{}( Int & this, unsigned long int init ) { mpz_init_set_ui( this.mpz, init ); }
     33        void ?{}( Int & this, const char * val ) { if ( mpz_init_set_str( this.mpz, val, 0 ) ) abort(); }
     34        void ^?{}( Int & this ) { mpz_clear( this.mpz ); }
     35
     36        // literal
     37        Int ?`mp( signed long int init ) { return (Int){ init }; }
     38        Int ?`mp( unsigned long int init ) { return (Int){ init }; }
     39        Int ?`mp( const char * init ) { return (Int){ init }; }
     40
     41        // assignment
     42        Int ?=?( Int & lhs, Int rhs ) { mpz_set( lhs.mpz, rhs.mpz ); return lhs; }
     43        Int ?=?( Int & lhs, long int rhs ) { mpz_set_si( lhs.mpz, rhs ); return lhs; }
     44        Int ?=?( Int & lhs, unsigned long int rhs ) { mpz_set_ui( lhs.mpz, rhs ); return lhs; }
     45        Int ?=?( Int & lhs, const char * rhs ) { if ( mpz_set_str( lhs.mpz, rhs, 0 ) ) { printf( "invalid string conversion\n" ); abort(); } return lhs; }
     46
     47        char ?=?( char & lhs, Int rhs ) { char val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
     48        short int ?=?( short int & lhs, Int rhs ) { short int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
     49        int ?=?( int & lhs, Int rhs ) { int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
     50        long int ?=?( long int & lhs, Int rhs ) { long int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
     51        unsigned char ?=?( unsigned char & lhs, Int rhs ) { unsigned char val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; }
     52        unsigned short int ?=?( unsigned short int & lhs, Int rhs ) { unsigned short int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; }
     53        unsigned int ?=?( unsigned int & lhs, Int rhs ) { unsigned int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; }
     54        unsigned long int ?=?( unsigned long int & lhs, Int rhs ) { unsigned long int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; }
     55
     56        // conversions
     57        long int narrow( Int val ) { return mpz_get_si( val.mpz ); }
     58        unsigned long int narrow( Int val ) { return mpz_get_ui( val.mpz ); }
     59
     60        // comparison
     61        int ?==?( Int oper1, Int oper2 ) { return mpz_cmp( oper1.mpz, oper2.mpz ) == 0; }
     62        int ?==?( Int oper1, long int oper2 ) { return mpz_cmp_si( oper1.mpz, oper2 ) == 0; }
     63        int ?==?( long int oper2, Int oper1 ) { return mpz_cmp_si( oper1.mpz, oper2 ) == 0; }
     64        int ?==?( Int oper1, unsigned long int oper2 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) == 0; }
     65        int ?==?( unsigned long int oper2, Int oper1 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) == 0; }
     66
     67        int ?!=?( Int oper1, Int oper2 ) { return ! ( oper1 == oper2 ); }
     68        int ?!=?( Int oper1, long int oper2 ) { return ! ( oper1 == oper2 ); }
     69        int ?!=?( long int oper1, Int oper2 ) { return ! ( oper1 == oper2 ); }
     70        int ?!=?( Int oper1, unsigned long int oper2 ) { return ! ( oper1 == oper2 ); }
     71        int ?!=?( unsigned long int oper1, Int oper2 ) { return ! ( oper1 == oper2 ); }
     72
     73        int ?<?( Int oper1, Int oper2 ) { return mpz_cmp( oper1.mpz, oper2.mpz ) < 0; }
     74        int ?<?( Int oper1, long int oper2 ) { return mpz_cmp_si( oper1.mpz, oper2 ) < 0; }
     75        int ?<?( long int oper2, Int oper1 ) { return mpz_cmp_si( oper1.mpz, oper2 ) < 0; }
     76        int ?<?( Int oper1, unsigned long int oper2 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) < 0; }
     77        int ?<?( unsigned long int oper2, Int oper1 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) < 0; }
     78
     79        int ?<=?( Int oper1, Int oper2 ) { return mpz_cmp( oper1.mpz, oper2.mpz ) <= 0; }
     80        int ?<=?( Int oper1, long int oper2 ) { return mpz_cmp_si( oper1.mpz, oper2 ) <= 0; }
     81        int ?<=?( long int oper2, Int oper1 ) { return mpz_cmp_si( oper1.mpz, oper2 ) <= 0; }
     82        int ?<=?( Int oper1, unsigned long int oper2 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) <= 0; }
     83        int ?<=?( unsigned long int oper2, Int oper1 ) { return mpz_cmp_ui( oper1.mpz, oper2 ) <= 0; }
     84
     85        int ?>?( Int oper1, Int oper2 ) { return ! ( oper1 <= oper2 ); }
     86        int ?>?( Int oper1, long int oper2 ) { return ! ( oper1 <= oper2 ); }
     87        int ?>?( long int oper1, Int oper2 ) { return ! ( oper1 <= oper2 ); }
     88        int ?>?( Int oper1, unsigned long int oper2 ) { return ! ( oper1 <= oper2 ); }
     89        int ?>?( unsigned long int oper1, Int oper2 ) { return ! ( oper1 <= oper2 ); }
     90
     91        int ?>=?( Int oper1, Int oper2 ) { return ! ( oper1 < oper2 ); }
     92        int ?>=?( Int oper1, long int oper2 ) { return ! ( oper1 < oper2 ); }
     93        int ?>=?( long int oper1, Int oper2 ) { return ! ( oper1 < oper2 ); }
     94        int ?>=?( Int oper1, unsigned long int oper2 ) { return ! ( oper1 < oper2 ); }
     95        int ?>=?( unsigned long int oper1, Int oper2 ) { return ! ( oper1 < oper2 ); }
     96
     97        // arithmetic
     98        Int +?( Int oper ) { Int pos; mpz_set( pos.mpz, oper.mpz ); return pos; }
     99        Int -?( Int oper ) { Int neg; mpz_neg( neg.mpz, oper.mpz ); return neg; }
     100        Int ~?( Int oper ) { Int comp; mpz_com( comp.mpz, oper.mpz ); return comp; }
     101
     102        Int ?&?( Int oper1, Int oper2 ) { Int conjunction; mpz_and( conjunction.mpz, oper1.mpz, oper2.mpz ); return conjunction; }
     103        Int ?&?( Int oper1, long int oper2 ) { Int conjunction, temp; mpz_set_si( temp.mpz, oper2 ); mpz_and( conjunction.mpz, oper1.mpz, temp.mpz ); return conjunction; }
     104        Int ?&?( long int oper1, Int oper2 ) { Int conjunction, temp; mpz_set_si( temp.mpz, oper1 ); mpz_and( conjunction.mpz, temp.mpz, oper2.mpz ); return conjunction; }
     105        Int ?&?( Int oper1, unsigned long int oper2 ) { Int conjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_and( conjunction.mpz, oper1.mpz, temp.mpz ); return conjunction; }
     106        Int ?&?( unsigned long int oper1, Int oper2 ) { Int conjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_and( conjunction.mpz, temp.mpz, oper2.mpz ); return conjunction; }
     107        Int ?&=?( Int & lhs, Int rhs ) { return lhs = lhs & rhs; }
     108
     109        Int ?|?( Int oper1, Int oper2 ) { Int disjunction; mpz_ior( disjunction.mpz, oper1.mpz, oper2.mpz ); return disjunction; }
     110        Int ?|?( Int oper1, long int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
     111        Int ?|?( long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
     112        Int ?|?( Int oper1, unsigned long int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
     113        Int ?|?( unsigned long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
     114        Int ?|=?( Int & lhs, Int rhs ) { return lhs = lhs | rhs; }
     115
     116        Int ?^?( Int oper1, Int oper2 ) { Int disjunction; mpz_xor( disjunction.mpz, oper1.mpz, oper2.mpz ); return disjunction; }
     117        Int ?^?( Int oper1, long int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
     118        Int ?^?( long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_si( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
     119        Int ?^?( Int oper1, unsigned long int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
     120        Int ?^?( unsigned long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
     121        Int ?^=?( Int & lhs, Int rhs ) { return lhs = lhs ^ rhs; }
     122
     123        Int ?+?( Int addend1, Int addend2 ) { Int sum; mpz_add( sum.mpz, addend1.mpz, addend2.mpz ); return sum; }
     124        Int ?+?( Int addend1, long int addend2 ) { Int sum; if ( addend2 >= 0 ) mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); else mpz_sub_ui( sum.mpz, addend1.mpz, -addend2 ); return sum; }
     125        Int ?+?( long int addend2, Int addend1 ) { Int sum; if ( addend2 >= 0 ) mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); else mpz_sub_ui( sum.mpz, addend1.mpz, -addend2 ); return sum; }
     126        Int ?+?( Int addend1, unsigned long int addend2 ) { Int sum; mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); return sum; }
     127        Int ?+?( unsigned long int addend2, Int addend1 ) { Int sum; mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); return sum; }
     128        Int ?+=?( Int & lhs, Int rhs ) { return lhs = lhs + rhs; }
     129        Int ?+=?( Int & lhs, long int rhs ) { return lhs = lhs + rhs; }
     130        Int ?+=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs + rhs; }
     131        Int ++?( Int & lhs ) { return lhs += 1; }
     132        Int ?++( Int & lhs ) { Int ret = lhs; lhs += 1; return ret; }
     133
     134        Int ?-?( Int minuend, Int subtrahend ) { Int diff; mpz_sub( diff.mpz, minuend.mpz, subtrahend.mpz ); return diff; }
     135        Int ?-?( Int minuend, long int subtrahend ) { Int diff; if ( subtrahend >= 0 ) mpz_sub_ui( diff.mpz, minuend.mpz, subtrahend ); else mpz_add_ui( diff.mpz, minuend.mpz, -subtrahend ); return diff; }
     136        Int ?-?( long int minuend, Int subtrahend ) { Int diff; if ( subtrahend >= 0 ) mpz_ui_sub( diff.mpz, minuend, subtrahend.mpz ); else { mpz_add_ui( diff.mpz, subtrahend.mpz, -minuend ); mpz_neg( diff.mpz, diff.mpz ); } return diff; }
     137        Int ?-?( Int minuend, unsigned long int subtrahend ) { Int diff; mpz_sub_ui( diff.mpz, minuend.mpz, subtrahend ); return diff; }
     138        Int ?-?( unsigned long int minuend, Int subtrahend ) { Int diff; mpz_ui_sub( diff.mpz, minuend, subtrahend.mpz ); return diff; }
     139        Int ?-=?( Int & lhs, Int rhs ) { return lhs = lhs - rhs; }
     140        Int ?-=?( Int & lhs, long int rhs ) { return lhs = lhs - rhs; }
     141        Int ?-=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs - rhs; }
     142        Int --?( Int & lhs ) { return lhs -= 1; }
     143        Int ?--( Int & lhs ) { Int ret = lhs; lhs -= 1; return ret; }
     144
     145        Int ?*?( Int multiplicator, Int multiplicand ) { Int product; mpz_mul( product.mpz, multiplicator.mpz, multiplicand.mpz ); return product; }
     146        Int ?*?( Int multiplicator, long int multiplicand ) { Int product; mpz_mul_si( product.mpz, multiplicator.mpz, multiplicand ); return product; }
     147        Int ?*?( long int multiplicand, Int multiplicator ) { Int product; mpz_mul_si( product.mpz, multiplicator.mpz, multiplicand ); return product; }
     148        Int ?*?( Int multiplicator, unsigned long int multiplicand ) { Int product; mpz_mul_ui( product.mpz, multiplicator.mpz, multiplicand ); return product; }
     149        Int ?*?( unsigned long int multiplicand, Int multiplicator ) { Int product; mpz_mul_ui( product.mpz, multiplicator.mpz, multiplicand ); return product; }
     150        Int ?*=?( Int & lhs, Int rhs ) { return lhs = lhs * rhs; }
     151        Int ?*=?( Int & lhs, long int rhs ) { return lhs = lhs * rhs; }
     152        Int ?*=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs * rhs; }
     153
     154        // some code for operators "/" and "%" taken from g++ gmpxx.h
     155        Int ?/?( Int dividend, Int divisor ) { Int quotient; mpz_tdiv_q( quotient.mpz, dividend.mpz, divisor.mpz ); return quotient; }
     156        Int ?/?( Int dividend, unsigned long int divisor ) { Int quotient; mpz_tdiv_q_ui( quotient.mpz, dividend.mpz, divisor ); return quotient; }
     157        Int ?/?( unsigned long int dividend, Int divisor ) {
     158                Int quotient;
     159                if ( mpz_sgn( divisor.mpz ) >= 0 ) {
     160                        if ( mpz_fits_ulong_p( divisor.mpz ) )
     161                                mpz_set_ui( quotient.mpz, dividend / mpz_get_ui( divisor.mpz ) );
     162                        else
     163                                mpz_set_ui( quotient.mpz, 0 );
     164                } else {
     165                        mpz_neg( quotient.mpz, divisor.mpz );
     166                        if ( mpz_fits_ulong_p( quotient.mpz ) ) {
     167                                mpz_set_ui( quotient.mpz, dividend / mpz_get_ui( quotient.mpz ) );
     168                                mpz_neg( quotient.mpz, quotient.mpz );
     169                        } else
     170                                mpz_set_ui( quotient.mpz, 0 );
     171                } // if
     172                return quotient;
     173        } // ?/?
     174        Int ?/?( Int dividend, long int divisor ) {
     175                Int quotient;
     176                if ( divisor >= 0 )
     177                        mpz_tdiv_q_ui( quotient.mpz, dividend.mpz, divisor );
     178                else {
     179                        mpz_tdiv_q_ui( quotient.mpz, dividend.mpz, -divisor );
    167180                        mpz_neg( quotient.mpz, quotient.mpz );
    168                 } else
    169                         mpz_set_ui( quotient.mpz, 0 );
    170         } // if
    171         return quotient;
    172 } // ?/?
    173 static inline Int ?/?( Int dividend, long int divisor ) {
    174         Int quotient;
    175     if ( divisor >= 0 )
    176                 mpz_tdiv_q_ui( quotient.mpz, dividend.mpz, divisor );
    177     else {
    178                 mpz_tdiv_q_ui( quotient.mpz, dividend.mpz, -divisor );
    179                 mpz_neg( quotient.mpz, quotient.mpz );
    180         } // if
    181         return quotient;
    182 } // ?/?
    183 static inline Int ?/?( long int dividend, Int divisor ) {
    184         Int quotient;
    185     if ( mpz_fits_slong_p( divisor.mpz ) )
    186                 mpz_set_si( quotient.mpz, dividend / mpz_get_si( divisor.mpz ) );
    187     else {
    188         // if divisor is bigger than a long then the quotient must be zero, unless dividend==LONG_MIN and
    189         // dividend==-LONG_MIN in which case the quotient is -1
    190         mpz_set_si( quotient.mpz, mpz_cmpabs_ui( divisor.mpz, (dividend >= 0 ? dividend : -dividend)) == 0 ? -1 : 0 );
    191         } // if
    192         return quotient;
    193 } // ?/?
    194 static inline Int ?/=?( Int & lhs, Int rhs ) { return lhs = lhs / rhs; }
    195 static inline Int ?/=?( Int & lhs, long int rhs ) { return lhs = lhs / rhs; }
    196 static inline Int ?/=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs / rhs; }
    197 
    198 static inline [ Int, Int ] div( Int dividend, Int divisor ) { Int quotient, remainder; mpz_fdiv_qr( quotient.mpz, remainder.mpz, dividend.mpz, divisor.mpz ); return [ quotient, remainder ]; }
    199 static inline [ Int, Int ] div( Int dividend, unsigned long int divisor ) { Int quotient, remainder; mpz_fdiv_qr_ui( quotient.mpz, remainder.mpz, dividend.mpz, divisor ); return [ quotient, remainder ]; }
    200 
    201 static inline Int ?%?( Int dividend, Int divisor ) { Int remainder; mpz_tdiv_r( remainder.mpz, dividend.mpz, divisor.mpz ); return remainder; }
    202 static inline Int ?%?( Int dividend, unsigned long int divisor ) { Int remainder; mpz_tdiv_r_ui( remainder.mpz, dividend.mpz, divisor ); return remainder; }
    203 static inline Int ?%?( unsigned long int dividend, Int divisor ) {
    204         Int remainder;
    205     if ( mpz_sgn( divisor.mpz ) >= 0 ) {
    206                 if ( mpz_fits_ulong_p( divisor.mpz ) )
    207                         mpz_set_ui( remainder.mpz, dividend % mpz_get_ui( divisor.mpz ) );
    208                 else
    209                         mpz_set_ui( remainder.mpz, dividend );
    210         } else {
    211                 mpz_neg( remainder.mpz, divisor.mpz );
    212                 if ( mpz_fits_ulong_p( remainder.mpz ) )
    213                         mpz_set_ui( remainder.mpz, dividend % mpz_get_ui( remainder.mpz ) );
    214                 else
    215                         mpz_set_ui( remainder.mpz, dividend );
    216         } // if
    217         return remainder;
    218 } // ?%?
    219 static inline Int ?%?( Int dividend, long int divisor ) {
    220         Int remainder;
    221     mpz_tdiv_r_ui( remainder.mpz, dividend.mpz, (divisor >= 0 ? divisor : -divisor));
    222         return remainder;
    223 } // ?%?
    224 static inline Int ?%?( long int dividend, Int divisor ) {
    225         Int remainder;
    226     if ( mpz_fits_slong_p( divisor.mpz ) )
    227                 mpz_set_si( remainder.mpz, dividend % mpz_get_si( divisor.mpz ) );
    228         else {
    229                 // if divisor is bigger than a long then the remainder is dividend unchanged, unless dividend==LONG_MIN and
    230                 // dividend==-LONG_MIN in which case the remainder is 0
    231         mpz_set_si( remainder.mpz, mpz_cmpabs_ui( divisor.mpz, (dividend >= 0 ? dividend : -dividend)) == 0 ? 0 : dividend);
    232         } // if
    233         return remainder;
    234 } // ?%?
    235 static inline Int ?%=?( Int & lhs, Int rhs ) { return lhs = lhs % rhs; }
    236 static inline Int ?%=?( Int & lhs, long int rhs ) { return lhs = lhs % rhs; }
    237 static inline Int ?%=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs % rhs; }
    238 
    239 static inline Int ?<<?( Int shiften, mp_bitcnt_t shift ) { Int shifted; mpz_mul_2exp( shifted.mpz, shiften.mpz, shift ); return shifted; }
    240 static inline Int ?<<=?( Int & lhs, mp_bitcnt_t shift ) { return lhs = lhs << shift; }
    241 static inline Int ?>>?( Int shiften, mp_bitcnt_t shift ) { Int shifted; mpz_fdiv_q_2exp( shifted.mpz, shiften.mpz, shift ); return shifted; }
    242 static inline Int ?>>=?( Int & lhs, mp_bitcnt_t shift ) { return lhs = lhs >> shift; }
    243 
    244 // number functions
    245 static inline Int abs( Int oper ) { Int positive; mpz_abs( positive.mpz, oper.mpz ); return positive; }
    246 static inline Int fact( unsigned long int N ) { Int factorial; mpz_fac_ui( factorial.mpz, N ); return factorial; }
    247 static inline Int gcd( Int oper1, Int oper2 ) { Int gcdret; mpz_gcd( gcdret.mpz, oper1.mpz, oper2.mpz ); return gcdret; }
    248 static inline Int pow( Int base, unsigned long int exponent ) { Int power; mpz_pow_ui( power.mpz, base.mpz, exponent ); return power; }
    249 static inline Int pow( unsigned long int base, unsigned long int exponent ) { Int power; mpz_ui_pow_ui( power.mpz, base, exponent ); return power; }
    250 static inline void srandom( gmp_randstate_t state ) { gmp_randinit_default( state ); }
    251 static inline Int random( gmp_randstate_t state, mp_bitcnt_t n ) { Int rand; mpz_urandomb( rand.mpz, state, n ); return rand; }
    252 static inline Int random( gmp_randstate_t state, Int n ) { Int rand; mpz_urandomm( rand.mpz, state, n.mpz ); return rand; }
    253 static inline Int random( gmp_randstate_t state, mp_size_t max_size ) { Int rand; mpz_random( rand.mpz, max_size ); return rand; }
    254 static inline int sgn( Int oper ) { return mpz_sgn( oper.mpz ); }
    255 static inline Int sqrt( Int oper ) { Int root; mpz_sqrt( root.mpz, oper.mpz ); return root; }
    256 
    257 // I/O
    258 static inline forall( dtype istype | istream( istype ) )
    259 istype & ?|?( istype & is, Int & mp ) {
    260         gmp_scanf( "%Zd", &mp );
    261         return is;
    262 } // ?|?
    263 
    264 static inline forall( dtype ostype | ostream( ostype ) ) {
    265         ostype & ?|?( ostype & os, Int mp ) {
    266                 if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
    267                 gmp_printf( "%Zd", mp.mpz );
    268                 sepOn( os );
    269                 return os;
     181                } // if
     182                return quotient;
     183        } // ?/?
     184        Int ?/?( long int dividend, Int divisor ) {
     185                Int quotient;
     186                if ( mpz_fits_slong_p( divisor.mpz ) )
     187                        mpz_set_si( quotient.mpz, dividend / mpz_get_si( divisor.mpz ) );
     188                else {
     189                        // if divisor is bigger than a long then the quotient must be zero, unless dividend==LONG_MIN and
     190                        // dividend==-LONG_MIN in which case the quotient is -1
     191                        mpz_set_si( quotient.mpz, mpz_cmpabs_ui( divisor.mpz, (dividend >= 0 ? dividend : -dividend)) == 0 ? -1 : 0 );
     192                } // if
     193                return quotient;
     194        } // ?/?
     195        Int ?/=?( Int & lhs, Int rhs ) { return lhs = lhs / rhs; }
     196        Int ?/=?( Int & lhs, long int rhs ) { return lhs = lhs / rhs; }
     197        Int ?/=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs / rhs; }
     198
     199        [ Int, Int ] div( Int dividend, Int divisor ) { Int quotient, remainder; mpz_fdiv_qr( quotient.mpz, remainder.mpz, dividend.mpz, divisor.mpz ); return [ quotient, remainder ]; }
     200        [ Int, Int ] div( Int dividend, unsigned long int divisor ) { Int quotient, remainder; mpz_fdiv_qr_ui( quotient.mpz, remainder.mpz, dividend.mpz, divisor ); return [ quotient, remainder ]; }
     201
     202        Int ?%?( Int dividend, Int divisor ) { Int remainder; mpz_tdiv_r( remainder.mpz, dividend.mpz, divisor.mpz ); return remainder; }
     203        Int ?%?( Int dividend, unsigned long int divisor ) { Int remainder; mpz_tdiv_r_ui( remainder.mpz, dividend.mpz, divisor ); return remainder; }
     204        Int ?%?( unsigned long int dividend, Int divisor ) {
     205                Int remainder;
     206                if ( mpz_sgn( divisor.mpz ) >= 0 ) {
     207                        if ( mpz_fits_ulong_p( divisor.mpz ) )
     208                                mpz_set_ui( remainder.mpz, dividend % mpz_get_ui( divisor.mpz ) );
     209                        else
     210                                mpz_set_ui( remainder.mpz, dividend );
     211                } else {
     212                        mpz_neg( remainder.mpz, divisor.mpz );
     213                        if ( mpz_fits_ulong_p( remainder.mpz ) )
     214                                mpz_set_ui( remainder.mpz, dividend % mpz_get_ui( remainder.mpz ) );
     215                        else
     216                                mpz_set_ui( remainder.mpz, dividend );
     217                } // if
     218                return remainder;
     219        } // ?%?
     220        Int ?%?( Int dividend, long int divisor ) {
     221                Int remainder;
     222                mpz_tdiv_r_ui( remainder.mpz, dividend.mpz, (divisor >= 0 ? divisor : -divisor));
     223                return remainder;
     224        } // ?%?
     225        Int ?%?( long int dividend, Int divisor ) {
     226                Int remainder;
     227                if ( mpz_fits_slong_p( divisor.mpz ) )
     228                        mpz_set_si( remainder.mpz, dividend % mpz_get_si( divisor.mpz ) );
     229                else {
     230                        // if divisor is bigger than a long then the remainder is dividend unchanged, unless dividend==LONG_MIN and
     231                        // dividend==-LONG_MIN in which case the remainder is 0
     232                        mpz_set_si( remainder.mpz, mpz_cmpabs_ui( divisor.mpz, (dividend >= 0 ? dividend : -dividend)) == 0 ? 0 : dividend);
     233                } // if
     234                return remainder;
     235        } // ?%?
     236        Int ?%=?( Int & lhs, Int rhs ) { return lhs = lhs % rhs; }
     237        Int ?%=?( Int & lhs, long int rhs ) { return lhs = lhs % rhs; }
     238        Int ?%=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs % rhs; }
     239
     240        Int ?<<?( Int shiften, mp_bitcnt_t shift ) { Int shifted; mpz_mul_2exp( shifted.mpz, shiften.mpz, shift ); return shifted; }
     241        Int ?<<=?( Int & lhs, mp_bitcnt_t shift ) { return lhs = lhs << shift; }
     242        Int ?>>?( Int shiften, mp_bitcnt_t shift ) { Int shifted; mpz_fdiv_q_2exp( shifted.mpz, shiften.mpz, shift ); return shifted; }
     243        Int ?>>=?( Int & lhs, mp_bitcnt_t shift ) { return lhs = lhs >> shift; }
     244
     245        // number functions
     246        Int abs( Int oper ) { Int positive; mpz_abs( positive.mpz, oper.mpz ); return positive; }
     247        Int fact( unsigned long int N ) { Int factorial; mpz_fac_ui( factorial.mpz, N ); return factorial; }
     248        Int gcd( Int oper1, Int oper2 ) { Int gcdret; mpz_gcd( gcdret.mpz, oper1.mpz, oper2.mpz ); return gcdret; }
     249        Int pow( Int base, unsigned long int exponent ) { Int power; mpz_pow_ui( power.mpz, base.mpz, exponent ); return power; }
     250        Int pow( unsigned long int base, unsigned long int exponent ) { Int power; mpz_ui_pow_ui( power.mpz, base, exponent ); return power; }
     251        void srandom( gmp_randstate_t state ) { gmp_randinit_default( state ); }
     252        Int random( gmp_randstate_t state, mp_bitcnt_t n ) { Int rand; mpz_urandomb( rand.mpz, state, n ); return rand; }
     253        Int random( gmp_randstate_t state, Int n ) { Int rand; mpz_urandomm( rand.mpz, state, n.mpz ); return rand; }
     254        Int random( gmp_randstate_t state, mp_size_t max_size ) { Int rand; mpz_random( rand.mpz, max_size ); return rand; }
     255        int sgn( Int oper ) { return mpz_sgn( oper.mpz ); }
     256        Int sqrt( Int oper ) { Int root; mpz_sqrt( root.mpz, oper.mpz ); return root; }
     257
     258        // I/O
     259        forall( dtype istype | istream( istype ) )
     260                istype & ?|?( istype & is, Int & mp ) {
     261                gmp_scanf( "%Zd", &mp );
     262                return is;
    270263        } // ?|?
    271264
    272         void ?|?( ostype & os, Int mp ) {
    273                 (ostype)(os | mp); nl( os );
    274         } // ?|?
     265        forall( dtype ostype | ostream( ostype ) ) {
     266                ostype & ?|?( ostype & os, Int mp ) {
     267                        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     268                        gmp_printf( "%Zd", mp.mpz );
     269                        sepOn( os );
     270                        return os;
     271                } // ?|?
     272
     273                void ?|?( ostype & os, Int mp ) {
     274                        (ostype)(os | mp); ends( os );
     275                } // ?|?
     276        } // distribution
    275277} // distribution
    276278
  • libcfa/src/iostream.cfa

    r1d760934 r65240bb  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jun 13 17:21:10 2019
    13 // Update Count     : 812
     12// Last Modified On : Fri Jul 12 12:04:13 2019
     13// Update Count     : 819
    1414//
    1515
     
    3030
    3131
    32 //*********************************** Ostream ***********************************
     32//*********************************** ostream ***********************************
    3333
    3434
     
    4040        } // ?|?
    4141        void ?|?( ostype & os, zero_t z ) {
    42                 (ostype &)(os | z); nl( os );
     42                (ostype &)(os | z); ends( os );
    4343        } // ?|?
    4444
     
    4949        } // ?|?
    5050        void ?|?( ostype & os, one_t o ) {
    51                 (ostype &)(os | o); nl( os );
     51                (ostype &)(os | o); ends( os );
    5252        } // ?|?
    5353
     
    5858        } // ?|?
    5959        void ?|?( ostype & os, bool b ) {
    60                 (ostype &)(os | b); nl( os );
     60                (ostype &)(os | b); ends( os );
    6161        } // ?|?
    6262
     
    6767        } // ?|?
    6868        void ?|?( ostype & os, char c ) {
    69                 (ostype &)(os | c); nl( os );
     69                (ostype &)(os | c); ends( os );
    7070        } // ?|?
    7171
     
    7676        } // ?|?
    7777        void ?|?( ostype & os, signed char sc ) {
    78                 (ostype &)(os | sc); nl( os );
     78                (ostype &)(os | sc); ends( os );
    7979        } // ?|?
    8080
     
    8585        } // ?|?
    8686        void ?|?( ostype & os, unsigned char usc ) {
    87                 (ostype &)(os | usc); nl( os );
     87                (ostype &)(os | usc); ends( os );
    8888        } // ?|?
    8989
     
    9494        } // ?|?
    9595        void & ?|?( ostype & os, short int si ) {
    96                 (ostype &)(os | si); nl( os );
     96                (ostype &)(os | si); ends( os );
    9797        } // ?|?
    9898
     
    103103        } // ?|?
    104104        void & ?|?( ostype & os, unsigned short int usi ) {
    105                 (ostype &)(os | usi); nl( os );
     105                (ostype &)(os | usi); ends( os );
    106106        } // ?|?
    107107
     
    112112        } // ?|?
    113113        void & ?|?( ostype & os, int i ) {
    114                 (ostype &)(os | i); nl( os );
     114                (ostype &)(os | i); ends( os );
    115115        } // ?|?
    116116
     
    121121        } // ?|?
    122122        void & ?|?( ostype & os, unsigned int ui ) {
    123                 (ostype &)(os | ui); nl( os );
     123                (ostype &)(os | ui); ends( os );
    124124        } // ?|?
    125125
     
    130130        } // ?|?
    131131        void & ?|?( ostype & os, long int li ) {
    132                 (ostype &)(os | li); nl( os );
     132                (ostype &)(os | li); ends( os );
    133133        } // ?|?
    134134
     
    139139        } // ?|?
    140140        void & ?|?( ostype & os, unsigned long int uli ) {
    141                 (ostype &)(os | uli); nl( os );
     141                (ostype &)(os | uli); ends( os );
    142142        } // ?|?
    143143
     
    148148        } // ?|?
    149149        void & ?|?( ostype & os, long long int lli ) {
    150                 (ostype &)(os | lli); nl( os );
     150                (ostype &)(os | lli); ends( os );
    151151        } // ?|?
    152152
     
    157157        } // ?|?
    158158        void & ?|?( ostype & os, unsigned long long int ulli ) {
    159                 (ostype &)(os | ulli); nl( os );
     159                (ostype &)(os | ulli); ends( os );
    160160        } // ?|?
    161161
     
    180180        } // ?|?
    181181        void & ?|?( ostype & os, float f ) {
    182                 (ostype &)(os | f); nl( os );
     182                (ostype &)(os | f); ends( os );
    183183        } // ?|?
    184184
     
    189189        } // ?|?
    190190        void & ?|?( ostype & os, double d ) {
    191                 (ostype &)(os | d); nl( os );
     191                (ostype &)(os | d); ends( os );
    192192        } // ?|?
    193193
     
    198198        } // ?|?
    199199        void & ?|?( ostype & os, long double ld ) {
    200                 (ostype &)(os | ld); nl( os );
     200                (ostype &)(os | ld); ends( os );
    201201        } // ?|?
    202202
     
    210210        } // ?|?
    211211        void & ?|?( ostype & os, float _Complex fc ) {
    212                 (ostype &)(os | fc); nl( os );
     212                (ostype &)(os | fc); ends( os );
    213213        } // ?|?
    214214
     
    222222        } // ?|?
    223223        void & ?|?( ostype & os, double _Complex dc ) {
    224                 (ostype &)(os | dc); nl( os );
     224                (ostype &)(os | dc); ends( os );
    225225        } // ?|?
    226226
     
    234234        } // ?|?
    235235        void & ?|?( ostype & os, long double _Complex ldc ) {
    236                 (ostype &)(os | ldc); nl( os );
     236                (ostype &)(os | ldc); ends( os );
    237237        } // ?|?
    238238
     
    276276        } // ?|?
    277277        void ?|?( ostype & os, const char * str ) {
    278                 (ostype &)(os | str); nl( os );
     278                (ostype &)(os | str); ends( os );
    279279        } // ?|?
    280280
     
    305305        } // ?|?
    306306        void ?|?( ostype & os, const void * p ) {
    307                 (ostype &)(os | p); nl( os );
     307                (ostype &)(os | p); ends( os );
    308308        } // ?|?
    309309
     
    315315        void ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
    316316                (ostype &)(manip( os ));
    317                 if ( getPrt( os ) ) nl( os );                                   // something printed ?
     317                if ( getPrt( os ) ) ends( os );                                 // something printed ?
    318318                setPrt( os, false );                                                    // turn off
    319319        } // ?|?
     
    335335        } // nl
    336336
    337         void nl( ostype & os ) {
    338                 if ( getANL( os ) ) (ostype &)(nl( os ));               // implementation only
    339                 else setPrt( os, false );                                               // turn off
    340         } // nl
    341 
    342337        ostype & nonl( ostype & os ) {
    343338                setPrt( os, false );                                                    // turn off
     
    386381        } // ?|?
    387382        void ?|?( ostype & os, T arg, Params rest ) {
    388                 // (ostype &)(?|?( os, arg, rest )); nl( os );
     383                // (ostype &)(?|?( os, arg, rest )); ends( os );
    389384                (ostype &)(os | arg);                                                   // print first argument
    390385                sepSetCur( os, sepGetTuple( os ) );                             // switch to tuple separator
    391386                (ostype &)(os | rest);                                                  // print remaining arguments
    392387                sepSetCur( os, sepGet( os ) );                                  // switch to regular separator
    393                 nl( os );
     388                ends( os );
    394389        } // ?|?
    395390} // distribution
     
    408403} // distribution
    409404
    410 //*********************************** Manipulators ***********************************
    411 
    412 //*********************************** Integral ***********************************
     405//*********************************** manipulators ***********************************
     406
     407//*********************************** integral ***********************************
    413408
    414409static const char * shortbin[] = { "0", "1", "10", "11", "100", "101", "110", "111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111" };
     
    478473                return os; \
    479474        } /* ?|? */ \
    480         void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); nl( os ); } \
     475        void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \
    481476} // distribution
    482477
     
    492487IntegralFMTImpl( unsigned long long int, 'u', "%    *ll ", "%    *.*ll " )
    493488
    494 //*********************************** Floating Point ***********************************
     489//*********************************** floating point ***********************************
    495490
    496491#define PrintWithDP2( os, format, val, ... ) \
     
    541536                return os; \
    542537        } /* ?|? */ \
    543         void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); nl( os ); } \
     538        void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \
    544539} // distribution
    545540
     
    547542FloatingPointFMTImpl( long double, "%    *L ", "%    *.*L " )
    548543
    549 //*********************************** Character ***********************************
     544//*********************************** character ***********************************
    550545
    551546forall( dtype ostype | ostream( ostype ) ) {
     
    576571                return os;
    577572        } // ?|?
    578         void ?|?( ostype & os, _Ostream_Manip(char) f ) { (ostype &)(os | f); nl( os ); }
     573        void ?|?( ostype & os, _Ostream_Manip(char) f ) { (ostype &)(os | f); ends( os ); }
    579574} // distribution
    580575
    581 //*********************************** C String ***********************************
     576//*********************************** C string ***********************************
    582577
    583578forall( dtype ostype | ostream( ostype ) ) {
     
    621616                return os;
    622617        } // ?|?
    623         void ?|?( ostype & os, _Ostream_Manip(const char *) f ) { (ostype &)(os | f); nl( os ); }
     618        void ?|?( ostype & os, _Ostream_Manip(const char *) f ) { (ostype &)(os | f); ends( os ); }
    624619} // distribution
    625620
    626621
    627 //*********************************** Istream ***********************************
     622//*********************************** istream ***********************************
    628623
    629624
     
    771766} // distribution
    772767
    773 //*********************************** Manipulators ***********************************
     768//*********************************** manipulators ***********************************
    774769
    775770forall( dtype istype | istream( istype ) )
  • libcfa/src/iostream.hfa

    r1d760934 r65240bb  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jun 13 17:20:21 2019
    13 // Update Count     : 325
     12// Last Modified On : Fri Jul 12 12:08:38 2019
     13// Update Count     : 334
    1414//
    1515
     
    1919
    2020
    21 //*********************************** Ostream ***********************************
     21//*********************************** ostream ***********************************
    2222
    2323
     
    4747        void sepSetTuple( ostype &, const char * );                     // set tuple separator to string (15 character maximum)
    4848
     49        void ends( ostype & os );                                                       // end of output statement
    4950        int fail( ostype & );
    5051        int flush( ostype & );
     
    9899        void ?|?( ostype &, unsigned long long int );
    99100
    100         ostype & ?|?( ostype &, float ); // FIX ME: should not be required
    101         void ?|?( ostype &, float ); // FIX ME: should not be required
     101        ostype & ?|?( ostype &, float );
     102        void ?|?( ostype &, float );
    102103        ostype & ?|?( ostype &, double );
    103104        void ?|?( ostype &, double );
     
    126127        void ?|?( ostype &, ostype & (*)( ostype & ) );
    127128        ostype & nl( ostype & );
    128         void nl( ostype & );
    129129        ostype & nonl( ostype & );
    130130        ostype & sep( ostype & );
     
    150150} // distribution
    151151
    152 //*********************************** Manipulators ***********************************
     152//*********************************** manipulators ***********************************
    153153
    154154forall( otype T )
     
    169169}; // _Ostream_Manip
    170170
    171 //*********************************** Integral ***********************************
     171//*********************************** integral ***********************************
    172172
    173173// See 6.7.9. 19) The initialization shall occur in initializer list order, each initializer provided for a particular
     
    207207IntegralFMTDecl( unsigned long long int, 'u' )
    208208
    209 //*********************************** Floating Point ***********************************
     209//*********************************** floating point ***********************************
    210210
    211211// Default suffix for values with no fraction is "."
     
    236236FloatingPointFMTDecl( long double )
    237237
    238 //*********************************** Character ***********************************
     238//*********************************** character ***********************************
    239239
    240240static inline {
     
    253253} // ?|?
    254254
    255 //*********************************** C String ***********************************
     255//*********************************** C string ***********************************
    256256
    257257static inline {
     
    272272
    273273
    274 //*********************************** Istream ***********************************
     274//*********************************** istream ***********************************
    275275
    276276
     
    326326} // distribution
    327327
    328 //*********************************** Manipulators ***********************************
     328//*********************************** manipulators ***********************************
    329329
    330330struct _Istream_Cstr {
     
    403403
    404404
    405 //*********************************** Time ***********************************
     405//*********************************** time ***********************************
    406406
    407407
  • libcfa/src/rational.cfa

    r1d760934 r65240bb  
    1010// Created On       : Wed Apr  6 17:54:28 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 28 17:33:03 2019
    13 // Update Count     : 181
     12// Last Modified On : Fri Jul 12 12:02:36 2019
     13// Update Count     : 183
    1414//
    1515
     
    167167
    168168                void ?|?( ostype & os, Rational(RationalImpl) r ) {
    169                         (ostype &)(os | r); nl( os );
     169                        (ostype &)(os | r); ends( os );
    170170                } // ?|?
    171171        } // distribution
  • libcfa/src/time.cfa

    r1d760934 r65240bb  
    1010// Created On       : Tue Mar 27 13:33:14 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Dec 23 22:57:48 2018
    13 // Update Count     : 57
     12// Last Modified On : Fri Jul 12 12:03:19 2019
     13// Update Count     : 59
    1414//
    1515
     
    3737                if ( ns != 0 ) {                                                                // some ?
    3838                        char buf[16];
    39                         (ostype &)(os | nanomsd( ns, buf ));                    // print nanoseconds
     39                        (ostype &)(os | nanomsd( ns, buf ));            // print nanoseconds
    4040                } // if
    4141                return os;
     
    4343
    4444        void ?|?( ostype & os, Duration dur ) with( dur ) {
    45                 (ostype &)(os | dur); nl( os );
     45                (ostype &)(os | dur); ends( os );
    4646        } // ?|?
    4747} // distribution
     
    150150                long int ns = (tv < 0 ? -tv : tv) % TIMEGRAN;   // compute nanoseconds
    151151                if ( ns == 0 ) {                                                                // none ?
    152                         (ostype &)(os | buf);                                                   // print date/time/year
     152                        (ostype &)(os | buf);                                           // print date/time/year
    153153                } else {
    154154                        buf[19] = '\0';                                                         // truncate to "Wed Jun 30 21:49:08"
    155155                        char buf2[16];
    156156                        nanomsd( ns, buf2 );                                            // compute nanoseconds
    157                         (ostype &)(os | buf | buf2 | ' ' | &buf[20]);   // print date/time, nanoseconds and year
     157                        (ostype &)(os | buf | buf2 | ' ' | &buf[20]); // print date/time, nanoseconds and year
    158158                } // if
    159159                return os;
     
    161161
    162162        void ?|?( ostype & os, Time time ) with( time ) {
    163                 (ostype &)(os | time); nl( os );
     163                (ostype &)(os | time); ends( os );
    164164        } // ?|?
    165165} // distribution
  • tests/loopctrl.cfa

    r1d760934 r65240bb  
    1010// Created On       : Wed Aug  8 18:32:59 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Apr 13 11:03:09 2019
    13 // Update Count     : 104
     12// Last Modified On : Fri Jul 12 12:05:05 2019
     13// Update Count     : 106
    1414//
    1515
     
    3232S ?-=?( S & t, one_t ) { t.i -= 1; t.j -= 1; return t; }
    3333ofstream & ?|?( ofstream & os, S v ) { return os | '(' | v.i | v.j | ')'; }
    34 void & ?|?( ofstream & os, S v ) { (ofstream &)(os | v); nl( os ); }
     34void & ?|?( ofstream & os, S v ) { (ofstream &)(os | v); ends( os ); }
    3535
    3636int main() {
  • tests/math1.cfa

    r1d760934 r65240bb  
    1010// Created On       : Fri Apr 22 14:59:21 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar 25 22:56:47 2019
    13 // Update Count     : 109
     12// Last Modified On : Fri Jul 12 12:04:56 2019
     13// Update Count     : 111
    1414//
    1515
     
    5959        S ?\?( S s, unsigned long y ) { return (S){ s.i \ y }; }
    6060        ofstream & ?|?( ofstream & os, S s ) { return os | s.i; }
    61         void ?|?( ofstream & os, S s ) { (ofstream &)(os | s); nl( os ); }
     61        void ?|?( ofstream & os, S s ) { (ofstream &)(os | s); ends( os ); }
    6262        S s = { 4 };
    6363        S x = s \ 2;
  • tests/sum.cfa

    r1d760934 r65240bb  
    1111// Created On       : Wed May 27 17:56:53 2015
    1212// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Thu Jun  6 16:18:22 2019
    14 // Update Count     : 333
     13// Last Modified On : Fri Jul 12 12:05:16 2019
     14// Update Count     : 335
    1515//
    1616
     
    9797        S ?++( S & t ) { S temp = t; t += (S){1}; return temp; }
    9898        ofstream & ?|?( ofstream & os, S v ) { return os | v.i | v.j; }
    99         void ?|?( ofstream & os, S v ) { (ofstream &)(os | v); nl( os ); }
     99        void ?|?( ofstream & os, S v ) { (ofstream &)(os | v); ends( os ); }
    100100
    101101        S s = (S){0}, a[size], v = { low, low };
     
    184184        S ?++( S & t ) { S temp = t; t += (S){1}; return temp; }
    185185        ofstream & ?|?( ofstream & os, S v ) { return os | v.i | v.j; }
    186         void ?|?( ofstream & os, S v ) { (ofstream &)(os | v); nl( os ); }
     186        void ?|?( ofstream & os, S v ) { (ofstream &)(os | v); ends( os ); }
    187187
    188188        S s = (S){0}, a[size], v = { low, low };
  • tests/swap.cfa

    r1d760934 r65240bb  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Dec 23 23:00:49 2018
    13 // Update Count     : 77
     12// Last Modified On : Fri Jul 12 12:05:26 2019
     13// Update Count     : 79
    1414//
    1515
     
    8585        struct S { int i, j; } s1 = { 1, 2 }, s2 = { 2, 1 };
    8686        ofstream & ?|?( ofstream & os, S s ) { return os | s.i | s.j; }
    87         void ?|?( ofstream & os, S s ) { (ofstream &)(os | s.i | s.j); nl( os ); }
     87        void ?|?( ofstream & os, S s ) { (ofstream &)(os | s.i | s.j); ends( os ); }
    8888        sout | "struct S\t\t" | s1 | "," | s2 | "\t\tswap " | nonl;
    8989        swap( s1, s2 );
Note: See TracChangeset for help on using the changeset viewer.