Changeset fe97a7d8 for src/prelude/builtins.c

Timestamp:

Jul 22, 2017, 11:05:35 AM (7 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

637ff81, 72457b6

Parents:

6b0b624

git-author:

Peter A. Buhr <pabuhr@…> (07/22/17 10:59:19)

git-committer:

Peter A. Buhr <pabuhr@…> (07/22/17 11:05:35)

Message:

updates to exponential operator

File:

• src/prelude/builtins.c (modified) (3 diffs)

src/prelude/builtins.c

@@ -10 +10 @@
 // Created On       : Fri Jul 21 16:21:03 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 17:01:54 2017
-// Update Count     : 11
+// Last Modified On : Sat Jul 22 10:34:20 2017
+// Update Count     : 13
 // 
 
@@ -38 +38 @@
 static inline long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); }
 
-static inline long int ?\?( long int pe, unsigned long y ) { // disallow negative exponent
+static inline long int ?\?( long int ep, unsigned long int y ) { // disallow negative exponent
         if ( y == 0 ) return 1;                                                         // base case
-    if ( pe == 2 ) return pe << (y - 1);                                // special case, positive shifting only
-    typeof( pe ) po = 1;                                                                // accumulate odd product
+    if ( ep == 2 ) return ep << (y - 1);                                // special case, positive shifting only
+    typeof( ep ) op = 1;                                                                // accumulate odd product
     for ( ; y > 1; y >>= 1 ) {                                                  // squaring exponentiation, O(log2 y)
-                if ( (y & 1) == 1 ) po *= pe;                                   // odd ?
-                pe *= pe;
-        } // while
-    return pe * po;
+                if ( (y & 1) == 1 ) op *= ep;                                   // odd ?
+                ep *= ep;
+        } // for
+    return ep * op;
 } // ?\?
 
-// FIX ME, cannot resolve the "T po = 1".
+// FIX ME, cannot resolve the "T op = 1".
 
 // static inline forall( otype T | { void ?{}( T * this, one_t ); T ?*?( T, T ); } )
-// T ?\?( T pe, unsigned long y ) {
+// T ?\?( T ep, unsigned long int y ) {
 //     if ( y == 0 ) return 1;
-//     T po = 1;
+//     T op = 1;
 //     for ( ; y > 1; y >>= 1 ) {                                                       // squaring exponentiation, O(log2 y)
-//              if ( (y & 1) == 1 ) po = po * pe;                               // odd ?
-//              pe = pe * pe;
+//              if ( (y & 1) == 1 ) op = op * ep;                               // odd ?
+//              ep = ep * ep;
 //     } // for
-//     return pe * po;
+//     return ep * op;
 // } // ?\?
 
 // unsigned computation may be faster and larger
-static inline unsigned long int ?\?( unsigned long int pe, unsigned long y ) { // disallow negative exponent
+static inline unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { // disallow negative exponent
         if ( y == 0 ) return 1;                                                         // base case
-    if ( pe == 2 ) return pe << (y - 1);                                // special case, positive shifting only
-    typeof( pe ) po = 1;                                                                // accumulate odd product
+    if ( ep == 2 ) return ep << (y - 1);                                // special case, positive shifting only
+    typeof( ep ) op = 1;                                                                // accumulate odd product
     for ( ; y > 1; y >>= 1 ) {                                                  // squaring exponentiation, O(log2 y)
-                if ( (y & 1) == 1 ) po *= pe;                                   // odd ?
-                pe *= pe;
-        } // while
-    return pe * po;
+                if ( (y & 1) == 1 ) op *= ep;                                   // odd ?
+                ep *= ep;
+        } // for
+    return ep * op;
 } // ?\?
 
-static inline double ?\?( long int x, signed long y ) { // allow negative exponent
+static inline double ?\?( long int x, signed long int y ) {     // allow negative exponent
     if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
     else return 1.0 / x \ (unsigned int)(-y);
@@ -80 +80 @@
 
 static inline forall( otype T | { void ?{}( T * this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } )
-double ?\?( T x, signed long y ) {
+double ?\?( T x, signed long int y ) {
     if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
-    else return 1.0 / x \ (unsigned int)(-y);
+    else return 1.0 / x \ (unsigned long int)(-y);
 } // ?\?
 
-static inline long int ?\=?( long int * x, unsigned long y ) { *x = *x \ y; return *x; }
-static inline long int ?\=?( unsigned long int * x, unsigned long y ) { *x = *x \ y; return *x; }
-static inline int ?\=?( int * x, unsigned long y ) { *x = *x \ y; return *x; }
-static inline int ?\=?( unsigned int * x, unsigned long y ) { *x = *x \ y; return *x; }
+static inline long int ?\=?( long int * x, unsigned long int y ) { *x = *x \ y; return *x; }
+static inline unsigned long int ?\=?( unsigned long int * x, unsigned long int y ) { *x = *x \ y; return *x; }
+static inline int ?\=?( int * x, unsigned long int y ) { *x = *x \ y; return *x; }
+static inline unsigned int ?\=?( unsigned int * x, unsigned long int y ) { *x = *x \ y; return *x; }
 
 // Local Variables: //