Changeset 26b713 in git for gfanlib/gfanlib_z.h

Timestamp:

Feb 13, 2013, 4:23:42 PM (11 years ago)

Author:

Yue Ren <ren@…>

Branches:

(u'spielwiese', '17f1d200f27c5bd38f5dfc6e8a0879242279d1d8')

Children:

81384bd682dd5f3d82dcdbb5f9b03b8e16f90d39

Parents:

7b8818e8f761639646d742a3b11bca3b5a9408da

git-author:

Yue Ren <ren@mathematik.uni-kl.de>2013-02-13 16:23:42+01:00

git-committer:

Yue Ren <ren@mathematik.uni-kl.de>2013-03-14 15:32:21+01:00

Message:

chg: updated gfanlib package to newest version in master

File:

• gfanlib/gfanlib_z.h (modified) (2 diffs)

gfanlib/gfanlib_z.h

@@ -11 +11 @@
 #include <string.h>
 #include <ostream>
+
+#define OLD 1
+#if OLD
 #include "gmp.h"
 
@@ -190 +193 @@
 }
 
-
+#else
+namespace gfan{
+  typedef signed long int word;//processor type for integers
+  typedef int64_t LimbWord;//memory word. Assumed to be at least as big as word
+  typedef uint64_t uLimbWord;//memory word. Assumed to be at least as big as word
+  const int limbSizeInBytes=8;
+#include <stdint.h>
+  struct spec64malloc{
+    int64_t data;
+    bool hasLimbs()
+    {
+      return data&1;
+    }
+    word fitsMask()
+    {
+      return 0xc000000000000000;
+    }
+    void assign(word value)//assuming data fits
+    {
+      data=value<<1;
+    }
+    void alloc(int nlimbs)//one limb is added since that will tell the number of remaining limbs
+    {
+      int64_t temp=(int64_t)malloc((nlimbs+1)*limbSizeInBytes);
+      assert(temp);
+      data=temp+1;
+    }
+    LimbWord *limbs()//assuming that limbs exist
+    {
+      return (LimbWord*)(data-1);
+    }
+    word nlimbs()//assuming limbs exist
+    {
+      return (word)*limbs();
+    }
+    void copy(spec64malloc b)
+    {
+      if(hasLimbs())
+        {
+          word n2=b.nlimbs()+1;
+          int64_t temp=(int64_t)malloc((n2)*limbSizeInBytes);
+          assert(temp);
+
+          data=temp+1;
+          memcpy((LimbWord*)temp,limbs(),n2*limbSizeInBytes);
+        }
+      else
+        {
+          data=b.data;
+        }
+    }
+    void doFree()//assuming that limbs exist
+    {
+      free((void*)(data-1));
+    }
+    word valueToWord()//assume no limbs and that word is big enough to contain int64_t
+    {
+      return data>>1;
+    }
+  };
+  template <struct spec> struct IntegerTemplate : public spec
+  {
+  private:
+    bool fits(word v)
+    {
+      return !((value_&fitsMask())^((value_<<1)&fitsMask));
+    }
+  public:
+    static bool isField()
+    {
+      return false;
+    }
+    IntegerTemplate()
+    {
+      spec.data=0;
+    }
+    void assignWordNoFree()
+    {
+      if(fits(value_))
+        {
+          assign(value);
+        }
+      else
+        {
+          alloc(1);
+          limbs()[0]=1;
+          limbs()[1]=value_;
+        }
+    }
+    IntegerTemplate(word value_)
+    {
+      assignWordNoFree(value_);
+    }
+    IntegerTemplate(IntegerTemplate const & value_)
+    {
+      if(value_.hasLimbs())
+        {
+          copy(value_);
+        }
+      else
+        data=value.data;
+    }
+/*    Integer(mpz_t value_)
+    {
+      mpz_init_set(value,value_);
+    }*/
+    ~IntegerTemplate()
+    {
+      if(hasLimbs())doFree();
+    }
+    IntegerTemplate& operator=(const IntegerTemplate& a)
+      {
+        if(this!=&a)
+          {
+            if(hasLimps())doFree();
+            copy(a);
+          }
+        return *this;
+      }
+    bool isZero()const{
+      return data==0;
+    }
+    friend std::ostream &operator<<(std::ostream &f, IntegerTemplate const &a)
+    {
+      if(hasLimps())
+        {
+          LimpWord *p=limbs();
+          int l=*p++;
+          for(int i=0;i<l;i++)
+            f<<":"<<p[i];
+        }
+      else
+        {
+          f<<valueToWord();
+        }
+      return f;
+    }
+    LimbWord signExtension(LimbWord a)
+    {
+      return 0-(a<0);
+    }
+    void addWordToLimbs(word v)
+    {
+      int n=nlimbs();
+      LimbWord V=v;
+      LimbWord *p=limbs()+1;
+      LimbWord s=signExtension(V);
+      for(int i=0;i<n;i++)
+        {
+          LimbWord r=V+*p;
+          bool carry=(uLimbWord)r<(uLimbWord)V;
+          V=carry+s;
+        }
+
+    }
+
+
+    IntegerTemplate& operator+=(const IntegerTemplate& a)
+      {
+        if(hasLimbs()||a.hasLimbs())
+          {
+            if(!hasLimbs())
+              {
+
+              }
+            else
+              {
+              }
+
+          }
+        else
+          {
+            word C=valueToWord();
+            word A=a.valueToWord();
+            word D=A+C;
+            assignWordNoFree(D);
+          }
+        return *this;
+      }
+
+  };
+
+  typedef IntegerTemplate<spec64malloc> Integer;
+};
+#endif
 
 #endif /* LIB_Z_H_ */