Changeset 6acd020


Ignore:
Timestamp:
Jul 20, 2021, 9:06:24 PM (3 years ago)
Author:
m3zulfiq <m3zulfiq@…>
Branches:
ADT, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
d2260ad
Parents:
3d7d407 (diff), 86fc350 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:
1 added
24 edited

Legend:

Unmodified
Added
Removed
  • doc/theses/andrew_beach_MMath/code/cond-catch.cfa

    r3d7d407 r6acd020  
    1919                throw_exception();
    2020        } catch (empty_exception * exc ; should_catch) {
    21                 // ...
     21                asm volatile ("# catch block (conditional)");
    2222        }
    2323}
     
    3737                        cond_catch();
    3838                } catch (empty_exception * exc) {
    39                         // ...
     39                        asm volatile ("# catch block (unconditional)");
    4040                }
    4141        }
  • doc/theses/andrew_beach_MMath/code/cond-catch.cpp

    r3d7d407 r6acd020  
    2222                        throw;
    2323                }
     24                asm volatile ("# catch block (conditional)");
    2425        }
    2526}
     
    3940                        cond_catch();
    4041                } catch (EmptyException &) {
    41                         // ...
     42                        asm volatile ("# catch block (unconditional)");
    4243                }
    4344    }
  • doc/theses/andrew_beach_MMath/code/cond-fixup.cfa

    r3d7d407 r6acd020  
    1919                throw_exception();
    2020        } catchResume (empty_exception * exc ; should_catch) {
    21                 // ...
     21                asm volatile ("# fixup block (conditional)");
    2222        }
    2323}
     
    3737                        cond_catch();
    3838                } catchResume (empty_exception * exc) {
    39                         // ...
     39                        asm volatile ("# fixup block (unconditional)");
    4040                }
    4141        }
  • doc/theses/andrew_beach_MMath/code/cross-catch.cfa

    r3d7d407 r6acd020  
    77EHM_EXCEPTION(not_raised_exception)();
    88
     9EHM_VIRTUAL_TABLE(not_raised_exception, not_vt);
     10
    911int main(int argc, char * argv[]) {
    1012        unsigned int times = 1;
    11         unsigned int total_frames = 1;
     13        bool should_throw = false;
    1214        if (1 < argc) {
    1315                times = strtol(argv[1], 0p, 10);
    14         }
    15         if (2 < argc) {
    16                 total_frames = strtol(argv[2], 0p, 10);
    1716        }
    1817
     
    2019        for (unsigned int count = 0 ; count < times ; ++count) {
    2120                try {
    22                         // ...
     21                        asm volatile ("# try block" : "=rm" (should_throw));
     22                        if (should_throw) {
     23                                throw (not_raised_exception){&not_vt};
     24                        }
    2325                } catch (not_raised_exception *) {
    24                         // ...
     26                        asm volatile ("# catch block");
    2527                }
    2628        }
  • doc/theses/andrew_beach_MMath/code/cross-catch.cpp

    r3d7d407 r6acd020  
    1111int main(int argc, char * argv[]) {
    1212        unsigned int times = 1;
     13        bool should_throw = false;
    1314        if (1 < argc) {
    1415                times = strtol(argv[1], nullptr, 10);
     
    1819        for (unsigned int count = 0 ; count < times ; ++count) {
    1920                try {
    20                         // ...
     21                        asm volatile ("# try block" : "=rm" (should_throw));
     22                        if (should_throw) {
     23                                throw NotRaisedException();
     24                        }
    2125                } catch (NotRaisedException &) {
    22                         // ...
     26                        asm volatile ("# catch block");
    2327                }
    2428        }
  • doc/theses/andrew_beach_MMath/code/cross-finally.cfa

    r3d7d407 r6acd020  
    55#include <stdlib.hfa>
    66
     7EHM_EXCEPTION(not_raised_exception)();
     8
     9EHM_VIRTUAL_TABLE(not_raised_exception, not_vt);
     10
    711int main(int argc, char * argv[]) {
    812        unsigned int times = 1;
    9         unsigned int total_frames = 1;
     13        bool should_throw = false;
    1014        if (1 < argc) {
    1115                times = strtol(argv[1], 0p, 10);
    12         }
    13         if (2 < argc) {
    14                 total_frames = strtol(argv[2], 0p, 10);
    1516        }
    1617
    1718        Time start_time = timeHiRes();
    1819        for (unsigned int count = 0 ; count < times ; ++count) {
    19                  try {
    20                         // ...
     20                try {
     21                        asm volatile ("# try block" : "=rm" (should_throw));
     22                        if (should_throw) {
     23                                throw (not_raised_exception){&not_vt};
     24                        }
    2125                } finally {
    22                         // ...
     26                        asm volatile ("# finally block");
    2327                }
    2428        }
  • doc/theses/andrew_beach_MMath/code/cross-resume.cfa

    r3d7d407 r6acd020  
    2020        for (unsigned int count = 0 ; count < times ; ++count) {
    2121                try {
    22                         // ...
     22                        asm volatile ("");
    2323                } catchResume (not_raised_exception *) {
    24                         // ...
     24                        asm volatile ("");
    2525                }
    2626        }
  • doc/theses/andrew_beach_MMath/code/resume-detor.cfa

    r3d7d407 r6acd020  
    1212
    1313void ^?{}(WithDestructor & this) {
    14     // ...
     14        asm volatile ("# destructor body");
    1515}
    1616
    1717void unwind_destructor(unsigned int frames) {
    18     if (frames) {
     18        if (frames) {
    1919
    20         WithDestructor object;
    21         unwind_destructor(frames - 1);
    22     } else {
    23         throwResume (empty_exception){&empty_vt};
    24     }
     20                WithDestructor object;
     21                unwind_destructor(frames - 1);
     22        } else {
     23                throwResume (empty_exception){&empty_vt};
     24        }
    2525}
    2626
     
    3636
    3737        Time start_time = timeHiRes();
    38     for (int count = 0 ; count < times ; ++count) {
    39         try {
    40             unwind_destructor(total_frames);
    41         } catchResume (empty_exception *) {
    42             // ...
    43         }
    44     }
     38        for (int count = 0 ; count < times ; ++count) {
     39                try {
     40                        unwind_destructor(total_frames);
     41                } catchResume (empty_exception *) {
     42                        asm volatile ("# fixup block");
     43                }
     44        }
    4545        Time end_time = timeHiRes();
    4646        sout | "Run-Time (ns): " | (end_time - start_time)`ns;
  • doc/theses/andrew_beach_MMath/code/resume-empty.cfa

    r3d7d407 r6acd020  
    3232                        unwind_empty(total_frames);
    3333                } catchResume (empty_exception *) {
    34                         // ...
     34                        asm volatile ("# fixup block");
    3535                }
    3636        }
  • doc/theses/andrew_beach_MMath/code/resume-finally.cfa

    r3d7d407 r6acd020  
    1414                        unwind_finally(frames - 1);
    1515                } finally {
    16                         // ...
     16                        asm volatile ("# finally block");
    1717                }
    1818        } else {
     
    3636                        unwind_finally(total_frames);
    3737                } catchResume (empty_exception *) {
    38                         // ...
     38                        asm volatile ("# fixup block");
    3939                }
    4040        }
  • doc/theses/andrew_beach_MMath/code/resume-other.cfa

    r3d7d407 r6acd020  
    1616                        unwind_other(frames - 1);
    1717                } catchResume (not_raised_exception *) {
    18                         // ...
     18                        asm volatile ("# fixup block (stack)");
    1919                }
    2020        } else {
     
    3838                        unwind_other(total_frames);
    3939                } catchResume (empty_exception *) {
    40                         // ...
     40                        asm volatile ("# fixup block (base)");
    4141                }
    4242        }
  • doc/theses/andrew_beach_MMath/code/throw-detor.cfa

    r3d7d407 r6acd020  
    1212
    1313void ^?{}(WithDestructor & this) {
    14         // ...
     14        asm volatile ("# destructor body");
    1515}
    1616
     
    3939                        unwind_destructor(total_frames);
    4040                } catch (empty_exception *) {
    41                         // ...
     41                        asm volatile ("# catch block");
    4242                }
    4343        }
  • doc/theses/andrew_beach_MMath/code/throw-detor.cpp

    r3d7d407 r6acd020  
    1010
    1111struct WithDestructor {
    12         ~WithDestructor() {}
     12        ~WithDestructor() {
     13                asm volatile ("# destructor body");
     14        }
    1315};
    1416
     
    3739                        unwind_destructor(total_frames);
    3840                } catch (EmptyException &) {
    39                         // ...
     41                        asm volatile ("# catch block");
    4042                }
    4143        }
  • doc/theses/andrew_beach_MMath/code/throw-empty.cfa

    r3d7d407 r6acd020  
    3232                        unwind_empty(total_frames);
    3333                } catch (empty_exception *) {
    34                         // ...
     34                        asm volatile ("# catch block");
    3535                }
    3636        }
  • doc/theses/andrew_beach_MMath/code/throw-empty.cpp

    r3d7d407 r6acd020  
    3232                        unwind_empty(total_frames);
    3333                } catch (EmptyException &) {
    34                         // ...
     34                        asm volatile ("# catch block");
    3535                }
    3636        }
  • doc/theses/andrew_beach_MMath/code/throw-finally.cfa

    r3d7d407 r6acd020  
    1414                        unwind_finally(frames - 1);
    1515                } finally {
    16                         // ...
     16                        asm volatile ("# finally block");
    1717                }
    1818        } else {
     
    3636                        unwind_finally(total_frames);
    3737                } catch (empty_exception *) {
    38                         // ...
     38                        asm volatile ("# catch block");
    3939                }
    4040        }
  • doc/theses/andrew_beach_MMath/code/throw-other.cfa

    r3d7d407 r6acd020  
    1616                        unwind_other(frames - 1);
    1717                } catch (not_raised_exception *) {
    18                         // ...
     18                        asm volatile ("# catch block (stack)");
    1919                }
    2020        } else {
     
    3838                        unwind_other(total_frames);
    3939                } catch (empty_exception *) {
    40                         // ...
     40                        asm volatile ("# catch block (base)");
    4141                }
    4242        }
  • doc/theses/andrew_beach_MMath/code/throw-other.cpp

    r3d7d407 r6acd020  
    1616                        unwind_other(frames - 1);
    1717                } catch (NotRaisedException &) {
    18                         // ...
     18                        asm volatile ("# catch block (stack)");
    1919                }
    2020        } else {
     
    3838                        unwind_other(total_frames);
    3939                } catch (EmptyException &) {
    40                         // ...
     40                        asm volatile ("# catch block (base)");
    4141                }
    4242        }
  • libcfa/prelude/builtins.c

    r3d7d407 r6acd020  
    1010// Created On       : Fri Jul 21 16:21:03 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Apr 13 17:26:32 2021
    13 // Update Count     : 117
     12// Last Modified On : Tue Jul 20 17:31:40 2021
     13// Update Count     : 128
    1414//
    1515
     
    7878
    7979static inline {
    80         forall( DT & | { DT & ?+=?( DT &, one_t ); } )
    81         DT & ++?( DT & x ) { return x += 1; }
     80        forall( T | { T ?+=?( T &, one_t ); } )
     81        T ++?( T & x ) { return x += 1; }
    8282
    83         forall( DT & | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?+=?( DT &, one_t ); } )
    84         DT & ?++( DT & x ) { DT tmp = x; x += 1; return tmp; }
     83        forall( T | { T ?+=?( T &, one_t ); } )
     84        T ?++( T & x ) { T tmp = x; x += 1; return tmp; }
    8585
    86         forall( DT & | { DT & ?-=?( DT &, one_t ); } )
    87         DT & --?( DT & x ) { return x -= 1; }
     86        forall( T | { T ?-=?( T &, one_t ); } )
     87        T --?( T & x ) { return x -= 1; }
    8888
    89         forall( DT & | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?-=?( DT &, one_t ); } )
    90         DT & ?--( DT & x ) { DT tmp = x; x -= 1; return tmp; }
     89        forall( T | { T ?-=?( T &, one_t ); } )
     90        T ?--( T & x ) { T tmp = x; x -= 1; return tmp; }
    9191
    92         forall( DT & | { int ?!=?( const DT &, zero_t ); } )
    93         int !?( const DT & x ) { return !( x != 0 ); }
     92        forall( T | { int ?!=?( T, zero_t ); } )
     93        int !?( T & x ) { return !( x != 0 ); }
    9494} // distribution
    9595
  • libcfa/src/Makefile.am

    r3d7d407 r6acd020  
    1111## Created On       : Sun May 31 08:54:01 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Sat Apr 24 09:09:56 2021
    14 ## Update Count     : 254
     13## Last Modified On : Fri Jul 16 16:00:40 2021
     14## Update Count     : 255
    1515###############################################################################
    1616
     
    4545        exception.h \
    4646        gmp.hfa \
     47        math.trait.hfa \
    4748        math.hfa \
    4849        time_t.hfa \
  • libcfa/src/rational.cfa

    r3d7d407 r6acd020  
    1010// Created On       : Wed Apr  6 17:54:28 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb  8 17:56:36 2020
    13 // Update Count     : 187
     12// Last Modified On : Tue Jul 20 16:30:06 2021
     13// Update Count     : 193
    1414//
    1515
     
    1818#include "stdlib.hfa"
    1919
    20 forall( RationalImpl | arithmetic( RationalImpl ) ) {
     20forall( T | Arithmetic( T ) ) {
    2121        // helper routines
    2222
    2323        // Calculate greatest common denominator of two numbers, the first of which may be negative. Used to reduce
    2424        // rationals.  alternative: https://en.wikipedia.org/wiki/Binary_GCD_algorithm
    25         static RationalImpl gcd( RationalImpl a, RationalImpl b ) {
     25        static T gcd( T a, T b ) {
    2626                for ( ;; ) {                                                                    // Euclid's algorithm
    27                         RationalImpl r = a % b;
    28                   if ( r == (RationalImpl){0} ) break;
     27                        T r = a % b;
     28                  if ( r == (T){0} ) break;
    2929                        a = b;
    3030                        b = r;
     
    3333        } // gcd
    3434
    35         static RationalImpl simplify( RationalImpl & n, RationalImpl & d ) {
    36                 if ( d == (RationalImpl){0} ) {
     35        static T simplify( T & n, T & d ) {
     36                if ( d == (T){0} ) {
    3737                        abort | "Invalid rational number construction: denominator cannot be equal to 0.";
    3838                } // exit
    39                 if ( d < (RationalImpl){0} ) { d = -d; n = -n; } // move sign to numerator
     39                if ( d < (T){0} ) { d = -d; n = -n; } // move sign to numerator
    4040                return gcd( abs( n ), d );                                              // simplify
    4141        } // Rationalnumber::simplify
     
    4343        // constructors
    4444
    45         void ?{}( Rational(RationalImpl) & r ) {
    46                 r{ (RationalImpl){0}, (RationalImpl){1} };
    47         } // rational
    48 
    49         void ?{}( Rational(RationalImpl) & r, RationalImpl n ) {
    50                 r{ n, (RationalImpl){1} };
    51         } // rational
    52 
    53         void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ) {
    54                 RationalImpl t = simplify( n, d );                              // simplify
     45        void ?{}( Rational(T) & r, zero_t ) {
     46                r{ (T){0}, (T){1} };
     47        } // rational
     48
     49        void ?{}( Rational(T) & r, one_t ) {
     50                r{ (T){1}, (T){1} };
     51        } // rational
     52
     53        void ?{}( Rational(T) & r ) {
     54                r{ (T){0}, (T){1} };
     55        } // rational
     56
     57        void ?{}( Rational(T) & r, T n ) {
     58                r{ n, (T){1} };
     59        } // rational
     60
     61        void ?{}( Rational(T) & r, T n, T d ) {
     62                T t = simplify( n, d );                         // simplify
    5563                r.[numerator, denominator] = [n / t, d / t];
    5664        } // rational
    5765
    58         void ?{}( Rational(RationalImpl) & r, zero_t ) {
    59                 r{ (RationalImpl){0}, (RationalImpl){1} };
    60         } // rational
    61 
    62         void ?{}( Rational(RationalImpl) & r, one_t ) {
    63                 r{ (RationalImpl){1}, (RationalImpl){1} };
    64         } // rational
    65 
    6666        // getter for numerator/denominator
    6767
    68         RationalImpl numerator( Rational(RationalImpl) r ) {
     68        T numerator( Rational(T) r ) {
    6969                return r.numerator;
    7070        } // numerator
    7171
    72         RationalImpl denominator( Rational(RationalImpl) r ) {
     72        T denominator( Rational(T) r ) {
    7373                return r.denominator;
    7474        } // denominator
    7575
    76         [ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ) {
     76        [ T, T ] ?=?( & [ T, T ] dest, Rational(T) src ) {
    7777                return dest = src.[ numerator, denominator ];
    7878        } // ?=?
     
    8080        // setter for numerator/denominator
    8181
    82         RationalImpl numerator( Rational(RationalImpl) r, RationalImpl n ) {
    83                 RationalImpl prev = r.numerator;
    84                 RationalImpl t = gcd( abs( n ), r.denominator ); // simplify
     82        T numerator( Rational(T) r, T n ) {
     83                T prev = r.numerator;
     84                T t = gcd( abs( n ), r.denominator ); // simplify
    8585                r.[numerator, denominator] = [n / t, r.denominator / t];
    8686                return prev;
    8787        } // numerator
    8888
    89         RationalImpl denominator( Rational(RationalImpl) r, RationalImpl d ) {
    90                 RationalImpl prev = r.denominator;
    91                 RationalImpl t = simplify( r.numerator, d );    // simplify
     89        T denominator( Rational(T) r, T d ) {
     90                T prev = r.denominator;
     91                T t = simplify( r.numerator, d );       // simplify
    9292                r.[numerator, denominator] = [r.numerator / t, d / t];
    9393                return prev;
     
    9696        // comparison
    9797
    98         int ?==?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     98        int ?==?( Rational(T) l, Rational(T) r ) {
    9999                return l.numerator * r.denominator == l.denominator * r.numerator;
    100100        } // ?==?
    101101
    102         int ?!=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     102        int ?!=?( Rational(T) l, Rational(T) r ) {
    103103                return ! ( l == r );
    104104        } // ?!=?
    105105
    106         int ?<?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     106        int ?!=?( Rational(T) l, zero_t ) {
     107                return ! ( l == (Rational(T)){ 0 } );
     108        } // ?!=?
     109
     110        int ?<?( Rational(T) l, Rational(T) r ) {
    107111                return l.numerator * r.denominator < l.denominator * r.numerator;
    108112        } // ?<?
    109113
    110         int ?<=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     114        int ?<=?( Rational(T) l, Rational(T) r ) {
    111115                return l.numerator * r.denominator <= l.denominator * r.numerator;
    112116        } // ?<=?
    113117
    114         int ?>?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     118        int ?>?( Rational(T) l, Rational(T) r ) {
    115119                return ! ( l <= r );
    116120        } // ?>?
    117121
    118         int ?>=?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     122        int ?>=?( Rational(T) l, Rational(T) r ) {
    119123                return ! ( l < r );
    120124        } // ?>=?
     
    122126        // arithmetic
    123127
    124         Rational(RationalImpl) +?( Rational(RationalImpl) r ) {
    125                 return (Rational(RationalImpl)){ r.numerator, r.denominator };
     128        Rational(T) +?( Rational(T) r ) {
     129                return (Rational(T)){ r.numerator, r.denominator };
    126130        } // +?
    127131
    128         Rational(RationalImpl) -?( Rational(RationalImpl) r ) {
    129                 return (Rational(RationalImpl)){ -r.numerator, r.denominator };
     132        Rational(T) -?( Rational(T) r ) {
     133                return (Rational(T)){ -r.numerator, r.denominator };
    130134        } // -?
    131135
    132         Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     136        Rational(T) ?+?( Rational(T) l, Rational(T) r ) {
    133137                if ( l.denominator == r.denominator ) {                 // special case
    134                         return (Rational(RationalImpl)){ l.numerator + r.numerator, l.denominator };
     138                        return (Rational(T)){ l.numerator + r.numerator, l.denominator };
    135139                } else {
    136                         return (Rational(RationalImpl)){ l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator };
     140                        return (Rational(T)){ l.numerator * r.denominator + l.denominator * r.numerator, l.denominator * r.denominator };
    137141                } // if
    138142        } // ?+?
    139143
    140         Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
     144        Rational(T) ?+=?( Rational(T) & l, Rational(T) r ) {
     145                l = l + r;
     146                return l;
     147        } // ?+?
     148
     149        Rational(T) ?+=?( Rational(T) & l, one_t ) {
     150                l = l + (Rational(T)){ 1 };
     151                return l;
     152        } // ?+?
     153
     154        Rational(T) ?-?( Rational(T) l, Rational(T) r ) {
    141155                if ( l.denominator == r.denominator ) {                 // special case
    142                         return (Rational(RationalImpl)){ l.numerator - r.numerator, l.denominator };
     156                        return (Rational(T)){ l.numerator - r.numerator, l.denominator };
    143157                } else {
    144                         return (Rational(RationalImpl)){ l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator };
     158                        return (Rational(T)){ l.numerator * r.denominator - l.denominator * r.numerator, l.denominator * r.denominator };
    145159                } // if
    146160        } // ?-?
    147161
    148         Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    149                 return (Rational(RationalImpl)){ l.numerator * r.numerator, l.denominator * r.denominator };
     162        Rational(T) ?-=?( Rational(T) & l, Rational(T) r ) {
     163                l = l - r;
     164                return l;
     165        } // ?-?
     166
     167        Rational(T) ?-=?( Rational(T) & l, one_t ) {
     168                l = l - (Rational(T)){ 1 };
     169                return l;
     170        } // ?-?
     171
     172        Rational(T) ?*?( Rational(T) l, Rational(T) r ) {
     173                return (Rational(T)){ l.numerator * r.numerator, l.denominator * r.denominator };
    150174        } // ?*?
    151175
    152         Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r ) {
    153                 if ( r.numerator < (RationalImpl){0} ) {
     176        Rational(T) ?*=?( Rational(T) & l, Rational(T) r ) {
     177                return l = l * r;
     178        } // ?*?
     179
     180        Rational(T) ?/?( Rational(T) l, Rational(T) r ) {
     181                if ( r.numerator < (T){0} ) {
    154182                        r.[numerator, denominator] = [-r.numerator, -r.denominator];
    155183                } // if
    156                 return (Rational(RationalImpl)){ l.numerator * r.denominator, l.denominator * r.numerator };
     184                return (Rational(T)){ l.numerator * r.denominator, l.denominator * r.numerator };
    157185        } // ?/?
    158186
     187        Rational(T) ?/=?( Rational(T) & l, Rational(T) r ) {
     188                return l = l / r;
     189        } // ?/?
     190
    159191        // I/O
    160192
    161         forall( istype & | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } )
    162         istype & ?|?( istype & is, Rational(RationalImpl) & r ) {
     193        forall( istype & | istream( istype ) | { istype & ?|?( istype &, T & ); } )
     194        istype & ?|?( istype & is, Rational(T) & r ) {
    163195                is | r.numerator | r.denominator;
    164                 RationalImpl t = simplify( r.numerator, r.denominator );
     196                T t = simplify( r.numerator, r.denominator );
    165197                r.numerator /= t;
    166198                r.denominator /= t;
     
    168200        } // ?|?
    169201
    170         forall( ostype & | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } ) {
    171                 ostype & ?|?( ostype & os, Rational(RationalImpl) r ) {
     202        forall( ostype & | ostream( ostype ) | { ostype & ?|?( ostype &, T ); } ) {
     203                ostype & ?|?( ostype & os, Rational(T) r ) {
    172204                        return os | r.numerator | '/' | r.denominator;
    173205                } // ?|?
    174206
    175                 void ?|?( ostype & os, Rational(RationalImpl) r ) {
     207                void ?|?( ostype & os, Rational(T) r ) {
    176208                        (ostype &)(os | r); ends( os );
    177209                } // ?|?
     
    179211} // distribution
    180212
    181 forall( RationalImpl | arithmetic( RationalImpl ) | { RationalImpl ?\?( RationalImpl, unsigned long ); } )
    182 Rational(RationalImpl) ?\?( Rational(RationalImpl) x, long int y ) {
    183         if ( y < 0 ) {
    184                 return (Rational(RationalImpl)){ x.denominator \ -y, x.numerator \ -y };
    185         } else {
    186                 return (Rational(RationalImpl)){ x.numerator \ y, x.denominator \ y };
    187         } // if
    188 }
     213forall( T | Arithmetic( T ) | { T ?\?( T, unsigned long ); } ) {
     214        Rational(T) ?\?( Rational(T) x, long int y ) {
     215                if ( y < 0 ) {
     216                        return (Rational(T)){ x.denominator \ -y, x.numerator \ -y };
     217                } else {
     218                        return (Rational(T)){ x.numerator \ y, x.denominator \ y };
     219                } // if
     220        } // ?\?
     221
     222        Rational(T) ?\=?( Rational(T) & x, long int y ) {
     223                return x = x \ y;
     224        } // ?\?
     225} // distribution
    189226
    190227// conversion
    191228
    192 forall( RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); } )
    193 double widen( Rational(RationalImpl) r ) {
     229forall( T | Arithmetic( T ) | { double convert( T ); } )
     230double widen( Rational(T) r ) {
    194231        return convert( r.numerator ) / convert( r.denominator );
    195232} // widen
    196233
    197 forall( RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); RationalImpl convert( double ); } )
    198 Rational(RationalImpl) narrow( double f, RationalImpl md ) {
     234forall( T | Arithmetic( T ) | { double convert( T ); T convert( double ); } )
     235Rational(T) narrow( double f, T md ) {
    199236        // http://www.ics.uci.edu/~eppstein/numth/frap.c
    200         if ( md <= (RationalImpl){1} ) {                                        // maximum fractional digits too small?
    201                 return (Rational(RationalImpl)){ convert( f ), (RationalImpl){1}}; // truncate fraction
     237        if ( md <= (T){1} ) {                                   // maximum fractional digits too small?
     238                return (Rational(T)){ convert( f ), (T){1}}; // truncate fraction
    202239        } // if
    203240
    204241        // continued fraction coefficients
    205         RationalImpl m00 = {1}, m11 = { 1 }, m01 = { 0 }, m10 = { 0 };
    206         RationalImpl ai, t;
     242        T m00 = {1}, m11 = { 1 }, m01 = { 0 }, m10 = { 0 };
     243        T ai, t;
    207244
    208245        // find terms until denom gets too big
     
    221258          if ( f > (double)0x7FFFFFFF ) break;                          // representation failure
    222259        } // for
    223         return (Rational(RationalImpl)){ m00, m10 };
     260        return (Rational(T)){ m00, m10 };
    224261} // narrow
    225262
  • libcfa/src/rational.hfa

    r3d7d407 r6acd020  
    1212// Created On       : Wed Apr  6 17:56:25 2016
    1313// Last Modified By : Peter A. Buhr
    14 // Last Modified On : Tue Mar 26 23:16:10 2019
    15 // Update Count     : 109
     14// Last Modified On : Tue Jul 20 17:45:29 2021
     15// Update Count     : 118
    1616//
    1717
     
    1919
    2020#include "iostream.hfa"
    21 
    22 trait scalar( T ) {
    23 };
    24 
    25 trait arithmetic( T | scalar( T ) ) {
    26         int !?( T );
    27         int ?==?( T, T );
    28         int ?!=?( T, T );
    29         int ?<?( T, T );
    30         int ?<=?( T, T );
    31         int ?>?( T, T );
    32         int ?>=?( T, T );
    33         void ?{}( T &, zero_t );
    34         void ?{}( T &, one_t );
    35         T +?( T );
    36         T -?( T );
    37         T ?+?( T, T );
    38         T ?-?( T, T );
    39         T ?*?( T, T );
    40         T ?/?( T, T );
    41         T ?%?( T, T );
    42         T ?/=?( T &, T );
    43         T abs( T );
    44 };
     21#include "math.trait.hfa"                                                               // Arithmetic
    4522
    4623// implementation
    4724
    48 forall( RationalImpl | arithmetic( RationalImpl ) ) {
     25forall( T | Arithmetic( T ) ) {
    4926        struct Rational {
    50                 RationalImpl numerator, denominator;                    // invariant: denominator > 0
     27                T numerator, denominator;                                               // invariant: denominator > 0
    5128        }; // Rational
    5229
    5330        // constructors
    5431
    55         void ?{}( Rational(RationalImpl) & r );
    56         void ?{}( Rational(RationalImpl) & r, RationalImpl n );
    57         void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d );
    58         void ?{}( Rational(RationalImpl) & r, zero_t );
    59         void ?{}( Rational(RationalImpl) & r, one_t );
     32        void ?{}( Rational(T) & r );
     33        void ?{}( Rational(T) & r, zero_t );
     34        void ?{}( Rational(T) & r, one_t );
     35        void ?{}( Rational(T) & r, T n );
     36        void ?{}( Rational(T) & r, T n, T d );
    6037
    6138        // numerator/denominator getter
    6239
    63         RationalImpl numerator( Rational(RationalImpl) r );
    64         RationalImpl denominator( Rational(RationalImpl) r );
    65         [ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src );
     40        T numerator( Rational(T) r );
     41        T denominator( Rational(T) r );
     42        [ T, T ] ?=?( & [ T, T ] dest, Rational(T) src );
    6643
    6744        // numerator/denominator setter
    6845
    69         RationalImpl numerator( Rational(RationalImpl) r, RationalImpl n );
    70         RationalImpl denominator( Rational(RationalImpl) r, RationalImpl d );
     46        T numerator( Rational(T) r, T n );
     47        T denominator( Rational(T) r, T d );
    7148
    7249        // comparison
    7350
    74         int ?==?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    75         int ?!=?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    76         int ?<?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    77         int ?<=?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    78         int ?>?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    79         int ?>=?( Rational(RationalImpl) l, Rational(RationalImpl) r );
     51        int ?==?( Rational(T) l, Rational(T) r );
     52        int ?!=?( Rational(T) l, Rational(T) r );
     53        int ?!=?( Rational(T) l, zero_t );                                      // => !
     54        int ?<?( Rational(T) l, Rational(T) r );
     55        int ?<=?( Rational(T) l, Rational(T) r );
     56        int ?>?( Rational(T) l, Rational(T) r );
     57        int ?>=?( Rational(T) l, Rational(T) r );
    8058
    8159        // arithmetic
    8260
    83         Rational(RationalImpl) +?( Rational(RationalImpl) r );
    84         Rational(RationalImpl) -?( Rational(RationalImpl) r );
    85         Rational(RationalImpl) ?+?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    86         Rational(RationalImpl) ?-?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    87         Rational(RationalImpl) ?*?( Rational(RationalImpl) l, Rational(RationalImpl) r );
    88         Rational(RationalImpl) ?/?( Rational(RationalImpl) l, Rational(RationalImpl) r );
     61        Rational(T) +?( Rational(T) r );
     62        Rational(T) -?( Rational(T) r );
     63        Rational(T) ?+?( Rational(T) l, Rational(T) r );
     64        Rational(T) ?+=?( Rational(T) & l, Rational(T) r );
     65        Rational(T) ?+=?( Rational(T) & l, one_t );                     // => ++?, ?++
     66        Rational(T) ?-?( Rational(T) l, Rational(T) r );
     67        Rational(T) ?-=?( Rational(T) & l, Rational(T) r );
     68        Rational(T) ?-=?( Rational(T) & l, one_t );                     // => --?, ?--
     69        Rational(T) ?*?( Rational(T) l, Rational(T) r );
     70        Rational(T) ?*=?( Rational(T) & l, Rational(T) r );
     71        Rational(T) ?/?( Rational(T) l, Rational(T) r );
     72        Rational(T) ?/=?( Rational(T) & l, Rational(T) r );
    8973
    9074        // I/O
    91         forall( istype & | istream( istype ) | { istype & ?|?( istype &, RationalImpl & ); } )
    92         istype & ?|?( istype &, Rational(RationalImpl) & );
     75        forall( istype & | istream( istype ) | { istype & ?|?( istype &, T & ); } )
     76        istype & ?|?( istype &, Rational(T) & );
    9377
    94         forall( ostype & | ostream( ostype ) | { ostype & ?|?( ostype &, RationalImpl ); } ) {
    95                 ostype & ?|?( ostype &, Rational(RationalImpl) );
    96                 void ?|?( ostype &, Rational(RationalImpl) );
     78        forall( ostype & | ostream( ostype ) | { ostype & ?|?( ostype &, T ); } ) {
     79                ostype & ?|?( ostype &, Rational(T) );
     80                void ?|?( ostype &, Rational(T) );
    9781        } // distribution
    9882} // distribution
    9983
    100 forall( RationalImpl | arithmetic( RationalImpl ) |{RationalImpl ?\?( RationalImpl, unsigned long );} )
    101 Rational(RationalImpl) ?\?( Rational(RationalImpl) x, long int y );
     84forall( T | Arithmetic( T ) | { T ?\?( T, unsigned long ); } ) {
     85        Rational(T) ?\?( Rational(T) x, long int y );
     86        Rational(T) ?\=?( Rational(T) & x, long int y );
     87} // distribution
    10288
    10389// conversion
    104 forall( RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl ); } )
    105 double widen( Rational(RationalImpl) r );
    106 forall( RationalImpl | arithmetic( RationalImpl ) | { double convert( RationalImpl );  RationalImpl convert( double );} )
    107 Rational(RationalImpl) narrow( double f, RationalImpl md );
     90forall( T | Arithmetic( T ) | { double convert( T ); } )
     91double widen( Rational(T) r );
     92forall( T | Arithmetic( T ) | { double convert( T );  T convert( double );} )
     93Rational(T) narrow( double f, T md );
    10894
    10995// Local Variables: //
  • tests/.expect/rational.txt

    r3d7d407 r6acd020  
    11constructor
    2 3/1 4/1 0/1 0/1 1/1
    3 1/2 5/7
    4 2/3 -3/2
    5 -2/3 3/2
    6 logical
    7 -2/1 -3/2
    8 1
    9 1
    10 1
    11 0
    12 0
     2a : 3/1 b : 4/1 c : 0/1 d : 0/1 e : 1/1
     3a : 1/2 b : 5/7
     4a : 2/3 b : -3/2
     5a : -2/3 b : 3/2
     6
     7comparison
     8a : -2/1 b : -3/2
     9a == 0 : 0
     10a == 1 : 0
     11a != 0 : 1
     12! a : 0
     13a != b : 1
     14a <  b : 1
     15a <=  b : 1
     16a >  b : 0
     17a >=  b : 0
     18
    1319arithmetic
    14 -2/1 -3/2
    15 -7/2
    16 -1/2
    17 3/1
    18 4/3
     20a : -2/1 b : -3/2
     21a + b : -7/2
     22a += b : -7/2
     23++a : -5/2
     24a++ : -5/2
     25a : -3/2
     26a - b : 0/1
     27a -= b : 0/1
     28--a : -1/1
     29a-- : -1/1
     30a : -2/1
     31a * b : 3/1
     32a / b : 4/3
     33a \ 2 : 4/1 b \ 2 : 9/4
     34a \ -2 : 1/4 b \ -2 : 4/9
     35
    1936conversion
    20370.75
     
    24411/7
    2542355/113
    26 decompose
     43
    2744more tests
    2845-3/2
  • tests/rational.cfa

    r3d7d407 r6acd020  
    1010// Created On       : Mon Mar 28 08:43:12 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb  8 18:46:23 2020
    13 // Update Count     : 86
     12// Last Modified On : Tue Jul 20 18:13:40 2021
     13// Update Count     : 107
    1414//
    1515
     
    2626        sout | "constructor";
    2727        RatInt a = { 3 }, b = { 4 }, c, d = 0, e = 1;
    28         sout | a | b | c | d | e;
     28        sout | "a : " | a | "b : " | b | "c : " | c | "d : " | d | "e : " | e;
    2929
    3030        a = (RatInt){ 4, 8 };
    3131        b = (RatInt){ 5, 7 };
    32         sout | a | b;
     32        sout | "a : " | a | "b : " | b;
    3333        a = (RatInt){ -2, -3 };
    3434        b = (RatInt){ 3, -2 };
    35         sout | a | b;
     35        sout | "a : " | a | "b : " | b;
    3636        a = (RatInt){ -2, 3 };
    3737        b = (RatInt){ 3, 2 };
    38         sout | a | b;
     38        sout | "a : " | a | "b : " | b;
     39        sout | nl;
    3940
    40         sout | "logical";
     41        sout | "comparison";
    4142        a = (RatInt){ -2 };
    4243        b = (RatInt){ -3, 2 };
    43         sout | a | b;
    44 //      sout | a == 1; // FIX ME
    45         sout | a != b;
    46         sout | a <  b;
    47         sout | a <= b;
    48         sout | a >  b;
    49         sout | a >= b;
     44        sout | "a : " | a | "b : " | b;
     45        sout | "a == 0 : " | a == (Rational(int)){0}; // FIX ME
     46        sout | "a == 1 : " | a == (Rational(int)){1}; // FIX ME
     47        sout | "a != 0 : " | a != 0;
     48        sout | "! a : " | ! a;
     49        sout | "a != b : " | a != b;
     50        sout | "a <  b : " | a <  b;
     51        sout | "a <=  b : " | a <= b;
     52        sout | "a >  b : " | a >  b;
     53        sout | "a >=  b : " | a >= b;
     54        sout | nl;
    5055
    5156        sout | "arithmetic";
    52         sout | a | b;
    53         sout | a + b;
    54         sout | a - b;
    55         sout | a * b;
    56         sout | a / b;
    57 //      sout | a \ 2 | b \ 2; // FIX ME
    58 //      sout | a \ -2 | b \ -2;
     57        sout | "a : " | a | "b : " | b;
     58        sout | "a + b : " | a + b;
     59        sout | "a += b : " | (a += b);
     60        sout | "++a : " | ++a;
     61        sout | "a++ : " | a++;
     62        sout | "a : " | a;
     63        sout | "a - b : " | a - b;
     64        sout | "a -= b : " | (a -= b);
     65        sout | "--a : " | --a;
     66        sout | "a-- : " | a--;
     67        sout | "a : " | a;
     68        sout | "a * b : " | a * b;
     69        sout | "a / b : " | a / b;
     70        sout | "a \\ 2 : " | a \ 2u | "b \\ 2 : " | b \ 2u;
     71        sout | "a \\ -2 : " | a \ -2 | "b \\ -2 : " | b \ -2;
     72        sout | nl;
    5973
    6074        sout | "conversion";
     
    6882        sout | narrow( 0.14285714285714, 16 );
    6983        sout | narrow( 3.14159265358979, 256 );
     84        sout | nl;
    7085
    71         sout | "decompose";
    72         int n, d;
    73 //      [n, d] = a;
    74 //      sout | a | n | d;
     86        // sout | "decompose";
     87        // int n, d;
     88        // [n, d] = a;
     89        // sout | a | n | d;
    7590
    7691        sout | "more tests";
Note: See TracChangeset for help on using the changeset viewer.