diff --git a/.gitignore b/.gitignore
index f72c334661d3c6048242d6ed61d729afcda46bbf..88cc5a7ce39dbfbae8780c461405fc957b8360d7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,6 +12,15 @@
/libwmp.a
/autom4te.cache/
+
/lib/*.o
/lib/.deps/
/lib/.dirstamp
+/lib/extracted
+
+/lib/alias.c
+/lib/c.c
+/lib/fxp.c
+/lib/uint32gmp.c
+/lib/uint64gmp.c
+/lib/z.c
diff --git a/Makefile.am b/Makefile.am
index 8bbcdfbf3ffdc5767bb565be99e7f54c9c8f4c8a..77d72107b41ae7380c60aee69d9ddbe440d7e4be 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -5,14 +5,12 @@ EXTRA_DIST = COPYING.md COPYING.GPLv3.md NEWS.md README.md
lib_LIBRARIES = libwmp.a
libwmp_a_SOURCES = \
- lib/int.h lib/int32.h lib/uint32gmp.h lib/int64.h lib/uint64.h lib/uint64gmp.h lib/fxp.h \
- lib/euclideandivision.h lib/computerdivision.h lib/bool.h \
- lib/array.h lib/map.h lib/c.h lib/power.h lib/types.h lib/realinfix.h lib/minmax.h \
- lib/explog.h lib/square.h \
+ lib/uint32gmp.h lib/uint64gmp.h lib/fxp.h lib/c.h \
lib/util.c lib/util.h lib/utilold.c lib/utilold.h \
lib/logical.c lib/logical.h \
lib/logicalutil.c lib/logicalutil.h \
lib/logicalold.c lib/logicalold.h \
+ lib/baseinfo.c lib/baseinfo.h \
lib/compare.c lib/compare.h \
lib/add.c lib/add.h lib/sub.c lib/sub.h \
lib/add_1.c lib/add_1.h lib/sub_1.c lib/sub_1.h \
@@ -21,10 +19,17 @@ libwmp_a_SOURCES = \
lib/div.c lib/div.h \
lib/powm.c lib/powm.h lib/binverttab.h \
lib/sqrt.c lib/sqrt.h lib/sqrt1.c lib/sqrt1.h lib/sqrtinit.h \
- lib/alias.h lib/abs.h \
- lib/z.c lib/z.h lib/zutil.c lib/zutil.h lib/set.c lib/set.h lib/zadd.c lib/zadd.h \
- lib/zcmp.c lib/zcmp.h lib/zsub.c lib/zsub.h lib/zmul.c lib/zmul.h \
- lib/zmul2exp.c lib/zmul2exp.h lib/zdiv2exp.c lib/zdiv2exp.h
-
+ lib/get_str.c lib/get_str.h \
+ lib/set_str.c lib/set_str.h \
+ lib/alias.h \
+ lib/z.h lib/zutil.c lib/zutil.h lib/set.c lib/set.h lib/zadd.c lib/zadd.h \
+ lib/zabs.c lib/zabs.h \
+ lib/zcmp.c lib/zcmp.h \
+ lib/zcmpabs.c lib/zcmpabs.h \
+ lib/zsub.c lib/zsub.h lib/zmul.c lib/zmul.h \
+ lib/zmul2exp.c lib/zmul2exp.h lib/zdiv2exp.c lib/zdiv2exp.h \
+ lib/zdiv.c lib/zdiv.h \
+ lib/zget_str.c lib/zget_str.h \
+ lib/zset_str.c lib/zset_str.h
include_HEADERS = wmp.h wmp-gmp.h
diff --git a/lib/abs.h b/lib/abs.h
deleted file mode 100644
index b671db59dfd94fa48fcb77ca99ea94f95dbb3b92..0000000000000000000000000000000000000000
--- a/lib/abs.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef ABS_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-
-#define ABS_H_INCLUDED
-#endif // ABS_H_INCLUDED
diff --git a/lib/add.c b/lib/add.c
index 666ca4e2ebb0e8eae0a5bacbace5989889bdfee7..ee4fce80dabf6279ed900be7a607f9bcfd14c817 100644
--- a/lib/add.c
+++ b/lib/add.c
@@ -1,25 +1,5 @@
-#include <stdlib.h>
+#include "add.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "c.h"
-
-#include "int.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "types.h"
-
-#include "array.h"
-
-#include "map.h"
-
-#include "power.h"
-
-#include "alias.h"
uint64_t wmpn_add_n(uint64_t * r, uint64_t * x, uint64_t * y, int32_t sz) {
uint64_t lx, ly, c;
@@ -150,4 +130,3 @@ uint64_t add_ry(uint64_t * x, int32_t sx, uint64_t * y, int32_t sy) {
uint64_t add_n_rxy(uint64_t * x, int32_t sx) {
return wmpn_add_n(x, x, x, sx);
}
-
diff --git a/lib/add.h b/lib/add.h
index 5dd5a7f228cce39a6ebd1e8299e5339500081d1a..55e521a3e7285a7baf4d744b8ed845c338da3d27 100644
--- a/lib/add.h
+++ b/lib/add.h
@@ -1,10 +1,10 @@
#ifndef ADD_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "uint64gmp.h"
+#include "alias.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
uint64_t wmpn_add_n(uint64_t * r, uint64_t * x, uint64_t * y, int32_t sz);
uint64_t wmpn_add(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
diff --git a/lib/add_1.c b/lib/add_1.c
index 67def4b228e6bac49696da7a2d6f9175ceba91e4..a3631a92469f620afa3b2938ef3a1c993e028d4b 100644
--- a/lib/add_1.c
+++ b/lib/add_1.c
@@ -1,25 +1,5 @@
-#include <stdlib.h>
+#include "add_1.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "power.h"
-
-#include "c.h"
-
-#include "array.h"
-
-#include "map.h"
-
-#include "types.h"
-
-#include "euclideandivision.h"
uint64_t wmpn_add_1(uint64_t * r, uint64_t * x, int32_t sz, uint64_t y) {
uint64_t lx;
@@ -119,4 +99,3 @@ uint64_t wmpn_add_1_in_place(uint64_t * x, int32_t sz, uint64_t y) {
}
return c;
}
-
diff --git a/lib/add_1.h b/lib/add_1.h
index d0422eda90b033fd15f4a6d1455ca61305b12468..252446b185db275ef7f1e83cee939ece3320bd08 100644
--- a/lib/add_1.h
+++ b/lib/add_1.h
@@ -1,10 +1,9 @@
#ifndef ADD_1_H_INCLUDED
-#include <stdlib.h>
+#include "uint64gmp.h"
+#include "c.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
uint64_t wmpn_add_1(uint64_t * r, uint64_t * x, int32_t sz, uint64_t y);
void wmpn_incr(uint64_t * x, uint64_t y);
diff --git a/lib/addold.c b/lib/addold.c
index d93a13b6041ac8237e4a197da3cc41972ddc256d..d5028eb4da4c35c1938c93bbff4da1b7f9a6ba40 100644
--- a/lib/addold.c
+++ b/lib/addold.c
@@ -1,25 +1,5 @@
-#include <stdlib.h>
+#include "addold.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "c.h"
-
-#include "int.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "types.h"
-
-#include "array.h"
-
-#include "map.h"
-
-#include "power.h"
-
-#include "alias.h"
uint64_t wmpn_add_n1(uint64_t * r, uint64_t * x, uint64_t * y, int32_t sz) {
uint64_t lx, ly, c;
@@ -116,4 +96,3 @@ uint64_t wmpn_add_in_place(uint64_t * x, int32_t sx, uint64_t * y, int32_t sy) {
}
return c;
}
-
diff --git a/lib/addold.h b/lib/addold.h
index 0cd13e17e12940aec4318d46f2c17ae3ada66168..ae59a72bf822f1df3f600ad87b56d819e9c7fcb6 100644
--- a/lib/addold.h
+++ b/lib/addold.h
@@ -1,10 +1,10 @@
#ifndef ADDOLD_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "uint64gmp.h"
+#include "alias.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
uint64_t wmpn_add_n1(uint64_t * r, uint64_t * x, uint64_t * y, int32_t sz);
uint64_t wmpn_add1(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
diff --git a/lib/alias.h b/lib/alias.h
index 2df797b964460bc54eba5188d80215e42f63f52c..351cea89a562705132dfb841dc3e1326207ad726 100644
--- a/lib/alias.h
+++ b/lib/alias.h
@@ -1,55 +1,53 @@
#ifndef ALIAS_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "uint64gmp.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-
-struct __open_sep_result
-{ uint64_t *__field_0;
-uint64_t *__field_1;
-uint64_t *__field_2;
+
+struct __open_sep_result {
+ uint64_t *__field_0;
+ uint64_t *__field_1;
+ uint64_t *__field_2;
};
-struct __open_rx_result
-{ uint64_t *__field_0;
-uint64_t *__field_1;
-uint64_t *__field_2;
+struct __open_rx_result {
+ uint64_t *__field_0;
+ uint64_t *__field_1;
+ uint64_t *__field_2;
};
-struct __open_shift_sep_result
-{ uint64_t *__field_0;
-uint64_t *__field_1;
+struct __open_shift_sep_result {
+ uint64_t *__field_0;
+ uint64_t *__field_1;
};
static inline struct __open_sep_result
-open_sep (uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y, int32_t sy)
+open_sep (uint64_t *r, uint64_t *x, int32_t sx, uint64_t *y, int32_t sy)
{
-struct __open_sep_result result;
-result.__field_0 = r;
-result.__field_1 = x;
-result.__field_2 = y;
-return result;
+ struct __open_sep_result result;
+ result.__field_0 = r;
+ result.__field_1 = x;
+ result.__field_2 = y;
+ return result;
}
static inline struct __open_rx_result
-open_rx (uint64_t * x, int32_t sx, uint64_t * y, int32_t sy)
+open_rx (uint64_t *x, int32_t sx, uint64_t *y, int32_t sy)
{
-struct __open_rx_result result;
-result.__field_0 = x;
-result.__field_1 = x;
-result.__field_2 = y;
-return result;
+ struct __open_rx_result result;
+ result.__field_0 = x;
+ result.__field_1 = x;
+ result.__field_2 = y;
+ return result;
}
static inline struct __open_shift_sep_result
-open_shift_sep (uint64_t * r, uint64_t * x, int32_t sz)
+open_shift_sep (uint64_t *r, uint64_t *x, int32_t sz)
{
-struct __open_shift_sep_result result;
-result.__field_0 = r;
-result.__field_1 = x;
-return result;
+ struct __open_shift_sep_result result;
+ result.__field_0 = r;
+ result.__field_1 = x;
+ return result;
}
#define ALIAS_H_INCLUDED
diff --git a/lib/array.h b/lib/array.h
deleted file mode 100644
index f639f99640869298e7e4fe1cb4ca055710e8bae4..0000000000000000000000000000000000000000
--- a/lib/array.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef ARRAY_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-
-
-
-
-
-
-#define ARRAY_H_INCLUDED
-#endif // ARRAY_H_INCLUDED
diff --git a/lib/baseinfo.c b/lib/baseinfo.c
new file mode 100644
index 0000000000000000000000000000000000000000..03708e52100c53917673ab928bad1cf79b8104e0
--- /dev/null
+++ b/lib/baseinfo.c
@@ -0,0 +1,63 @@
+#include "baseinfo.h"
+#include <stdint.h>
+
+uint32_t wmpn_base_power_of_two_p(uint64_t b) {
+ if (b == UINT64_C(2)) {
+ return 1U;
+ } else {
+ if (b == UINT64_C(4)) {
+ return 2U;
+ } else {
+ if (b == UINT64_C(8)) {
+ return 3U;
+ } else {
+ if (b == UINT64_C(16)) {
+ return 4U;
+ } else {
+ if (b == UINT64_C(32)) {
+ return 5U;
+ } else {
+ if (b == UINT64_C(64)) {
+ return 6U;
+ } else {
+ if (b == UINT64_C(128)) {
+ return 7U;
+ } else {
+ if (b == UINT64_C(256)) {
+ return 8U;
+ } else {
+ return 0U;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+}
+struct wmpn_base_info;
+
+
+struct wmpn_base_info wmpn_get_base_info(uint64_t b) {
+ uint64_t m;
+ uint64_t p;
+ uint32_t exp;
+ struct wmpn_base_info wmpn_base_info;
+ m = UINT64_C(0xFFFFFFFFFFFFFFFF) / b;
+ p = b;
+ exp = 1U;
+ while (p <= m) {
+ p = p * b;
+ exp = exp + 1U;
+ }
+ wmpn_base_info.exp = exp;
+ wmpn_base_info.bb = p;
+ return wmpn_base_info;
+}
+
+uint64_t wmpn_limb_size_in_base_2(uint64_t u) {
+ uint64_t shift;
+ shift = (uint64_t)__builtin_clzll(u);
+ return UINT64_C(64) - shift;
+}
diff --git a/lib/baseinfo.h b/lib/baseinfo.h
new file mode 100644
index 0000000000000000000000000000000000000000..ee52f84a7169b5327776bc22d40dbd38a88a7fa2
--- /dev/null
+++ b/lib/baseinfo.h
@@ -0,0 +1,18 @@
+#ifndef BASEINFO_H_INCLUDED
+
+#include "logical.h"
+#include <stdint.h>
+
+uint32_t wmpn_base_power_of_two_p(uint64_t b);
+
+struct wmpn_base_info {
+ uint32_t exp;
+ uint64_t bb;
+};
+
+struct wmpn_base_info wmpn_get_base_info(uint64_t b);
+
+uint64_t wmpn_limb_size_in_base_2(uint64_t u);
+
+#define BASEINFO_H_INCLUDED
+#endif // BASEINFO_H_INCLUDED
diff --git a/lib/bool.h b/lib/bool.h
deleted file mode 100644
index c1e53b88a2d1c23410634ca773c2715590fa47cb..0000000000000000000000000000000000000000
--- a/lib/bool.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef BOOL_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-int implb(int x, int y);
-
-#define BOOL_H_INCLUDED
-#endif // BOOL_H_INCLUDED
diff --git a/lib/c.h b/lib/c.h
index 074f8160ac6983b79b69e3832a7cb6293397f14c..611b381a3ef67193707038565a8cd0e14d5a7897 100644
--- a/lib/c.h
+++ b/lib/c.h
@@ -1,11 +1,13 @@
#ifndef C_H_INCLUDED
-#include <stdlib.h>
+#include "uint32gmp.h"
#include <stdint.h>
+#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <alloca.h>
#define IGNORE2(x,y) do { (void)(x); (void)(y); } while (0)
#define IGNORE3(x,y,z) do { (void)(x); (void)(y); (void)(z); } while (0)
+
#define C_H_INCLUDED
#endif // C_H_INCLUDED
diff --git a/lib/compare.c b/lib/compare.c
index 09ac2700b70f5e465fd0aec244d28a7103010f60..4ef322107ff1a87b1614da0703efde3b46eae565 100644
--- a/lib/compare.c
+++ b/lib/compare.c
@@ -1,21 +1,5 @@
-#include <stdlib.h>
+#include "compare.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "power.h"
-
-#include "c.h"
-
-#include "map.h"
-
-#include "types.h"
int32_t wmpn_cmp(uint64_t * x, uint64_t * y, int32_t sz) {
int32_t i;
@@ -35,4 +19,3 @@ int32_t wmpn_cmp(uint64_t * x, uint64_t * y, int32_t sz) {
}
return 0;
}
-
diff --git a/lib/compare.h b/lib/compare.h
index fe5b19907129c1ac4e86ce78dc6eb02b87f22bb7..ff2750c1ccedc6ed2e53831f98e1e4bb09b8d44e 100644
--- a/lib/compare.h
+++ b/lib/compare.h
@@ -1,10 +1,9 @@
#ifndef COMPARE_H_INCLUDED
-#include <stdlib.h>
+#include "uint64gmp.h"
+#include "c.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
int32_t wmpn_cmp(uint64_t * x, uint64_t * y, int32_t sz);
#define COMPARE_H_INCLUDED
diff --git a/lib/computerdivision.h b/lib/computerdivision.h
deleted file mode 100644
index fdd350377097415ea83af1cd6522a03f9dc5bf5c..0000000000000000000000000000000000000000
--- a/lib/computerdivision.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef COMPUTERDIVISION_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#define COMPUTERDIVISION_H_INCLUDED
-#endif // COMPUTERDIVISION_H_INCLUDED
diff --git a/lib/div.c b/lib/div.c
index 2c1b85e58c80fbcd956afcb98a42c0b2a9ae9d0c..b6a9b4c95121260c7347b09bec0b06a2808fb0ed 100644
--- a/lib/div.c
+++ b/lib/div.c
@@ -1,50 +1,11 @@
-#include <stdlib.h>
+#include "div.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "power.h"
-
-#include "c.h"
-
-#include "array.h"
-
-#include "map.h"
-
-#include "types.h"
-
-#include "compare.h"
-
-#include "utilold.h"
-
-#include "addold.h"
-
-#include "subold.h"
-
-#include "logicalutil.h"
-
-#include "logicalold.h"
-
-#include "euclideandivision.h"
-
-#include "minmax.h"
-
-#include "mul.h"
uint64_t invert_limb(uint64_t d) {
- return div64_2by1((0xffffffffffffffffUL), (0xffffffffffffffffUL) - d, d);
+ return div64_2by1(0xffffffffffffffffUL, 0xffffffffffffffffUL - d, d);
}
+struct __div2by1_inv_result;
-struct __div2by1_inv_result
-{ uint64_t __field_0;
- uint64_t __field_1;
-};
struct __div2by1_inv_result div2by1_inv(uint64_t uh, uint64_t ul, uint64_t d,
uint64_t v) {
@@ -124,12 +85,8 @@ uint64_t wmpn_divrem_1(uint64_t * q, uint64_t * x, int32_t sz, uint64_t y) {
return r;
}
}
+struct __div3by2_inv_result;
-struct __div3by2_inv_result
-{ uint64_t __field_0;
- uint64_t __field_1;
- uint64_t __field_2;
-};
struct __div3by2_inv_result div3by2_inv(uint64_t uh, uint64_t um,
uint64_t ul, uint64_t dh,
@@ -141,7 +98,7 @@ struct __div3by2_inv_result div3by2_inv(uint64_t uh, uint64_t um,
uint64_t sh, p, tl, th, il, b;
struct __mul64_double_result struct_res3;
struct __sub64_with_borrow_result struct_res4, struct_res5, struct_res6,
- struct_res7;
+ struct_res7;
uint64_t ih, bl, b2, bh, rl, c1, rh, bl1, b1;
struct __add64_with_carry_result struct_res8, struct_res9;
struct __sub64_with_borrow_result struct_res10, struct_res11;
@@ -272,7 +229,7 @@ uint64_t div_sb_qr(uint64_t * q, uint64_t * x, int32_t sx, uint64_t * y,
xd1 = xp + mdn;
nx0 = (xp)[1];
if (__builtin_expect(x1 == dh && nx0 == dl,0)) {
- ql = (0xffffffffffffffffUL);
+ ql = 0xffffffffffffffffUL;
wmpn_submul_1(xd1, y, sy, ql);
x1 = (xp)[1];
qp = qp + -1;
@@ -508,4 +465,3 @@ void wmpn_tdiv_qr_in_place(uint64_t * q, int32_t qxn, uint64_t * x,
free(ny);
return;
}
-
diff --git a/lib/div.h b/lib/div.h
index 69c05518f799ecd41c2a8d7e4b03246e472ac191..e189af32cde30a71b3a58d4bb3d7bb78c7db8bfc 100644
--- a/lib/div.h
+++ b/lib/div.h
@@ -1,14 +1,20 @@
#ifndef DIV_H_INCLUDED
-#include <stdlib.h>
+#include "uint64gmp.h"
+#include "c.h"
+#include "compare.h"
+#include "utilold.h"
+#include "addold.h"
+#include "subold.h"
+#include "logicalutil.h"
+#include "logicalold.h"
+#include "mul.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
uint64_t invert_limb(uint64_t d);
-struct __div2by1_inv_result
-{ uint64_t __field_0;
+struct __div2by1_inv_result {
+ uint64_t __field_0;
uint64_t __field_1;
};
@@ -17,8 +23,8 @@ struct __div2by1_inv_result div2by1_inv(uint64_t uh, uint64_t ul, uint64_t d,
uint64_t wmpn_divrem_1(uint64_t * q, uint64_t * x, int32_t sz, uint64_t y);
-struct __div3by2_inv_result
-{ uint64_t __field_0;
+struct __div3by2_inv_result {
+ uint64_t __field_0;
uint64_t __field_1;
uint64_t __field_2;
};
diff --git a/lib/euclideandivision.h b/lib/euclideandivision.h
deleted file mode 100644
index 3f53625f2a163969d16c89d25c183fce5ade2ca9..0000000000000000000000000000000000000000
--- a/lib/euclideandivision.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef EUCLIDEANDIVISION_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#define EUCLIDEANDIVISION_H_INCLUDED
-#endif // EUCLIDEANDIVISION_H_INCLUDED
diff --git a/lib/explog.h b/lib/explog.h
deleted file mode 100644
index 33b5a4da0bf41e8f2bc1c2f59bf95555f9506803..0000000000000000000000000000000000000000
--- a/lib/explog.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef EXPLOG_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#define EXPLOG_H_INCLUDED
-#endif // EXPLOG_H_INCLUDED
diff --git a/lib/fxp.h b/lib/fxp.h
index 03034786a5b231ae4432de5bbb585644c280f40c..95994f7aef0eb4df0dbb25c72be9f67267552050 100644
--- a/lib/fxp.h
+++ b/lib/fxp.h
@@ -1,13 +1,5 @@
#ifndef FXP_H_INCLUDED
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-uint64_t fxp_init(uint64_t x);
-
-uint64_t fxp_id(uint64_t x);
#define FXP_H_INCLUDED
#endif // FXP_H_INCLUDED
diff --git a/lib/get_str.c b/lib/get_str.c
new file mode 100644
index 0000000000000000000000000000000000000000..860f67013b5399f1a0211c5c91c10066a40bcd90
--- /dev/null
+++ b/lib/get_str.c
@@ -0,0 +1,122 @@
+#include "get_str.h"
+#include <stdint.h>
+
+uint32_t wmpn_get_str_bits(unsigned char * sp, uint32_t bits, uint64_t * up,
+ int32_t un) {
+ uint64_t um, sb, b;
+ int32_t e, sn;
+ int32_t i, j;
+ uint64_t shift, digit;
+ uint64_t lu, luqt, high, sj;
+ um = up[un - 1];
+ sb = wmpn_limb_size_in_base_2(um);
+ e = 64 * (un - 1) + (int32_t)sb + (int32_t)bits - 1;
+ sn = e / (int32_t)bits;
+ b = UINT64_C(1) << (uint64_t)bits;
+ i = 0;
+ j = sn;
+ shift = UINT64_C(0);
+ while (j > 0) {
+ j = j - 1;
+ lu = up[i];
+ digit = lu >> shift;
+ shift = shift + (uint64_t)bits;
+ if (shift >= UINT64_C(64)) {
+ i = i + 1;
+ if (i < un) {
+ shift = shift - UINT64_C(64);
+ luqt = up[i];
+ high = luqt << ((uint64_t)bits - shift);
+ digit = digit + high;
+ }
+ }
+ sj = digit % b;
+ sp[j] = (unsigned char)sj;
+ }
+ return (uint32_t)sn;
+}
+
+uint32_t wmpn_limb_get_str(unsigned char * sp, uint64_t * w, uint64_t d1,
+ uint64_t di, uint64_t shift) {
+ int32_t i;
+ uint64_t h, l, q, r;
+ struct __div2by1_inv_result struct_res;
+ i = 0;
+ while (*w > UINT64_C(0)) {
+ h = *w >> (UINT64_C(64) - shift);
+ l = *w << shift;
+ struct_res = div2by1_inv(h, l, d1, di);
+ q = struct_res.__field_0;
+ r = struct_res.__field_1;
+ sp[i] = (unsigned char)(r >> shift);
+ *w = q;
+ i = i + 1;
+ }
+ return (uint32_t)i;
+}
+
+uint32_t wmpn_get_str_other(unsigned char * sp, int32_t base,
+ struct wmpn_base_info info, uint64_t * up,
+ int32_t un) {
+ uint64_t shift, d1, di;
+ int32_t sn, n;
+ uint64_t * tp;
+ uint64_t w;
+ uint64_t o;
+ unsigned char * spn;
+ uint32_t sdone;
+ uint32_t o1;
+ uint64_t lu;
+ unsigned char * spn1;
+ uint32_t sdone1;
+ int32_t i;
+ unsigned char t;
+ shift = (uint64_t)__builtin_clzll((uint64_t)base);
+ d1 = (uint64_t)base << shift;
+ di = invert_limb(d1);
+ sn = 0;
+ n = un;
+ if (n > 1) {
+ tp = alloca((uint32_t)n * sizeof(uint64_t));
+ while (n > 1) {
+ o = wmpn_divrem_1(tp, up, n, info.bb);
+ w = o;
+ wmpn_copyi1(up, tp, n);
+ n = n - (up[n - 1] == UINT64_C(0));
+ spn = sp + sn;
+ o1 = wmpn_limb_get_str(spn, &w, d1, di, shift);
+ sdone = o1;
+ sn = sn + (int32_t)sdone;
+ while (sdone < info.exp) {
+ sp[sn] = 0;
+ sn = sn + 1;
+ sdone = sdone + 1U;
+ }
+ }
+ }
+ lu = *up;
+ spn1 = sp + sn;
+ sdone1 = wmpn_limb_get_str(spn1, &lu, d1, di, shift);
+ sn = sn + (int32_t)sdone1;
+ i = 0;
+ while (2 * i + 1 < sn) {
+ t = sp[i];
+ sp[i] = sp[sn - i - 1];
+ sp[sn - i - 1] = t;
+ i = i + 1;
+ }
+ return (uint32_t)sn;
+}
+
+uint32_t wmpn_get_str(unsigned char * sp, int32_t base, uint64_t * up,
+ int32_t un) {
+ uint32_t bits;
+ struct wmpn_base_info info;
+ bits = wmpn_base_power_of_two_p((uint64_t)base);
+ if (!(bits == 0U)) {
+ return wmpn_get_str_bits(sp, bits, up, un);
+ } else {
+ info = wmpn_get_base_info((uint64_t)base);
+ return wmpn_get_str_other(sp, base, info, up, un);
+ }
+}
diff --git a/lib/get_str.h b/lib/get_str.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6d33dd0f8d2c8962e10f427645db73c8a7ed666
--- /dev/null
+++ b/lib/get_str.h
@@ -0,0 +1,26 @@
+#ifndef GET_STR_H_INCLUDED
+
+#include "uint64gmp.h"
+#include "c.h"
+#include "powm.h"
+#include "logical.h"
+#include "baseinfo.h"
+#include "div.h"
+#include "utilold.h"
+#include <stdint.h>
+
+uint32_t wmpn_get_str_bits(unsigned char * sp, uint32_t bits, uint64_t * up,
+ int32_t un);
+
+uint32_t wmpn_limb_get_str(unsigned char * sp, uint64_t * w, uint64_t d1,
+ uint64_t di, uint64_t shift);
+
+uint32_t wmpn_get_str_other(unsigned char * sp, int32_t base,
+ struct wmpn_base_info info, uint64_t * up,
+ int32_t un);
+
+uint32_t wmpn_get_str(unsigned char * sp, int32_t base, uint64_t * up,
+ int32_t un);
+
+#define GET_STR_H_INCLUDED
+#endif // GET_STR_H_INCLUDED
diff --git a/lib/int.h b/lib/int.h
deleted file mode 100644
index f65cc537361dc3cffee34d17892440de783bd639..0000000000000000000000000000000000000000
--- a/lib/int.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef INT_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-
-
-
-
-
-
-#define INT_H_INCLUDED
-#endif // INT_H_INCLUDED
diff --git a/lib/int32.h b/lib/int32.h
deleted file mode 100644
index 56bcefd1a1e22759e2c19c5ad30e01518b0f9f3f..0000000000000000000000000000000000000000
--- a/lib/int32.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef INT32_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-
-
-#define INT32_H_INCLUDED
-#endif // INT32_H_INCLUDED
diff --git a/lib/int64.h b/lib/int64.h
deleted file mode 100644
index 7a78900517626e3212b7e1057b00236d6a356de4..0000000000000000000000000000000000000000
--- a/lib/int64.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef INT64_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-
-
-#define INT64_H_INCLUDED
-#endif // INT64_H_INCLUDED
diff --git a/lib/logical.c b/lib/logical.c
index d5196aff6faf1fe1cabc6f2215b37226448a1eda..e2ac3814141c5cf84fa4c50b15c4c31f4bb27cc3 100644
--- a/lib/logical.c
+++ b/lib/logical.c
@@ -1,29 +1,5 @@
-#include <stdlib.h>
+#include "logical.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "power.h"
-
-#include "c.h"
-
-#include "array.h"
-
-#include "map.h"
-
-#include "types.h"
-
-#include "euclideandivision.h"
-
-#include "logicalutil.h"
-
-#include "alias.h"
uint64_t wmpn_lshift(uint64_t * r, uint64_t * x, int32_t sz, uint64_t cnt) {
int32_t msb;
@@ -58,19 +34,6 @@ uint64_t wmpn_lshift(uint64_t * r, uint64_t * x, int32_t sz, uint64_t cnt) {
return retval;
}
-uint64_t wmpn_lshift_sep(uint64_t * r, uint64_t * x, int32_t sz, uint64_t cnt) {
- uint64_t * nr;
- uint64_t * nx;
- struct __open_shift_sep_result struct_res;
- uint64_t res;
- struct_res = open_shift_sep(r, x, sz);
- nr = struct_res.__field_0;
- nx = struct_res.__field_1;
- res = wmpn_lshift(nr, nx, sz, cnt);
- IGNORE2(r,x);
- return res;
-}
-
uint64_t wmpn_rshift(uint64_t * r, uint64_t * x, int32_t sz, uint64_t cnt) {
uint64_t tnc;
int32_t msb;
@@ -107,17 +70,3 @@ uint64_t wmpn_rshift(uint64_t * r, uint64_t * x, int32_t sz, uint64_t cnt) {
*rp = low;
return retval;
}
-
-uint64_t wmpn_rshift_sep(uint64_t * r, uint64_t * x, int32_t sz, uint64_t cnt) {
- uint64_t * nr;
- uint64_t * nx;
- struct __open_shift_sep_result struct_res;
- uint64_t res;
- struct_res = open_shift_sep(r, x, sz);
- nr = struct_res.__field_0;
- nx = struct_res.__field_1;
- res = wmpn_rshift(nr, nx, sz, cnt);
- IGNORE2(r,x);
- return res;
-}
-
diff --git a/lib/logical.h b/lib/logical.h
index 285706e52313c41794329fd7b1f0b184fe9aa21a..7e4036083c21793c7fd9945648dd24711317b834 100644
--- a/lib/logical.h
+++ b/lib/logical.h
@@ -1,17 +1,14 @@
#ifndef LOGICAL_H_INCLUDED
-#include <stdlib.h>
+#include "uint64gmp.h"
+#include "c.h"
+#include "logicalutil.h"
+#include "alias.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-uint64_t wmpn_lshift(uint64_t * r, uint64_t * x, int32_t sz, uint64_t cnt);
-uint64_t wmpn_lshift_sep(uint64_t * r, uint64_t * x, int32_t sz, uint64_t cnt);
+uint64_t wmpn_lshift(uint64_t * r, uint64_t * x, int32_t sz, uint64_t cnt);
uint64_t wmpn_rshift(uint64_t * r, uint64_t * x, int32_t sz, uint64_t cnt);
-uint64_t wmpn_rshift_sep(uint64_t * r, uint64_t * x, int32_t sz, uint64_t cnt);
-
#define LOGICAL_H_INCLUDED
#endif // LOGICAL_H_INCLUDED
diff --git a/lib/logicalold.c b/lib/logicalold.c
index b397f38953782ce4877b83bc58d0a30028d9f6d3..05f2abb55610f8330ff3d3c59e9fdea0f1c9908d 100644
--- a/lib/logicalold.c
+++ b/lib/logicalold.c
@@ -1,27 +1,5 @@
-#include <stdlib.h>
+#include "logicalold.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "power.h"
-
-#include "c.h"
-
-#include "array.h"
-
-#include "map.h"
-
-#include "types.h"
-
-#include "euclideandivision.h"
-
-#include "logicalutil.h"
uint64_t wmpn_lshift1(uint64_t * r, uint64_t * x, int32_t sz, uint64_t cnt) {
int32_t msb;
@@ -156,4 +134,3 @@ uint64_t wmpn_rshift_in_place(uint64_t * x, int32_t sz, uint64_t cnt) {
x[msb] = low;
return retval;
}
-
diff --git a/lib/logicalold.h b/lib/logicalold.h
index 92d38426df8ba7343ab82710f0ff2b9da92bc2dd..0e16d3397e85d8f3a26cdf06b33cc00a3e81bda5 100644
--- a/lib/logicalold.h
+++ b/lib/logicalold.h
@@ -1,10 +1,10 @@
#ifndef LOGICALOLD_H_INCLUDED
-#include <stdlib.h>
+#include "uint64gmp.h"
+#include "c.h"
+#include "logicalutil.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
uint64_t wmpn_lshift1(uint64_t * r, uint64_t * x, int32_t sz, uint64_t cnt);
uint64_t wmpn_rshift1(uint64_t * r, uint64_t * x, int32_t sz, uint64_t cnt);
diff --git a/lib/logicalutil.c b/lib/logicalutil.c
index 8efeeeabb975ac9ce9503b6dd36052ede1c5ca04..d21d341603b4aecf535c53842a52d75db7948a65 100644
--- a/lib/logicalutil.c
+++ b/lib/logicalutil.c
@@ -1,34 +1,7 @@
-#include <stdlib.h>
+#include "logicalutil.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
+struct __lsld_ext_result;
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "power.h"
-
-#include "c.h"
-
-#include "array.h"
-
-#include "map.h"
-
-#include "types.h"
-
-#include "euclideandivision.h"
-
-uint64_t lsl_mod_ext(uint64_t x, uint64_t cnt) {
- return x << cnt;
-}
-
-struct __lsld_ext_result
-{ uint64_t __field_0;
- uint64_t __field_1;
-};
struct __lsld_ext_result lsld_ext(uint64_t x, uint64_t cnt) {
struct __lsld_ext_result result;
@@ -48,8 +21,3 @@ struct __lsld_ext_result lsld_ext(uint64_t x, uint64_t cnt) {
return result1;
}
}
-
-int32_t clz_ext(uint64_t x) {
- return __builtin_clzll(x);
-}
-
diff --git a/lib/logicalutil.h b/lib/logicalutil.h
index 577c84f37251e3b80dcec3cb9dcfcd0386f2a930..a3e4d12639ebad0237c7eb1a325d7815068d359a 100644
--- a/lib/logicalutil.h
+++ b/lib/logicalutil.h
@@ -1,20 +1,15 @@
#ifndef LOGICALUTIL_H_INCLUDED
-#include <stdlib.h>
+#include "uint64gmp.h"
+#include "c.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-uint64_t lsl_mod_ext(uint64_t x, uint64_t cnt);
-struct __lsld_ext_result
-{ uint64_t __field_0;
+struct __lsld_ext_result {
+ uint64_t __field_0;
uint64_t __field_1;
};
struct __lsld_ext_result lsld_ext(uint64_t x, uint64_t cnt);
-int32_t clz_ext(uint64_t x);
-
#define LOGICALUTIL_H_INCLUDED
#endif // LOGICALUTIL_H_INCLUDED
diff --git a/lib/map.h b/lib/map.h
deleted file mode 100644
index d24eac9a8b025d2518d6bc93c6e2a39eafe7d545..0000000000000000000000000000000000000000
--- a/lib/map.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef MAP_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-
-
-#define MAP_H_INCLUDED
-#endif // MAP_H_INCLUDED
diff --git a/lib/minmax.h b/lib/minmax.h
deleted file mode 100644
index 09e16d394527cf5359da6f09b791874ea95564c5..0000000000000000000000000000000000000000
--- a/lib/minmax.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef MINMAX_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-
-
-#define MINMAX_H_INCLUDED
-#endif // MINMAX_H_INCLUDED
diff --git a/lib/mul.c b/lib/mul.c
index fb19dbc40884eb31ba0a4c7526f356cd0940f4e3..9620bcbbda7e99cc4280bb28c631addd7cc5479a 100644
--- a/lib/mul.c
+++ b/lib/mul.c
@@ -1,27 +1,5 @@
-#include <stdlib.h>
+#include "mul.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "power.h"
-
-#include "c.h"
-
-#include "array.h"
-
-#include "map.h"
-
-#include "types.h"
-
-#include "util.h"
-
-#include "add.h"
uint64_t wmpn_mul_1(uint64_t * r, uint64_t * x, int32_t sz, uint64_t y) {
uint64_t cl, ul;
@@ -42,7 +20,7 @@ uint64_t wmpn_mul_1(uint64_t * r, uint64_t * x, int32_t sz, uint64_t y) {
l = struct_res.__field_0;
h = struct_res.__field_1;
lpl = l + cl;
- cl = (lpl < cl ? UINT64_C(1) : UINT64_C(0)) + h;
+ cl = (lpl < cl) + h;
*rp = lpl;
rp = rp + 1;
n = n - 1;
@@ -71,10 +49,10 @@ uint64_t wmpn_addmul_1(uint64_t * r, uint64_t * x, int32_t sz, uint64_t y) {
l = struct_res.__field_0;
h = struct_res.__field_1;
lpl = l + cl;
- cl = (lpl < cl ? UINT64_C(1) : UINT64_C(0)) + h;
+ cl = (lpl < cl) + h;
rl = *rp;
lpl = rl + lpl;
- cl = (lpl < rl ? UINT64_C(1) : UINT64_C(0)) + cl;
+ cl = (lpl < rl) + cl;
*rp = lpl;
rp = rp + 1;
n = n - 1;
@@ -125,7 +103,7 @@ uint64_t wmpn_mul_1_in_place(uint64_t * x, int32_t sz, uint64_t y) {
l = struct_res.__field_0;
h = struct_res.__field_1;
lpl = l + cl;
- cl = (lpl < cl ? UINT64_C(1) : UINT64_C(0)) + h;
+ cl = (lpl < cl) + h;
*up = lpl;
up = up + 1;
n = n - 1;
@@ -154,10 +132,10 @@ uint64_t wmpn_submul_1(uint64_t * r, uint64_t * x, int32_t sz, uint64_t y) {
l = struct_res.__field_0;
h = struct_res.__field_1;
lpl = l + cl;
- cl = (lpl < cl ? UINT64_C(1) : UINT64_C(0)) + h;
+ cl = (lpl < cl) + h;
rl = *rp;
lpl = rl - lpl;
- cl = (lpl > rl ? UINT64_C(1) : UINT64_C(0)) + cl;
+ cl = (lpl > rl) + cl;
*rp = lpl;
rp = rp + 1;
n = n - 1;
@@ -175,4 +153,3 @@ uint64_t wmpn_addmul_2(uint64_t * r, uint64_t * x, int32_t sz, uint64_t * y) {
y1 = y[1];
return wmpn_addmul_1(r1, x, sz, y1);
}
-
diff --git a/lib/mul.h b/lib/mul.h
index d13ea9b324d71231411a895e1111ebf6afb37e9d..c96a60f949abd9722802ef2708886c203f20c8b1 100644
--- a/lib/mul.h
+++ b/lib/mul.h
@@ -1,10 +1,11 @@
#ifndef MUL_H_INCLUDED
-#include <stdlib.h>
+#include "uint64gmp.h"
+#include "c.h"
+#include "util.h"
+#include "add.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
uint64_t wmpn_mul_1(uint64_t * r, uint64_t * x, int32_t sz, uint64_t y);
uint64_t wmpn_addmul_1(uint64_t * r, uint64_t * x, int32_t sz, uint64_t y);
diff --git a/lib/mul_basecase.c b/lib/mul_basecase.c
index 708d6a58d65d10c5047af2e89b7fe5f4aa356930..6c1f64a093d63c1bb4fafe40576a1cac33022f82 100644
--- a/lib/mul_basecase.c
+++ b/lib/mul_basecase.c
@@ -1,29 +1,5 @@
-#include <stdlib.h>
+#include "mul_basecase.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "power.h"
-
-#include "c.h"
-
-#include "array.h"
-
-#include "map.h"
-
-#include "types.h"
-
-#include "util.h"
-
-#include "add.h"
-
-#include "mul.h"
void wmpn_mul_basecase(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
int32_t sy) {
@@ -52,4 +28,3 @@ void wmpn_mul_basecase(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
vn = vn - 1;
}
}
-
diff --git a/lib/mul_basecase.h b/lib/mul_basecase.h
index 8360f5fa5116e646156f73fdd4236297a1092786..acfb7ffc38496d976ce0c60713396425f59475fb 100644
--- a/lib/mul_basecase.h
+++ b/lib/mul_basecase.h
@@ -1,10 +1,12 @@
#ifndef MUL_BASECASE_H_INCLUDED
-#include <stdlib.h>
+#include "uint64gmp.h"
+#include "c.h"
+#include "util.h"
+#include "add.h"
+#include "mul.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
void wmpn_mul_basecase(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
int32_t sy);
diff --git a/lib/power.h b/lib/power.h
deleted file mode 100644
index ed1029fb7b3e1e1f44a8195675d3bd7156a2f09e..0000000000000000000000000000000000000000
--- a/lib/power.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef POWER_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#define POWER_H_INCLUDED
-#endif // POWER_H_INCLUDED
diff --git a/lib/powm.c b/lib/powm.c
index cc0e09259b195b3f6a714a5ac140b2076e283cd3..f2187f1cfdfb6b3af6fc148d619a36b025b219df 100644
--- a/lib/powm.c
+++ b/lib/powm.c
@@ -1,50 +1,10 @@
-#include <stdlib.h>
+#include "powm.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "array.h"
-
-#include "map.h"
-
-#include "c.h"
-
-#include "int32.h"
-
-#include "uint32gmp.h"
-
-#include "uint64gmp.h"
-
-#include "int.h"
-
-#include "power.h"
-
-#include "types.h"
-
-#include "compare.h"
-
-#include "util.h"
-
-#include "utilold.h"
-
-#include "addold.h"
-
-#include "subold.h"
-
-#include "mul.h"
-
-#include "logicalutil.h"
-
-#include "div.h"
-
-#include "toom.h"
-
-#include "euclideandivision.h"
#include "binverttab.h"
uint64_t binvert_limb_table (uint64_t n) {
-return (uint64_t)binverttab[n];
+ return (uint64_t)binverttab[n];
}
void wmpn_redc_1(uint64_t * rp, uint64_t * up, uint64_t * mp, int32_t n,
@@ -139,16 +99,9 @@ static inline void redcify(uint64_t * rp, uint64_t * up, int32_t un,
uint64_t * mp, int32_t n) {
uint64_t * tp;
uint64_t * qp;
- int32_t i;
- uint64_t lzero;
tp = alloca((uint32_t)(un + n) * sizeof(uint64_t));
qp = alloca((uint32_t)(un + 1) * sizeof(uint64_t));
- i = 0;
- lzero = UINT64_C(0);
- while (i < n) {
- tp[i] = lzero;
- i = i + 1;
- }
+ wmpn_zero(tp, n);
wmpn_copyi1(tp + n, up, un);
wmpn_tdiv_qr(qp, rp, 0, tp, un + n, mp, n);
return;
@@ -203,9 +156,6 @@ void wmpn_powm(uint64_t * rp, uint64_t * bp, int32_t bn, uint64_t * ep,
int32_t this_windowsize;
int32_t ebh1;
uint64_t * ppn1;
- uint64_t * o1;
- int32_t i1;
- uint64_t lzero;
le = ep[en - 1];
cnt = __builtin_clzll(le);
ebi = 64 * en - cnt;
@@ -272,13 +222,7 @@ void wmpn_powm(uint64_t * rp, uint64_t * bp, int32_t bn, uint64_t * ep,
wmpn_redc_1(rp, tp, mp, n, mip);
}
wmpn_copyi1(tp, rp, n);
- o1 = tp + n;
- i1 = 0;
- lzero = UINT64_C(0);
- while (i1 < n) {
- o1[i1] = lzero;
- i1 = i1 + 1;
- }
+ wmpn_zero(tp + n, n);
wmpn_redc_1(rp, tp, mp, n, mip);
if (wmpn_cmp(rp, mp, n) >= 0) {
wmpn_sub_n_in_place(rp, mp, n);
@@ -287,4 +231,3 @@ void wmpn_powm(uint64_t * rp, uint64_t * bp, int32_t bn, uint64_t * ep,
return;
}
}
-
diff --git a/lib/powm.h b/lib/powm.h
index 7a211b8fcba94ad9145bd49e01c6604fbeb529c3..ee09c958e2c22f02ca807f6bd385a444ac3b28ae 100644
--- a/lib/powm.h
+++ b/lib/powm.h
@@ -1,10 +1,19 @@
#ifndef POWM_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "uint32gmp.h"
+#include "uint64gmp.h"
+#include "compare.h"
+#include "util.h"
+#include "utilold.h"
+#include "addold.h"
+#include "subold.h"
+#include "mul.h"
+#include "logicalutil.h"
+#include "div.h"
+#include "toom.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
void wmpn_redc_1(uint64_t * rp, uint64_t * up, uint64_t * mp, int32_t n,
uint64_t invm);
diff --git a/lib/realinfix.h b/lib/realinfix.h
deleted file mode 100644
index 29db6760d9853349f9787c13982ea4be8d06e27a..0000000000000000000000000000000000000000
--- a/lib/realinfix.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef REALINFIX_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-
-
-
-
-
-
-
-
-
-#define REALINFIX_H_INCLUDED
-#endif // REALINFIX_H_INCLUDED
diff --git a/lib/set.c b/lib/set.c
index c2134c43ffb5a89db3399e77223a97285e90a240..9587044970ff5dc0599c72ded5752e9eb345b4fd 100644
--- a/lib/set.c
+++ b/lib/set.c
@@ -1,27 +1,5 @@
-#include <stdlib.h>
+#include "set.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "euclideandivision.h"
-
-#include "abs.h"
-
-#include "map.h"
-
-#include "c.h"
-
-#include "int32.h"
-
-#include "int64.h"
-
-#include "uint64gmp.h"
-
-#include "z.h"
-
-#include "zutil.h"
void wmpz_set_ui(wmpz_ptr dst, uint64_t src) {
uint64_t * dstp;
@@ -79,4 +57,3 @@ uint64_t wmpz_get_ui(wmpz_ptr src) {
(void)(src);
return v;
}
-
diff --git a/lib/set.h b/lib/set.h
index 975e16fbf95299bda4e042c3d779bbf6a74634f7..ec578a38246f1a5d0228b7496353b87967f473c1 100644
--- a/lib/set.h
+++ b/lib/set.h
@@ -1,10 +1,11 @@
#ifndef SET_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "uint64gmp.h"
+#include "z.h"
+#include "zutil.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
void wmpz_set_ui(wmpz_ptr dst, uint64_t src);
uint64_t abs_cast(int64_t x);
diff --git a/lib/set_str.c b/lib/set_str.c
new file mode 100644
index 0000000000000000000000000000000000000000..f254b275f418eb6bbeaa117da88227a395ae4896
--- /dev/null
+++ b/lib/set_str.c
@@ -0,0 +1,105 @@
+#include "set_str.h"
+#include <stdint.h>
+
+int32_t wmpn_set_str_bits(uint64_t * rp, unsigned char * sp, uint32_t sn,
+ uint32_t bits) {
+ int32_t rn, j;
+ uint32_t shift;
+ uint64_t sj, rlow, slow, nr, shigh;
+ rn = 0;
+ shift = 0U;
+ j = (int32_t)sn;
+ while (j > 0) {
+ j = j - 1;
+ sj = (uint64_t)sp[j];
+ if (shift == 0U) {
+ rp[rn] = sj;
+ rn = rn + 1;
+ shift = bits;
+ } else {
+ rlow = rp[rn - 1];
+ slow = sj << (uint64_t)shift;
+ nr = rlow + slow;
+ rp[rn - 1] = nr;
+ shift = shift + bits;
+ if (shift >= 64U) {
+ shift = shift - 64U;
+ if (shift > 0U) {
+ shigh = sj >> (uint64_t)(bits - shift);
+ rp[rn] = shigh;
+ rn = rn + 1;
+ }
+ }
+ }
+ }
+ normalize(rp, &rn);
+ return rn;
+}
+
+int32_t wmpn_set_str_other(uint64_t * rp, unsigned char * sp, uint32_t sn,
+ uint64_t b, struct wmpn_base_info info) {
+ uint32_t k;
+ uint64_t w;
+ int32_t j;
+ uint32_t o;
+ uint64_t sj;
+ int32_t rn;
+ uint32_t k1, o1;
+ uint64_t sj1, o2, cy1;
+ uint64_t cy;
+ k = 1U + (sn - 1U) % info.exp;
+ w = (uint64_t)*sp;
+ j = 1;
+ while (1) {
+ k = k - 1U;
+ o = k;
+ if (!(o > 0U)) {
+ break;
+ }
+ sj = (uint64_t)sp[j];
+ w = w * b + sj;
+ j = j + 1;
+ }
+ *rp = w;
+ rn = 1;
+ while (j < (int32_t)sn) {
+ w = (uint64_t)sp[j];
+ j = j + 1;
+ o1 = info.exp - 1U;
+ if (1U <= o1) {
+ for (k1 = 1U; ; ++k1) {
+ sj1 = (uint64_t)sp[j];
+ w = w * b + sj1;
+ j = j + 1;
+ if (k1 == o1) {
+ break;
+ }
+ }
+ }
+ o2 = wmpn_mul_1_in_place(rp, rn, info.bb);
+ cy = o2;
+ cy1 = wmpn_add_1_in_place(rp, rn, w);
+ cy = cy + cy1;
+ if (cy > UINT64_C(0)) {
+ rp[rn] = cy;
+ rn = rn + 1;
+ }
+ }
+ return rn;
+}
+
+int32_t wmpn_set_str(uint64_t * rp, unsigned char * sp, uint32_t sn,
+ int32_t base) {
+ uint32_t bits;
+ struct wmpn_base_info info;
+ if (sn == 0U) {
+ return 0;
+ }
+ bits = wmpn_base_power_of_two_p((uint64_t)base);
+ if (!(bits == 0U)) {
+ return wmpn_set_str_bits(rp, sp, sn, bits);
+ } else {
+ info = wmpn_get_base_info((uint64_t)base);
+ return wmpn_set_str_other(rp, sp, sn, (uint64_t)base, info);
+ }
+}
diff --git a/lib/set_str.h b/lib/set_str.h
new file mode 100644
index 0000000000000000000000000000000000000000..8bbb37d6349cbce68309c9782266e78bc1d871a0
--- /dev/null
+++ b/lib/set_str.h
@@ -0,0 +1,23 @@
+#ifndef SET_STR_H_INCLUDED
+
+#include "uint64gmp.h"
+#include "c.h"
+#include "powm.h"
+#include "logical.h"
+#include "util.h"
+#include "baseinfo.h"
+#include "mul.h"
+#include "add_1.h"
+#include <stdint.h>
+
+int32_t wmpn_set_str_bits(uint64_t * rp, unsigned char * sp, uint32_t sn,
+ uint32_t bits);
+
+int32_t wmpn_set_str_other(uint64_t * rp, unsigned char * sp, uint32_t sn,
+ uint64_t b, struct wmpn_base_info info);
+
+int32_t wmpn_set_str(uint64_t * rp, unsigned char * sp, uint32_t sn,
+ int32_t base);
+
+#define SET_STR_H_INCLUDED
+#endif // SET_STR_H_INCLUDED
diff --git a/lib/sqrt.c b/lib/sqrt.c
index fe993515f69b78ffd7274d87e741148c60a5ac56..4dd5b76c4423b0cbb223181c4ccbf301d9d97e6e 100644
--- a/lib/sqrt.c
+++ b/lib/sqrt.c
@@ -1,53 +1,5 @@
-#include <stdlib.h>
+#include "sqrt.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "array.h"
-
-#include "map.h"
-
-#include "c.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "euclideandivision.h"
-
-#include "int.h"
-
-#include "power.h"
-
-#include "types.h"
-
-#include "compare.h"
-
-#include "utilold.h"
-
-#include "add_1.h"
-
-#include "addold.h"
-
-#include "sub_1.h"
-
-#include "subold.h"
-
-#include "mul.h"
-
-#include "logicalutil.h"
-
-#include "logical.h"
-
-#include "div.h"
-
-#include "sqrt1.h"
-
-#include "alias.h"
-
-#include "explog.h"
-
-#include "toom.h"
uint64_t wmpn_sqrtrem2(uint64_t * sp, uint64_t * rp, uint64_t * np) {
uint64_t np0, o, prec, nph, rq, u, uh;
@@ -58,7 +10,7 @@ uint64_t wmpn_sqrtrem2(uint64_t * sp, uint64_t * rp, uint64_t * np) {
o = sqrt1(rp, np[1]);
sp0 = o;
rp0 = *rp;
- prec = (64) / UINT64_C(2);
+ prec = 64 / UINT64_C(2);
nph = np0 >> (prec + UINT64_C(1));
rp0 = (rp0 << (prec - UINT64_C(1))) + nph;
q = rp0 / sp0;
@@ -143,7 +95,7 @@ uint64_t wmpn_dc_sqrtrem(uint64_t * sp, uint64_t * np, int32_t n,
IGNORE2(sp,scratch);
res;
st = sp[l - 1];
- ql = q << ((64) - UINT64_C(1));
+ ql = q << (64 - UINT64_C(1));
qh = q >> UINT64_C(1);
sp[l - 1] = st + ql;
q = qh;
@@ -304,4 +256,3 @@ int32_t wmpn_sqrtrem(uint64_t * sp, uint64_t * rp, uint64_t * np, int32_t n) {
}
return rn;
}
-
diff --git a/lib/sqrt.h b/lib/sqrt.h
index e2ae68c9d4d6f1d5a5f10f6dc93ab91000327907..ac542769d272c5d40c12412cf0d5b9180e4ec69c 100644
--- a/lib/sqrt.h
+++ b/lib/sqrt.h
@@ -1,10 +1,22 @@
#ifndef SQRT_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "uint64gmp.h"
+#include "compare.h"
+#include "utilold.h"
+#include "add_1.h"
+#include "addold.h"
+#include "sub_1.h"
+#include "subold.h"
+#include "mul.h"
+#include "logicalutil.h"
+#include "logical.h"
+#include "div.h"
+#include "sqrt1.h"
+#include "alias.h"
+#include "toom.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
uint64_t wmpn_sqrtrem2(uint64_t * sp, uint64_t * rp, uint64_t * np);
uint64_t wmpn_dc_sqrtrem(uint64_t * sp, uint64_t * np, int32_t n,
diff --git a/lib/sqrt1.c b/lib/sqrt1.c
index 0b80cad39bb63e89fd852c1ba53b1d32321b0967..e5c91630f930226561d65cb6eac5aed522f1e12f 100644
--- a/lib/sqrt1.c
+++ b/lib/sqrt1.c
@@ -1,34 +1,11 @@
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "euclideandivision.h"
-
-#include "realinfix.h"
-
-#include "square.h"
-
-#include "uint64.h"
-
-#include "power.h"
-
-#include "map.h"
-
-#include "c.h"
-
-#include "fxp.h"
-
-
+#include "sqrt1.h"
#include "sqrtinit.h"
uint64_t rsa_estimate (uint64_t a) {
-uint64_t abits, x0;
-abits = a >> 55;
-x0 = 0x100 | invsqrttab[abits - 0x80];
-return x0;
+ uint64_t abits, x0;
+ abits = a >> 55;
+ x0 = 0x100 | invsqrttab[abits - 0x80];
+ return x0;
}
uint64_t sqrt1(uint64_t * rp, uint64_t a0) {
@@ -58,4 +35,3 @@ uint64_t sqrt1(uint64_t * rp, uint64_t a0) {
*rp = a0 - s;
return c;
}
-
diff --git a/lib/sqrt1.h b/lib/sqrt1.h
index 5ed03411598b2f19695719d64b61a395e221b57e..f5dcd447f9b952353ef67855b68bf0c8a4a0d906 100644
--- a/lib/sqrt1.h
+++ b/lib/sqrt1.h
@@ -1,10 +1,8 @@
#ifndef SQRT1_H_INCLUDED
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+#include "c.h"
+#include "fxp.h"
+
uint64_t sqrt1(uint64_t * rp, uint64_t a0);
#define SQRT1_H_INCLUDED
diff --git a/lib/square.h b/lib/square.h
deleted file mode 100644
index ce39c7b71d80838c329d759cbc0c219b8b91742c..0000000000000000000000000000000000000000
--- a/lib/square.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef SQUARE_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#define SQUARE_H_INCLUDED
-#endif // SQUARE_H_INCLUDED
diff --git a/lib/sub.c b/lib/sub.c
index 5a2dba46321dbc066a718db9985185889c38d85c..0851fa478ed042addaeb751e3192ff9282a1eb86 100644
--- a/lib/sub.c
+++ b/lib/sub.c
@@ -1,25 +1,5 @@
-#include <stdlib.h>
+#include "sub.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "c.h"
-
-#include "int.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "types.h"
-
-#include "array.h"
-
-#include "map.h"
-
-#include "alias.h"
-
-#include "power.h"
uint64_t wmpn_sub_n(uint64_t * r, uint64_t * x, uint64_t * y, int32_t sz) {
uint64_t lx, ly, b;
@@ -161,4 +141,3 @@ uint64_t sub_ry(uint64_t * x, int32_t sx, uint64_t * y, int32_t sy) {
IGNORE3(y,sx,sx);
return res;
}
-
diff --git a/lib/sub.h b/lib/sub.h
index e38cc197b09fd707e4f40451edb319d6711343ab..86eed71faeb0b70d2761f620c464a49a82b013ab 100644
--- a/lib/sub.h
+++ b/lib/sub.h
@@ -1,10 +1,10 @@
#ifndef SUB_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "uint64gmp.h"
+#include "alias.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
uint64_t wmpn_sub_n(uint64_t * r, uint64_t * x, uint64_t * y, int32_t sz);
uint64_t wmpn_sub(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
diff --git a/lib/sub_1.c b/lib/sub_1.c
index c8d870f3c45c483e21c267c2cf2133e14f26d7e0..9f19fa7693e5fdb65f7891dfe3213a43f886d01a 100644
--- a/lib/sub_1.c
+++ b/lib/sub_1.c
@@ -1,23 +1,5 @@
-#include <stdlib.h>
+#include "sub_1.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "power.h"
-
-#include "c.h"
-
-#include "array.h"
-
-#include "map.h"
-
-#include "types.h"
uint64_t wmpn_sub_1(uint64_t * r, uint64_t * x, int32_t sz, uint64_t y) {
uint64_t b, lx;
@@ -113,4 +95,3 @@ uint64_t wmpn_sub_1_in_place(uint64_t * x, int32_t sz, uint64_t y) {
}
return b;
}
-
diff --git a/lib/sub_1.h b/lib/sub_1.h
index 6733b4adefe51b184c3995c7d1976598261bdf41..cb91b2cb8ac5bc7b2f43ca41f0854535c7319fa6 100644
--- a/lib/sub_1.h
+++ b/lib/sub_1.h
@@ -1,10 +1,9 @@
#ifndef SUB_1_H_INCLUDED
-#include <stdlib.h>
+#include "uint64gmp.h"
+#include "c.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
uint64_t wmpn_sub_1(uint64_t * r, uint64_t * x, int32_t sz, uint64_t y);
void wmpn_decr(uint64_t * x, uint64_t y);
diff --git a/lib/subold.c b/lib/subold.c
index 027f50ec3eb5256e247892f3aa180a725628eb78..9f59f97c6b2b2e9e6370cbfdc4342f7cd20d484a 100644
--- a/lib/subold.c
+++ b/lib/subold.c
@@ -1,25 +1,5 @@
-#include <stdlib.h>
+#include "subold.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "c.h"
-
-#include "int.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "types.h"
-
-#include "array.h"
-
-#include "map.h"
-
-#include "power.h"
-
-#include "alias.h"
uint64_t wmpn_sub_n1(uint64_t * r, uint64_t * x, uint64_t * y, int32_t sz) {
uint64_t lx, ly, b;
@@ -116,4 +96,3 @@ uint64_t wmpn_sub_in_place(uint64_t * x, int32_t sx, uint64_t * y, int32_t sy) {
}
return b;
}
-
diff --git a/lib/subold.h b/lib/subold.h
index 4be7647b37d9974c97c7ababae7630c37fac0fa6..8fadd21af82adf92c09664c45c752b3f1c1915de 100644
--- a/lib/subold.h
+++ b/lib/subold.h
@@ -1,10 +1,10 @@
#ifndef SUBOLD_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "uint64gmp.h"
+#include "alias.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
uint64_t wmpn_sub_n1(uint64_t * r, uint64_t * x, uint64_t * y, int32_t sz);
uint64_t wmpn_sub1(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
diff --git a/lib/toom.c b/lib/toom.c
index 601d1ef8b2e45cb2849442b35143ec6742dc9c2d..b91085f8c0c8d82242335f5ad7600b0095261f37 100644
--- a/lib/toom.c
+++ b/lib/toom.c
@@ -1,49 +1,7 @@
-#include <stdlib.h>
+#include "toom.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "array.h"
-#include "map.h"
-
-#include "c.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "int.h"
-
-#include "power.h"
-
-#include "computerdivision.h"
-
-#include "types.h"
-
-#include "compare.h"
-
-#include "util.h"
-
-#include "utilold.h"
-
-#include "add_1.h"
-
-#include "addold.h"
-
-#include "sub_1.h"
-
-#include "subold.h"
-
-#include "mul.h"
-
-#include "mul_basecase.h"
-
-#include "logical.h"
-
-int32_t toom22_threshold() {
- return 29;
-}
+int32_t toom22_threshold = 29;
void wmpn_toom22_mul(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
int32_t sy, uint64_t * scratch);
@@ -79,8 +37,6 @@ void wmpn_toom22_mul(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
uint64_t * y0t;
int c0, c1;
uint64_t * ysm1t;
- int32_t i;
- uint64_t lzero;
uint64_t * v0;
uint64_t * v0n;
uint64_t * vinfn;
@@ -135,12 +91,7 @@ void wmpn_toom22_mul(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
if (c0 && c1) {
wmpn_sub_n1(ysm1, y1, y0, t);
ysm1t = ysm1 + t;
- i = 0;
- lzero = UINT64_C(0);
- while (i < n - t) {
- ysm1t[i] = lzero;
- i = i + 1;
- }
+ wmpn_zero(ysm1t, n - t);
vm1_neg = !(vm1_neg);
} else {
wmpn_sub1(ysm1, y0, n, y1, t);
@@ -190,7 +141,7 @@ void wmpn_toom22_mul(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
void wmpn_toom22_mul_rec(uint64_t * r, uint64_t * x, int32_t sx,
uint64_t * y, int32_t sy, uint64_t * scratch) {
- if (sy <= toom22_threshold()) {
+ if (sy <= toom22_threshold) {
wmpn_mul_basecase(r, x, sx, y, sy);
return;
} else {
@@ -206,7 +157,7 @@ void wmpn_toom22_mul_rec(uint64_t * r, uint64_t * x, int32_t sx,
void wmpn_toom22_mul_n_rec(uint64_t * r, uint64_t * x, uint64_t * y,
uint64_t * scratch, int32_t sz) {
- if (sz <= toom22_threshold()) {
+ if (sz <= toom22_threshold) {
wmpn_mul_basecase(r, x, sz, y, sz);
return;
} else {
@@ -241,8 +192,6 @@ void wmpn_toom32_mul(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
int c0, c1;
int32_t cmp2;
uint64_t * ym1t;
- int32_t i;
- uint64_t lzero;
uint64_t cy;
uint64_t * sn;
uint64_t c2, c3;
@@ -325,12 +274,7 @@ void wmpn_toom32_mul(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
if (c0 && c1) {
wmpn_sub_n1(ym1, y1, y0, t);
ym1t = ym1 + t;
- i = 0;
- lzero = UINT64_C(0);
- while (i < n - t) {
- ym1t[i] = lzero;
- i = i + 1;
- }
+ wmpn_zero(ym1t, n - t);
vm1_neg = !(vm1_neg);
} else {
wmpn_sub1(ym1, y0, n, y1, t);
@@ -460,7 +404,7 @@ uint64_t wmpn_mul(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
uint64_t cy1;
uint64_t * rpn1;
uint64_t * wsy1;
- if (sy <= toom22_threshold()) {
+ if (sy <= toom22_threshold) {
wmpn_mul_basecase(r, x, sx, y, sy);
} else {
scratch = alloca((uint32_t)(5 * sy + 128) * sizeof(uint64_t));
@@ -516,7 +460,7 @@ uint64_t wmpn_mul(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
void wmpn_mul_n(uint64_t * r, uint64_t * x, uint64_t * y, int32_t sz) {
uint64_t * ws;
- if (sz <= toom22_threshold()) {
+ if (sz <= toom22_threshold) {
wmpn_mul_basecase(r, x, sz, y, sz);
return;
} else {
@@ -525,4 +469,3 @@ void wmpn_mul_n(uint64_t * r, uint64_t * x, uint64_t * y, int32_t sz) {
return;
}
}
-
diff --git a/lib/toom.h b/lib/toom.h
index 524367eed9b3ec32862d7fde16b30252e7284814..e587aa532a562ef53afefb90ffb856aa7cc85f9d 100644
--- a/lib/toom.h
+++ b/lib/toom.h
@@ -1,11 +1,20 @@
#ifndef TOOM_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "uint64gmp.h"
+#include "compare.h"
+#include "util.h"
+#include "utilold.h"
+#include "add_1.h"
+#include "addold.h"
+#include "sub_1.h"
+#include "subold.h"
+#include "mul.h"
+#include "mul_basecase.h"
+#include "logical.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-int32_t toom22_threshold();
+
+extern int32_t toom22_threshold;
void wmpn_toom22_mul(uint64_t * r, uint64_t * x, int32_t sx, uint64_t * y,
int32_t sy, uint64_t * scratch);
diff --git a/lib/types.h b/lib/types.h
deleted file mode 100644
index efd91f2d0f89a97770016fc319960f5aec588a0a..0000000000000000000000000000000000000000
--- a/lib/types.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef TYPES_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#define TYPES_H_INCLUDED
-#endif // TYPES_H_INCLUDED
diff --git a/lib/uint32gmp.h b/lib/uint32gmp.h
index d913272a2cbb922be1a29c80cd96eb3742e05fda..16792660041f234f67ea265ceeb891b5fc39a726 100644
--- a/lib/uint32gmp.h
+++ b/lib/uint32gmp.h
@@ -1,45 +1,46 @@
#ifndef UINT32GMP_H_INCLUDED
-#include <stdlib.h>
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-struct __add32_with_carry_result
-{ uint32_t __field_0;
-uint32_t __field_1;
+struct __add32_with_carry_result {
+ uint32_t __field_0;
+ uint32_t __field_1;
};
-struct __add32_with_carry_result add32_with_carry(uint32_t x, uint32_t y, uint32_t c);
+struct __add32_with_carry_result
+add32_with_carry(uint32_t x, uint32_t y, uint32_t c);
-struct __sub32_with_borrow_result
-{ uint32_t __field_0;
-uint32_t __field_1;
+struct __sub32_with_borrow_result {
+ uint32_t __field_0;
+ uint32_t __field_1;
};
-struct __sub32_with_borrow_result sub32_with_borrow(uint32_t x, uint32_t y, uint32_t b);
+struct __sub32_with_borrow_result
+sub32_with_borrow(uint32_t x, uint32_t y, uint32_t b);
-struct __mul32_double_result
-{ uint32_t __field_0;
-uint32_t __field_1;
+struct __mul32_double_result {
+ uint32_t __field_0;
+ uint32_t __field_1;
};
-struct __mul32_double_result mul32_double(uint32_t x, uint32_t y);
+struct __mul32_double_result
+mul32_double(uint32_t x, uint32_t y);
-struct __add32_3_result
-{ uint32_t __field_0;
-uint32_t __field_1;
+struct __add32_3_result {
+ uint32_t __field_0;
+ uint32_t __field_1;
};
-struct __add32_3_result add32_3(uint32_t x, uint32_t y, uint32_t z);
+struct __add32_3_result
+add32_3(uint32_t x, uint32_t y, uint32_t z);
-struct __lsld32_result
-{ uint32_t __field_0;
-uint32_t __field_1;
+struct __lsld32_result {
+ uint32_t __field_0;
+ uint32_t __field_1;
};
-struct __lsld32_result lsld32(uint32_t x, uint32_t cnt);
+struct __lsld32_result
+lsld32(uint32_t x, uint32_t cnt);
#define UINT32GMP_H_INCLUDED
diff --git a/lib/uint64.h b/lib/uint64.h
deleted file mode 100644
index 2a1c949000d5444942d1afeddc200dd138b1105a..0000000000000000000000000000000000000000
--- a/lib/uint64.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef UINT64_H_INCLUDED
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-
-#define UINT64_H_INCLUDED
-#endif // UINT64_H_INCLUDED
diff --git a/lib/uint64gmp.h b/lib/uint64gmp.h
index a57ed41b8a7cbfe2a745574a1fd30b665a96ddf6..58f3b33c2cf547d24af3ece23bd89a80e576ebe4 100644
--- a/lib/uint64gmp.h
+++ b/lib/uint64gmp.h
@@ -1,93 +1,90 @@
#ifndef UINT64GMP_H_INCLUDED
-#include <stdlib.h>
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
typedef unsigned __int128 uint128_t;
struct __mul64_double_result
{ uint64_t __field_0;
-uint64_t __field_1;
+ uint64_t __field_1;
};
static inline struct __mul64_double_result mul64_double(uint64_t x, uint64_t y)
{
-uint128_t z = (uint128_t)x * (uint128_t)y;
-struct __mul64_double_result result = { z, z >> 64 };
-return result;
+ uint128_t z = (uint128_t)x * (uint128_t)y;
+ struct __mul64_double_result result = { z, z >> 64 };
+ return result;
}
static inline uint64_t div64_2by1(uint64_t ul, uint64_t uh, uint64_t d)
{
-return (((uint128_t)uh << 64) | ul) / d;
+ return (((uint128_t)uh << 64) | ul) / d;
}
-
-struct __add64_with_carry_result
-{ uint64_t __field_0;
-uint64_t __field_1;
+struct __add64_with_carry_result {
+ uint64_t __field_0;
+ uint64_t __field_1;
};
static inline struct __add64_with_carry_result
add64_with_carry(uint64_t x, uint64_t y, uint64_t c)
{
-struct __add64_with_carry_result result;
-uint64_t r = x + y + c;
-result.__field_0 = r;
-if (r == x) result.__field_1 = c;
-else result.__field_1 = (r < x);
-return result;
+ struct __add64_with_carry_result result;
+ uint64_t r = x + y + c;
+ result.__field_0 = r;
+ if (r == x) result.__field_1 = c;
+ else result.__field_1 = (r < x);
+ return result;
}
-struct __sub64_with_borrow_result
-{ uint64_t __field_0;
-uint64_t __field_1;
+struct __sub64_with_borrow_result {
+ uint64_t __field_0;
+ uint64_t __field_1;
};
static inline struct __sub64_with_borrow_result
sub64_with_borrow(uint64_t x, uint64_t y, uint64_t b)
{
-struct __sub64_with_borrow_result result;
-uint64_t r = x - y - b;
-result.__field_0 = r;
-if (r > x) result.__field_1 = 1;
-else if (r == x) result.__field_1 = b;
-else result.__field_1 = 0;
-return result;
+ struct __sub64_with_borrow_result result;
+ uint64_t r = x - y - b;
+ result.__field_0 = r;
+ if (r > x) result.__field_1 = 1;
+ else if (r == x) result.__field_1 = b;
+ else result.__field_1 = 0;
+ return result;
}
-struct __add64_3_result
-{ uint64_t __field_0;
-uint64_t __field_1;
+struct __add64_3_result {
+ uint64_t __field_0;
+ uint64_t __field_1;
};
-static inline struct __add64_3_result add64_3(uint64_t x, uint64_t y, uint64_t z)
+static inline struct __add64_3_result
+add64_3(uint64_t x, uint64_t y, uint64_t z)
{
-struct __add64_3_result result;
-uint64_t r, c1, c2;
-r = x + y;
-c1 = r < y;
-r += z;
-c2 = r < z;
-result.__field_1 = c1 + c2;
-result.__field_0 = r;
-return result;
+ struct __add64_3_result result;
+ uint64_t r, c1, c2;
+ r = x + y;
+ c1 = r < y;
+ r += z;
+ c2 = r < z;
+ result.__field_1 = c1 + c2;
+ result.__field_0 = r;
+ return result;
}
struct __lsld64_result
{ uint64_t __field_0;
-uint64_t __field_1;
+ uint64_t __field_1;
};
-static inline struct __lsld64_result lsld64(uint64_t x, uint64_t cnt)
+static inline struct __lsld64_result
+lsld64(uint64_t x, uint64_t cnt)
{
-struct __lsld64_result result;
-result.__field_1 = x >> (64 - cnt);
-result.__field_0 = x << cnt;
-return result;
+ struct __lsld64_result result;
+ result.__field_1 = x >> (64 - cnt);
+ result.__field_0 = x << cnt;
+ return result;
}
diff --git a/lib/util.c b/lib/util.c
index 1b230c142eb118e930c95f45e180a1609f803761..d7d7784a5e875e410562bc07767aa79098caa015 100644
--- a/lib/util.c
+++ b/lib/util.c
@@ -1,25 +1,5 @@
-#include <stdlib.h>
+#include "util.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "power.h"
-
-#include "c.h"
-
-#include "array.h"
-
-#include "map.h"
-
-#include "types.h"
-
-#include "alias.h"
int32_t wmpn_zero_p(uint64_t * x, int32_t sz) {
int32_t i;
@@ -94,4 +74,3 @@ void wmpn_copyi(uint64_t * rp, uint64_t * up, int32_t n) {
}
}
}
-
diff --git a/lib/util.h b/lib/util.h
index af619de78654239b02d1b3583a6bf20623d878ca..d313203ca4939a83495ebf5980295736a5ecfaee 100644
--- a/lib/util.h
+++ b/lib/util.h
@@ -1,10 +1,10 @@
#ifndef UTIL_H_INCLUDED
-#include <stdlib.h>
+#include "uint64gmp.h"
+#include "c.h"
+#include "alias.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
int32_t wmpn_zero_p(uint64_t * x, int32_t sz);
void wmpn_zero(uint64_t * r, int32_t sz);
diff --git a/lib/utilold.c b/lib/utilold.c
index 51715f62c03ec7fba16b657ab6c3bc1fdbaee4a1..3d23feff0d186c547488b6fa4ac21646697b8790 100644
--- a/lib/utilold.c
+++ b/lib/utilold.c
@@ -1,23 +1,5 @@
-#include <stdlib.h>
+#include "utilold.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "int32.h"
-
-#include "uint64gmp.h"
-
-#include "power.h"
-
-#include "c.h"
-
-#include "array.h"
-
-#include "map.h"
-
-#include "types.h"
void wmpn_copyi1(uint64_t * r, uint64_t * x, int32_t sz) {
int32_t i;
@@ -33,4 +15,3 @@ void wmpn_copyi1(uint64_t * r, uint64_t * x, int32_t sz) {
i = i + 1;
}
}
-
diff --git a/lib/utilold.h b/lib/utilold.h
index a7a667b0a8727ddfaba47840adef0982a8586184..fc88db03853dffeef20bede190868f08584273ab 100644
--- a/lib/utilold.h
+++ b/lib/utilold.h
@@ -1,10 +1,9 @@
#ifndef UTILOLD_H_INCLUDED
-#include <stdlib.h>
+#include "uint64gmp.h"
+#include "c.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
void wmpn_copyi1(uint64_t * r, uint64_t * x, int32_t sz);
#define UTILOLD_H_INCLUDED
diff --git a/lib/z.c b/lib/z.c
deleted file mode 100644
index 6c63cb63372e1f37be2bd35e54816d4eebcd6bdf..0000000000000000000000000000000000000000
--- a/lib/z.c
+++ /dev/null
@@ -1,52 +0,0 @@
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "abs.h"
-
-#include "int32.h"
-
-#include "c.h"
-
-#include "map.h"
-
-#include "types.h"
-
-#include "uint64gmp.h"
-
-#include "power.h"
-
-
-typedef struct
-{
-int _alloc;
-int _size;
-uint64_t * _ptr;
-} __wmpz_struct;
-
-typedef __wmpz_struct *wmpz_ptr;
-
-#define SIZ(x) ((x)->_size)
-#define ALLOC(x) ((x)->_alloc)
-#define PTR(x) ((x)->_ptr)
-
-
-int32_t abs(int32_t x) {
- if (x >= 0) {
- return x;
- } else {
- return -x;
- }
-}
-
-int32_t abs_size_of(wmpz_ptr x) {
- if (SIZ(x) >= 0) {
- return SIZ(x);
- } else {
- return -SIZ(x);
- }
-}
-
diff --git a/lib/z.h b/lib/z.h
index 3d6df6beba56bf395afdcdff1f61b6aed62900a3..50832070f4b278af8e4a0d5b6a7fcec7e8690e05 100644
--- a/lib/z.h
+++ b/lib/z.h
@@ -1,28 +1,23 @@
#ifndef Z_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "uint64gmp.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
typedef struct
{
-int _alloc;
-int _size;
-uint64_t * _ptr;
+ int _alloc;
+ int _size;
+ uint64_t * _ptr;
} __wmpz_struct;
typedef __wmpz_struct *wmpz_ptr;
+typedef __wmpz_struct wmpz_t[1];
#define SIZ(x) ((x)->_size)
#define ALLOC(x) ((x)->_alloc)
#define PTR(x) ((x)->_ptr)
-int32_t abs(int32_t x);
-
-int32_t abs_size_of(wmpz_ptr x);
-
#define Z_H_INCLUDED
#endif // Z_H_INCLUDED
diff --git a/lib/zabs.c b/lib/zabs.c
new file mode 100644
index 0000000000000000000000000000000000000000..a9f2b1d11c4987c180be730e1318723deded3380
--- /dev/null
+++ b/lib/zabs.c
@@ -0,0 +1,24 @@
+#include "zabs.h"
+#include <stdint.h>
+
+void wmpz_abs(wmpz_ptr w, wmpz_ptr u) {
+ int32_t size;
+ uint64_t * wp;
+ uint64_t * up;
+ if (SIZ(u) >= 0) {
+ size = SIZ(u);
+ } else {
+ size = -SIZ(u);
+ }
+ if (!(u == w)) {
+ wp = wmpz_realloc(w, size);
+ up = PTR(u);
+ wmpn_copyd_sep(wp, up, size);
+ (void)(u);
+ SIZ(w) = size;
+ (void)(w);
+ return;
+ } else {
+ return;
+ }
+}
diff --git a/lib/zabs.h b/lib/zabs.h
new file mode 100644
index 0000000000000000000000000000000000000000..2ff92030ae68ba8d0e6c77fc38a19d52df410f60
--- /dev/null
+++ b/lib/zabs.h
@@ -0,0 +1,14 @@
+#ifndef ZABS_H_INCLUDED
+
+#include "c.h"
+#include "util.h"
+#include "compare.h"
+#include "uint64gmp.h"
+#include "z.h"
+#include "zutil.h"
+#include <stdint.h>
+
+void wmpz_abs(wmpz_ptr w, wmpz_ptr u);
+
+#define ZABS_H_INCLUDED
+#endif // ZABS_H_INCLUDED
diff --git a/lib/zadd.c b/lib/zadd.c
index 2334cce7dc8548f7b4178d4862d48d0f515823c4..d1675180511ad33fad89a659675cd5c4a5d8448b 100644
--- a/lib/zadd.c
+++ b/lib/zadd.c
@@ -1,37 +1,5 @@
-#include <stdlib.h>
+#include "zadd.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "power.h"
-
-#include "map.h"
-
-#include "c.h"
-
-#include "util.h"
-
-#include "alias.h"
-
-#include "compare.h"
-
-#include "uint64gmp.h"
-
-#include "add.h"
-
-#include "sub.h"
-
-#include "abs.h"
-
-#include "z.h"
-
-#include "zutil.h"
-
-#include "add_1.h"
-
-#include "sub_1.h"
void wmpz_add(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
wmpz_ptr u1, v1;
@@ -99,12 +67,7 @@ void wmpz_add(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
}
}
wsize = abs_usize;
- while (wsize > 0) {
- if (!(wp[wsize - 1] == UINT64_C(0))) {
- break;
- }
- wsize = wsize - 1;
- }
+ normalize(wp, &wsize);
if (usize < 0) {
wsize = -wsize;
}
@@ -114,23 +77,13 @@ void wmpz_add(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
vp2 = PTR(v1);
if (wmpn_cmp(wp, vp2, abs_usize) < 0) {
usb3 = sub_n_ry(vp2, wp, abs_usize);
- while (wsize > 0) {
- if (!(wp[wsize - 1] == UINT64_C(0))) {
- break;
- }
- wsize = wsize - 1;
- }
+ normalize(wp, &wsize);
if (usize >= 0) {
wsize = -wsize;
}
} else {
usb4 = sub_n_rx(wp, vp2, abs_usize);
- while (wsize > 0) {
- if (!(wp[wsize - 1] == UINT64_C(0))) {
- break;
- }
- wsize = wsize - 1;
- }
+ normalize(wp, &wsize);
if (usize < 0) {
wsize = -wsize;
}
@@ -141,23 +94,13 @@ void wmpz_add(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
up2 = PTR(u1);
if (wmpn_cmp(up2, wp, abs_usize) < 0) {
usb5 = sub_n_rx(wp, up2, abs_usize);
- while (wsize > 0) {
- if (!(wp[wsize - 1] == UINT64_C(0))) {
- break;
- }
- wsize = wsize - 1;
- }
+ normalize(wp, &wsize);
if (usize >= 0) {
wsize = -wsize;
}
} else {
usb6 = sub_n_ry(up2, wp, abs_usize);
- while (wsize > 0) {
- if (!(wp[wsize - 1] == UINT64_C(0))) {
- break;
- }
- wsize = wsize - 1;
- }
+ normalize(wp, &wsize);
if (usize < 0) {
wsize = -wsize;
}
@@ -168,23 +111,13 @@ void wmpz_add(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
vp3 = PTR(v1);
if (wmpn_cmp(up3, vp3, abs_usize) < 0) {
usb7 = sub_n(wp, vp3, up3, abs_usize);
- while (wsize > 0) {
- if (!(wp[wsize - 1] == UINT64_C(0))) {
- break;
- }
- wsize = wsize - 1;
- }
+ normalize(wp, &wsize);
if (usize >= 0) {
wsize = -wsize;
}
} else {
usb8 = sub_n(wp, up3, vp3, abs_usize);
- while (wsize > 0) {
- if (!(wp[wsize - 1] == UINT64_C(0))) {
- break;
- }
- wsize = wsize - 1;
- }
+ normalize(wp, &wsize);
if (usize < 0) {
wsize = -wsize;
}
@@ -246,7 +179,7 @@ void wmpz_add_ui(wmpz_ptr w, wmpz_ptr u, uint64_t v) {
if (usize == 0) {
wp = PTR(w);
*wp = v;
- SIZ(w) = !(v == UINT64_C(0)) ? 1 : 0;
+ SIZ(w) = !(v == UINT64_C(0));
(void)(w);
return;
}
@@ -278,7 +211,7 @@ void wmpz_add_ui(wmpz_ptr w, wmpz_ptr u, uint64_t v) {
wsize = 1;
} else {
wmpn_sub_1_in_place(wp1, abs_usize, v);
- wsize = -(abs_usize - (wp1[abs_usize - 1] == UINT64_C(0) ? 1 : 0));
+ wsize = -(abs_usize - (wp1[abs_usize - 1] == UINT64_C(0)));
}
} else {
up1 = PTR(u);
@@ -287,7 +220,7 @@ void wmpz_add_ui(wmpz_ptr w, wmpz_ptr u, uint64_t v) {
wsize = 1;
} else {
wmpn_sub_1(wp1, up1, abs_usize, v);
- wsize = -(abs_usize - (wp1[abs_usize - 1] == UINT64_C(0) ? 1 : 0));
+ wsize = -(abs_usize - (wp1[abs_usize - 1] == UINT64_C(0)));
}
(void)(u);
}
@@ -296,4 +229,3 @@ void wmpz_add_ui(wmpz_ptr w, wmpz_ptr u, uint64_t v) {
(void)(w);
return;
}
-
diff --git a/lib/zadd.h b/lib/zadd.h
index 5112f08c4d6736ae154e6dab14b5469461e30770..593014f86c39868f68680ce54736285dce68080e 100644
--- a/lib/zadd.h
+++ b/lib/zadd.h
@@ -1,10 +1,18 @@
#ifndef ZADD_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "util.h"
+#include "alias.h"
+#include "compare.h"
+#include "uint64gmp.h"
+#include "add.h"
+#include "sub.h"
+#include "z.h"
+#include "zutil.h"
+#include "add_1.h"
+#include "sub_1.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
void wmpz_add(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v);
void wmpz_add_ui(wmpz_ptr w, wmpz_ptr u, uint64_t v);
diff --git a/lib/zcmp.c b/lib/zcmp.c
index e10a1756e82bb9ee265f65bf9cde90096986324c..eb3188393067af38bde566c30b1aa63331123866 100644
--- a/lib/zcmp.c
+++ b/lib/zcmp.c
@@ -1,31 +1,5 @@
-#include <stdlib.h>
+#include "zcmp.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "power.h"
-
-#include "map.h"
-
-#include "c.h"
-
-#include "compare.h"
-
-#include "alias.h"
-
-#include "compare.h"
-
-#include "uint64gmp.h"
-
-#include "abs.h"
-
-#include "z.h"
-
-#include "zutil.h"
-
-#include "types.h"
int32_t wmpz_cmp(wmpz_ptr u, wmpz_ptr v) {
int32_t usize, vsize, dsize, asize;
@@ -86,3 +60,38 @@ int32_t wmpz_cmp_ui(wmpz_ptr u, uint64_t v_digit) {
}
}
+int32_t wmpz_cmp_si(wmpz_ptr u, int64_t v_digit) {
+ int32_t usize, vsize;
+ uint64_t * up;
+ uint64_t ul, vl;
+ usize = SIZ(u);
+ vsize = (v_digit > INT64_C(0)) - (v_digit < INT64_C(0));
+ if (usize == 0 || !(usize == vsize)) {
+ return usize - vsize;
+ } else {
+ up = PTR(u);
+ ul = *up;
+ vl = abs_cast(v_digit);
+ (void)(u);
+ if (ul == vl) {
+ return 0;
+ }
+ if (ul > vl) {
+ return usize;
+ } else {
+ return -usize;
+ }
+ }
+}
+
+int32_t wmpz_sgn(wmpz_ptr u) {
+ if (SIZ(u) < 0) {
+ return -1;
+ } else {
+ if (SIZ(u) > 0) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+}
diff --git a/lib/zcmp.h b/lib/zcmp.h
index 5494b6daadc8978054886fc057a669f85f69ce04..8c66c353e0eaa0f084345c75495172225afe237c 100644
--- a/lib/zcmp.h
+++ b/lib/zcmp.h
@@ -1,13 +1,22 @@
#ifndef ZCMP_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "compare.h"
+#include "alias.h"
+#include "compare.h"
+#include "uint64gmp.h"
+#include "z.h"
+#include "zutil.h"
+#include "set.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
int32_t wmpz_cmp(wmpz_ptr u, wmpz_ptr v);
int32_t wmpz_cmp_ui(wmpz_ptr u, uint64_t v_digit);
+int32_t wmpz_cmp_si(wmpz_ptr u, int64_t v_digit);
+
+int32_t wmpz_sgn(wmpz_ptr u);
+
#define ZCMP_H_INCLUDED
#endif // ZCMP_H_INCLUDED
diff --git a/lib/zcmpabs.c b/lib/zcmpabs.c
new file mode 100644
index 0000000000000000000000000000000000000000..3dc6a8ef241b4ff0ca785b634c850b2f3db4586f
--- /dev/null
+++ b/lib/zcmpabs.c
@@ -0,0 +1,56 @@
+#include "zcmpabs.h"
+#include <stdint.h>
+
+int32_t wmpz_cmpabs(wmpz_ptr u, wmpz_ptr v) {
+ int32_t usize, vsize, dsize;
+ uint64_t * up;
+ uint64_t * vp;
+ int32_t cmp;
+ if (SIZ(u) >= 0) {
+ usize = SIZ(u);
+ } else {
+ usize = -SIZ(u);
+ }
+ if (SIZ(v) >= 0) {
+ vsize = SIZ(v);
+ } else {
+ vsize = -SIZ(v);
+ }
+ dsize = usize - vsize;
+ if (!(dsize == 0)) {
+ return dsize;
+ }
+ up = PTR(u);
+ vp = PTR(v);
+ cmp = wmpn_cmp(up, vp, usize);
+ (void)(u);
+ (void)(v);
+ return cmp;
+}
+
+int32_t wmpz_cmpabs_ui(wmpz_ptr u, uint64_t v_digit) {
+ int32_t un;
+ uint64_t * up;
+ uint64_t ul;
+ un = SIZ(u);
+ if (un == 0) {
+ if (!(v_digit == UINT64_C(0))) {
+ return -1;
+ } else {
+ return 0;
+ }
+ }
+ if ((un >= 0 ? un : -un) == 1) {
+ up = PTR(u);
+ ul = *up;
+ (void)(u);
+ if (ul > v_digit) {
+ return 1;
+ }
+ if (ul < v_digit) {
+ return -1;
+ }
+ return 0;
+ }
+ return 1;
+}
diff --git a/lib/zcmpabs.h b/lib/zcmpabs.h
new file mode 100644
index 0000000000000000000000000000000000000000..f0602103172fa3b04d02502949e7339bb74051d5
--- /dev/null
+++ b/lib/zcmpabs.h
@@ -0,0 +1,17 @@
+#ifndef ZCMPABS_H_INCLUDED
+
+#include "c.h"
+#include "compare.h"
+#include "alias.h"
+#include "compare.h"
+#include "uint64gmp.h"
+#include "z.h"
+#include "zutil.h"
+#include <stdint.h>
+
+int32_t wmpz_cmpabs(wmpz_ptr u, wmpz_ptr v);
+
+int32_t wmpz_cmpabs_ui(wmpz_ptr u, uint64_t v_digit);
+
+#define ZCMPABS_H_INCLUDED
+#endif // ZCMPABS_H_INCLUDED
diff --git a/lib/zdiv.c b/lib/zdiv.c
new file mode 100644
index 0000000000000000000000000000000000000000..3c9e59bd61508b2f41c82957bfb51a2bb65e4cdc
--- /dev/null
+++ b/lib/zdiv.c
@@ -0,0 +1,159 @@
+#include "zdiv.h"
+#include <stdint.h>
+
+void wmpz_tdiv_qr(wmpz_ptr quot, wmpz_ptr rem, wmpz_ptr num, wmpz_ptr den) {
+ int32_t ns, ds, nl;
+ int32_t dl, ql;
+ uint64_t * np;
+ uint64_t * rp;
+ wmpz_ptr dqt, nqt;
+ uint64_t * dp;
+ wmpz_ptr nd;
+ __wmpz_struct t = { 0, 0, NULL };
+ uint64_t * tdp;
+ uint64_t * np1;
+ wmpz_ptr nn;
+ __wmpz_struct t1 = { 0, 0, NULL };
+ uint64_t * tnp;
+ uint64_t * qp;
+ uint64_t * rp1;
+ uint64_t * np2;
+ uint64_t * dp1;
+ uint64_t qh;
+ int32_t qs, rs;
+ ns = SIZ(num);
+ ds = SIZ(den);
+ if (ns >= 0) {
+ nl = ns;
+ } else {
+ nl = -ns;
+ }
+ dl = ds >= 0 ? ds : -ds;
+ ql = nl - dl + 1;
+ if (ql <= 0) {
+ if (!(num == rem)) {
+ np = PTR(num);
+ rp = wmpz_realloc(rem, dl);
+ wmpn_copyd_sep(rp, np, nl);
+ SIZ(rem) = ns;
+ (void)(num);
+ (void)(rem);
+ }
+ SIZ(quot) = 0;
+ return;
+ }
+ dqt = den;
+ nqt = num;
+ if (den == rem || den == quot) {
+ dp = PTR(den);
+ nd = &t;
+ dqt = nd;
+ tdp = alloca((uint32_t)dl * sizeof(uint64_t));
+ ALLOC(dqt) = dl;
+ wmpn_copyd_sep(tdp, dp, dl);
+ PTR(dqt) = tdp;
+ SIZ(dqt) = ds;
+ (void)(dqt);
+ (void)(den);
+ }
+ if (num == rem || num == quot) {
+ np1 = PTR(num);
+ nn = &t1;
+ nqt = nn;
+ tnp = alloca((uint32_t)nl * sizeof(uint64_t));
+ ALLOC(nqt) = nl;
+ wmpn_copyd_sep(tnp, np1, nl);
+ PTR(nqt) = tnp;
+ SIZ(nqt) = ns;
+ (void)(nqt);
+ (void)(num);
+ }
+ qp = wmpz_realloc(quot, ql);
+ rp1 = wmpz_realloc(rem, dl);
+ np2 = PTR(nqt);
+ dp1 = PTR(dqt);
+ wmpn_tdiv_qr(qp, rp1, 0, np2, nl, dp1, dl);
+ qh = qp[ql - 1];
+ ql = ql - (qh == UINT64_C(0));
+ normalize(rp1, &dl);
+ if ((ns ^ ds) >= 0) {
+ qs = ql;
+ } else {
+ qs = -ql;
+ }
+ if (ns >= 0) {
+ rs = dl;
+ } else {
+ rs = -dl;
+ }
+ SIZ(quot) = qs;
+ SIZ(rem) = rs;
+ (void)(rem);
+ (void)(quot);
+ (void)(nqt);
+ (void)(dqt);
+ return;
+}
+
+uint64_t wmpz_tdiv_qr_ui(wmpz_ptr quot, wmpz_ptr rem, wmpz_ptr dividend,
+ uint64_t divisor) {
+ int32_t ns, nn;
+ uint64_t * qp;
+ int32_t qn;
+ uint64_t rl;
+ uint64_t * np;
+ uint64_t o, o1;
+ uint64_t * np1;
+ int32_t rs;
+ uint64_t * rp;
+ uint64_t qh;
+ int32_t qs;
+ ns = SIZ(dividend);
+ if (ns == 0) {
+ SIZ(quot) = 0;
+ SIZ(rem) = 0;
+ return UINT64_C(0);
+ }
+ if (ns >= 0) {
+ nn = ns;
+ } else {
+ nn = -ns;
+ }
+ qp = wmpz_realloc(quot, nn);
+ qn = nn;
+ rl = UINT64_C(0);
+ if (quot == dividend) {
+ np = alloca((uint32_t)nn * sizeof(uint64_t));
+ wmpn_copyd_sep(np, qp, nn);
+ o = wmpn_divrem_1(qp, np, nn, divisor);
+ rl = o;
+ } else {
+ np1 = PTR(dividend);
+ o1 = wmpn_divrem_1(qp, np1, nn, divisor);
+ rl = o1;
+ (void)(dividend);
+ }
+ if (rl == UINT64_C(0)) {
+ SIZ(rem) = 0;
+ } else {
+ if (ns >= 0) {
+ rs = 1;
+ } else {
+ rs = -1;
+ }
+ rp = PTR(rem);
+ *rp = rl;
+ SIZ(rem) = rs;
+ (void)(rem);
+ }
+ qh = qp[nn - 1];
+ qn = qn - (qh == UINT64_C(0));
+ if (ns >= 0) {
+ qs = qn;
+ } else {
+ qs = -qn;
+ }
+ SIZ(quot) = qs;
+ (void)(quot);
+ return rl;
+}
diff --git a/lib/zdiv.h b/lib/zdiv.h
new file mode 100644
index 0000000000000000000000000000000000000000..ccd8d89259a2c20ac677e28e4c3e33eac4a023b4
--- /dev/null
+++ b/lib/zdiv.h
@@ -0,0 +1,20 @@
+#ifndef ZDIV_H_INCLUDED
+
+#include "c.h"
+#include "util.h"
+#include "utilold.h"
+#include "alias.h"
+#include "compare.h"
+#include "uint64gmp.h"
+#include "div.h"
+#include "z.h"
+#include "zutil.h"
+#include <stdint.h>
+
+void wmpz_tdiv_qr(wmpz_ptr quot, wmpz_ptr rem, wmpz_ptr num, wmpz_ptr den);
+
+uint64_t wmpz_tdiv_qr_ui(wmpz_ptr quot, wmpz_ptr rem, wmpz_ptr dividend,
+ uint64_t divisor);
+
+#define ZDIV_H_INCLUDED
+#endif // ZDIV_H_INCLUDED
diff --git a/lib/zdiv2exp.c b/lib/zdiv2exp.c
index 9efd564aa89abae17bc2060f2ae4679a7d01af6a..3438486d31c25738259a99b4fd4b720d551f2ef5 100644
--- a/lib/zdiv2exp.c
+++ b/lib/zdiv2exp.c
@@ -1,41 +1,5 @@
-#include <stdlib.h>
+#include "zdiv2exp.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "computerdivision.h"
-
-#include "power.h"
-
-#include "map.h"
-
-#include "c.h"
-
-#include "util.h"
-
-#include "utilold.h"
-
-#include "alias.h"
-
-#include "compare.h"
-
-#include "uint64gmp.h"
-
-#include "types.h"
-
-#include "logicalutil.h"
-
-#include "logical.h"
-
-#include "logicalold.h"
-
-#include "abs.h"
-
-#include "z.h"
-
-#include "zutil.h"
void wmpz_tdiv_q_2exp(wmpz_ptr r, wmpz_ptr u, uint64_t cnt) {
int32_t un, limb_cnt;
@@ -58,7 +22,7 @@ void wmpz_tdiv_q_2exp(wmpz_ptr r, wmpz_ptr u, uint64_t cnt) {
up = rp + limb_cnt;
if (!(c == UINT64_C(0))) {
wmpn_rshift(rp, up, rn, c);
- rn = rn - (rp[rn - 1] == UINT64_C(0) ? 1 : 0);
+ rn = rn - (rp[rn - 1] == UINT64_C(0));
} else {
wmpn_copyi(rp, up, rn);
}
@@ -67,7 +31,7 @@ void wmpz_tdiv_q_2exp(wmpz_ptr r, wmpz_ptr u, uint64_t cnt) {
up1 = up0 + limb_cnt;
if (!(c == UINT64_C(0))) {
wmpn_rshift1(rp, up1, rn, c);
- rn = rn - (rp[rn - 1] == UINT64_C(0) ? 1 : 0);
+ rn = rn - (rp[rn - 1] == UINT64_C(0));
} else {
wmpn_copyi1(rp, up1, rn);
}
@@ -78,4 +42,3 @@ void wmpz_tdiv_q_2exp(wmpz_ptr r, wmpz_ptr u, uint64_t cnt) {
return;
}
}
-
diff --git a/lib/zdiv2exp.h b/lib/zdiv2exp.h
index e349b61a4cb1e5510469d440d75cfb4c54717378..e18a678c316a944e2909bb654e34d5d55e40129f 100644
--- a/lib/zdiv2exp.h
+++ b/lib/zdiv2exp.h
@@ -1,10 +1,18 @@
#ifndef ZDIV2EXP_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "util.h"
+#include "utilold.h"
+#include "alias.h"
+#include "compare.h"
+#include "uint64gmp.h"
+#include "logicalutil.h"
+#include "logical.h"
+#include "logicalold.h"
+#include "z.h"
+#include "zutil.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
void wmpz_tdiv_q_2exp(wmpz_ptr r, wmpz_ptr u, uint64_t cnt);
#define ZDIV2EXP_H_INCLUDED
diff --git a/lib/zget_str.c b/lib/zget_str.c
new file mode 100644
index 0000000000000000000000000000000000000000..5c842c61d8b9cc4ec7df209e1e4db3c647b1ddb7
--- /dev/null
+++ b/lib/zget_str.c
@@ -0,0 +1,81 @@
+#include "zget_str.h"
+#include <stdint.h>
+#include <string.h>
+
+char * wmpz_get_str(char * sp, int32_t base, wmpz_ptr u) {
+ char * digits;
+ int32_t base1, i, sn;
+ int32_t un;
+ uint32_t bits;
+ uint64_t * up;
+ unsigned char * usp;
+ unsigned char * uspi;
+ uint32_t g;
+ struct wmpn_base_info info;
+ uint64_t * tp;
+ uint32_t g1;
+ int32_t j, o;
+ unsigned char cj;
+ char dc;
+ if (base > 36) {
+ digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+ } else {
+ if (base >= 0) {
+ digits = "0123456789abcdefghijklmnopqrstuvwxyz";
+ } else {
+ digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ }
+ }
+ base1 = base;
+ if (base1 <= 0) {
+ base1 = -base1;
+ }
+ if (base1 <= 1) {
+ base1 = 10;
+ }
+ if (SIZ(u) >= 0) {
+ un = SIZ(u);
+ } else {
+ un = -SIZ(u);
+ }
+ if (un == 0) {
+ sp[0] = '0';
+ sp[1] = '\0';
+ return sp;
+ }
+ i = 0;
+ sn = 0;
+ if (SIZ(u) < 0) {
+ sp[0] = '-';
+ i = i + 1;
+ }
+ bits = wmpn_base_power_of_two_p((uint64_t)base1);
+ up = PTR(u);
+ usp = (unsigned char *)sp;
+ uspi = usp + i;
+ if (!(bits == 0U)) {
+ g = wmpn_get_str_bits(uspi, bits, up, un);
+ sn = i + (int32_t)g;
+ } else {
+ info = wmpn_get_base_info((uint64_t)base1);
+ tp = alloca((uint32_t)un * sizeof(uint64_t));
+ wmpn_copyd_sep(tp, up, un);
+ g1 = wmpn_get_str_other(uspi, base1, info, tp, un);
+ sn = i + (int32_t)g1;
+ }
+ IGNORE2(sp, usp);
+ o = sn - 1;
+ if (i <= o) {
+ for (j = i; ; ++j) {
+ cj = (unsigned char)sp[j];
+ dc = digits[(int32_t)cj];
+ sp[j] = dc;
+ if (j == o) {
+ break;
+ }
+ }
+ }
+ sp[sn] = '\0';
+ (void)(u);
+ return sp;
+}
diff --git a/lib/zget_str.h b/lib/zget_str.h
new file mode 100644
index 0000000000000000000000000000000000000000..4552678e945619537aa0dbecf8c02fca68435e29
--- /dev/null
+++ b/lib/zget_str.h
@@ -0,0 +1,16 @@
+#ifndef ZGET_STR_H_INCLUDED
+
+#include "c.h"
+#include "uint64gmp.h"
+#include "util.h"
+#include "z.h"
+#include "zutil.h"
+#include "baseinfo.h"
+#include "get_str.h"
+#include <stdint.h>
+#include <string.h>
+
+char * wmpz_get_str(char * sp, int32_t base, wmpz_ptr u);
+
+#define ZGET_STR_H_INCLUDED
+#endif // ZGET_STR_H_INCLUDED
diff --git a/lib/zmul.c b/lib/zmul.c
index 222159a31c14d5bc44643d33044782853414a41e..b249e44680637dfaec1941bf33e95e25ae459ef0 100644
--- a/lib/zmul.c
+++ b/lib/zmul.c
@@ -1,45 +1,5 @@
-#include <stdlib.h>
+#include "zmul.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "power.h"
-
-#include "map.h"
-
-#include "c.h"
-
-#include "util.h"
-
-#include "utilold.h"
-
-#include "alias.h"
-
-#include "compare.h"
-
-#include "uint64gmp.h"
-
-#include "add.h"
-
-#include "sub.h"
-
-#include "mul.h"
-
-#include "toom.h"
-
-#include "abs.h"
-
-#include "z.h"
-
-#include "zutil.h"
-
-#include "int64.h"
-
-#include "set.h"
-
-#include "bool.h"
void wmpz_mul(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
wmpz_ptr u1, v1;
@@ -56,14 +16,17 @@ void wmpz_mul(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
int freew;
int32_t wsize1;
wmpz_ptr uqt, vqt, wqt;
- wmpz_ptr o;
+ wmpz_ptr nw;
+ __wmpz_struct t = { 0, 0, NULL };
uint64_t * wpqt;
uint64_t * wp1;
uint64_t * up1;
- wmpz_ptr o1;
+ wmpz_ptr nu;
+ __wmpz_struct t1 = { 0, 0, NULL };
uint64_t * wp2;
uint64_t * vp1;
- wmpz_ptr o2;
+ wmpz_ptr nv;
+ __wmpz_struct t2 = { 0, 0, NULL };
uint64_t * upqt;
uint64_t * vpqt;
uint64_t * wpqt1;
@@ -104,7 +67,7 @@ void wmpz_mul(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
cy = cy1;
}
wp[usize] = cy;
- usize = usize + (!(cy == UINT64_C(0)) ? 1 : 0);
+ usize = usize + !(cy == UINT64_C(0));
if (sign_product >= 0) {
wsize = usize;
} else {
@@ -121,16 +84,17 @@ void wmpz_mul(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
wqt = w;
if (ALLOC(w) < wsize1) {
freew = 1;
- o = __wmpz_init();
- wqt = o;
+ nw = &t;
+ __wmpz_init(nw);
+ wqt = nw;
wpqt = wmpz_realloc(wqt, wsize1);
(void)(wqt);
} else {
if (uw) {
wp1 = PTR(w);
up1 = alloca((uint32_t)usize * sizeof(uint64_t));
- o1 = __wmpz_init();
- uqt = o1;
+ nu = &t1;
+ uqt = nu;
ALLOC(uqt) = usize;
wmpn_copyi1(up1, wp1, usize);
PTR(uqt) = up1;
@@ -144,8 +108,8 @@ void wmpz_mul(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
if (vw) {
wp2 = PTR(w);
vp1 = alloca((uint32_t)vsize * sizeof(uint64_t));
- o2 = __wmpz_init();
- vqt = o2;
+ nv = &t2;
+ vqt = nv;
ALLOC(vqt) = vsize;
wmpn_copyi1(vp1, wp2, vsize);
PTR(vqt) = vp1;
@@ -164,8 +128,9 @@ void wmpz_mul(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
if (freew) {
wp3 = PTR(w);
free(wp3);
+ ALLOC(w) = wsize1;
}
- wsize1 = wsize1 - (cy2 == UINT64_C(0) ? 1 : 0);
+ wsize1 = wsize1 - (cy2 == UINT64_C(0));
wsize1 = sign_product < 0 ? -wsize1 : wsize1;
PTR(w) = wpqt1;
SIZ(w) = wsize1;
@@ -197,7 +162,7 @@ void wmpz_mul_si(wmpz_ptr prod, wmpz_ptr mult, int64_t small_mult) {
cy = cy1;
}
pp[size] = cy;
- size = size + (!(cy == UINT64_C(0)) ? 1 : 0);
+ size = size + !(cy == UINT64_C(0));
size = (sign_product < 0) ^ (small_mult < INT64_C(0)) ? -size : size;
SIZ(prod) = size;
(void)(prod);
@@ -226,10 +191,9 @@ void wmpz_mul_ui(wmpz_ptr prod, wmpz_ptr mult, uint64_t small_mult) {
cy = cy1;
}
pp[size] = cy;
- size = size + (!(cy == UINT64_C(0)) ? 1 : 0);
+ size = size + !(cy == UINT64_C(0));
size = sign_product < 0 ? -size : size;
SIZ(prod) = size;
(void)(prod);
return;
}
-
diff --git a/lib/zmul.h b/lib/zmul.h
index 157be4efbb8425bd7fd31225530c84b36636eb52..283988d4b00424bc835400520786e50f62fe2899 100644
--- a/lib/zmul.h
+++ b/lib/zmul.h
@@ -1,10 +1,20 @@
#ifndef ZMUL_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "util.h"
+#include "utilold.h"
+#include "alias.h"
+#include "compare.h"
+#include "uint64gmp.h"
+#include "add.h"
+#include "sub.h"
+#include "mul.h"
+#include "toom.h"
+#include "z.h"
+#include "zutil.h"
+#include "set.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
void wmpz_mul(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v);
void wmpz_mul_si(wmpz_ptr prod, wmpz_ptr mult, int64_t small_mult);
diff --git a/lib/zmul2exp.c b/lib/zmul2exp.c
index 3fbf6fbdd9e3a5d3b053063b903375c674b04b9a..bd7a9a59f2090849c46a454331f1c494ad92cd1e 100644
--- a/lib/zmul2exp.c
+++ b/lib/zmul2exp.c
@@ -1,41 +1,5 @@
-#include <stdlib.h>
+#include "zmul2exp.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "euclideandivision.h"
-
-#include "power.h"
-
-#include "map.h"
-
-#include "c.h"
-
-#include "util.h"
-
-#include "utilold.h"
-
-#include "alias.h"
-
-#include "compare.h"
-
-#include "uint64gmp.h"
-
-#include "types.h"
-
-#include "logicalutil.h"
-
-#include "logical.h"
-
-#include "logicalold.h"
-
-#include "abs.h"
-
-#include "z.h"
-
-#include "zutil.h"
void wmpz_mul2exp(wmpz_ptr r, wmpz_ptr u, uint64_t cnt) {
int32_t un, limb_cnt;
@@ -47,8 +11,6 @@ void wmpz_mul2exp(wmpz_ptr r, wmpz_ptr u, uint64_t cnt) {
uint64_t * rl1;
uint64_t rlimb1;
uint64_t * rl2;
- int32_t i;
- uint64_t lzero;
if (SIZ(u) >= 0) {
un = SIZ(u);
} else {
@@ -67,7 +29,7 @@ void wmpz_mul2exp(wmpz_ptr r, wmpz_ptr u, uint64_t cnt) {
rl = rp + limb_cnt;
rlimb = wmpn_lshift(rl, rp, un, c);
rp[rn] = rlimb;
- rn = rn + (!(rlimb == UINT64_C(0)) ? 1 : 0);
+ rn = rn + !(rlimb == UINT64_C(0));
} else {
wmpn_copyd(rp + limb_cnt, rp, un);
}
@@ -77,22 +39,16 @@ void wmpz_mul2exp(wmpz_ptr r, wmpz_ptr u, uint64_t cnt) {
rl1 = rp + limb_cnt;
rlimb1 = wmpn_lshift1(rl1, up, un, c);
rp[rn] = rlimb1;
- rn = rn + (!(rlimb1 == UINT64_C(0)) ? 1 : 0);
+ rn = rn + !(rlimb1 == UINT64_C(0));
} else {
rl2 = rp + limb_cnt;
wmpn_copyi1(rl2, up, un);
}
(void)(u);
}
- i = 0;
- lzero = UINT64_C(0);
- while (i < limb_cnt) {
- rp[i] = lzero;
- i = i + 1;
- }
+ wmpn_zero(rp, limb_cnt);
SIZ(r) = SIZ(u) >= 0 ? rn : -rn;
(void)(r);
return;
}
}
-
diff --git a/lib/zmul2exp.h b/lib/zmul2exp.h
index dc1cf73481aeb39ac5c4591769f92889efaf5f45..37d42fb927ad84fdc952f9c57cef2310c7387fcd 100644
--- a/lib/zmul2exp.h
+++ b/lib/zmul2exp.h
@@ -1,10 +1,18 @@
#ifndef ZMUL2EXP_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "util.h"
+#include "utilold.h"
+#include "alias.h"
+#include "compare.h"
+#include "uint64gmp.h"
+#include "logicalutil.h"
+#include "logical.h"
+#include "logicalold.h"
+#include "z.h"
+#include "zutil.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
void wmpz_mul2exp(wmpz_ptr r, wmpz_ptr u, uint64_t cnt);
#define ZMUL2EXP_H_INCLUDED
diff --git a/lib/zset_str.c b/lib/zset_str.c
new file mode 100644
index 0000000000000000000000000000000000000000..7a73b77e41dc37ae3880c927a35882dcbf3616fe
--- /dev/null
+++ b/lib/zset_str.c
@@ -0,0 +1,101 @@
+#include "zset_str.h"
+#include <stdint.h>
+#include <string.h>
+
+int32_t wmpz_set_str(wmpz_ptr r, char * sp, int32_t base) {
+ int32_t sign;
+ char * spi;
+ unsigned char * dp;
+ unsigned char digit;
+ int32_t dn;
+ char c;
+ uint32_t bits;
+ int32_t alloc, rn, rn1;
+ uint64_t * rp;
+ struct wmpn_base_info info;
+ int32_t alloc1, rn2, rn3, rn4;
+ uint64_t * rp1;
+ if (*sp == '-') {
+ sign = 1;
+ } else {
+ sign = 0;
+ }
+ spi = sp + sign;
+ if (*spi == '\0') {
+ SIZ(r) = 0;
+ return -1;
+ }
+ dp = alloca(strlen(sp) * sizeof(unsigned char));
+ digit = 0;
+ dn = 0;
+ while (!(*spi == '\0')) {
+ c = *spi;
+ if (36 < base) {
+ if ('0' <= c && c <= '9') {
+ digit = (unsigned char)(c - '0');
+ } else {
+ if ('a' <= c && c <= 'z') {
+ digit = (unsigned char)(c - 'a' + 36);
+ } else {
+ if ('A' <= c && c <= 'Z') {
+ digit = (unsigned char)(c - 'A' + 10);
+ } else {
+ digit = (unsigned char)base;
+ }
+ }
+ }
+ } else {
+ if ('0' <= c && c <= '9') {
+ digit = (unsigned char)(c - '0');
+ } else {
+ if ('a' <= c && c <= 'z') {
+ digit = (unsigned char)(c - 'a' + 10);
+ } else {
+ if ('A' <= c && c <= 'Z') {
+ digit = (unsigned char)(c - 'A' + 10);
+ } else {
+ digit = (unsigned char)base;
+ }
+ }
+ }
+ }
+ if (digit >= (unsigned char)base) {
+ SIZ(r) = 0;
+ return -1;
+ }
+ dp[dn] = digit;
+ dn = dn + 1;
+ spi = spi + 1;
+ }
+ if (dn == 0) {
+ SIZ(r) = 0;
+ return -1;
+ }
+ bits = wmpn_base_power_of_two_p((uint64_t)base);
+ if (bits > 0U) {
+ alloc = (dn * (int32_t)bits + 63) / 64;
+ rp = wmpz_realloc(r, alloc);
+ rn = wmpn_set_str_bits(rp, dp, (uint32_t)dn, bits);
+ if (!(sign == 0)) {
+ rn1 = -rn;
+ } else {
+ rn1 = rn;
+ }
+ SIZ(r) = rn1;
+ (void)(r);
+ } else {
+ info = wmpn_get_base_info((uint64_t)base);
+ alloc1 = (dn + (int32_t)info.exp - 1) / (int32_t)info.exp;
+ rp1 = wmpz_realloc(r, alloc1);
+ rn2 = wmpn_set_str_other(rp1, dp, (uint32_t)dn, (uint64_t)base, info);
+ rn3 = rn2 - (rp1[rn2 - 1] == UINT64_C(0));
+ if (!(sign == 0)) {
+ rn4 = -rn3;
+ } else {
+ rn4 = rn3;
+ }
+ SIZ(r) = rn4;
+ (void)(r);
+ }
+ return 0;
+}
diff --git a/lib/zset_str.h b/lib/zset_str.h
new file mode 100644
index 0000000000000000000000000000000000000000..a535160743bf36fa04292e7ad2e3858164140dcf
--- /dev/null
+++ b/lib/zset_str.h
@@ -0,0 +1,16 @@
+#ifndef ZSET_STR_H_INCLUDED
+
+#include "c.h"
+#include "uint64gmp.h"
+#include "util.h"
+#include "z.h"
+#include "zutil.h"
+#include "baseinfo.h"
+#include "set_str.h"
+#include <stdint.h>
+#include <string.h>
+
+int32_t wmpz_set_str(wmpz_ptr r, char * sp, int32_t base);
+
+#define ZSET_STR_H_INCLUDED
+#endif // ZSET_STR_H_INCLUDED
diff --git a/lib/zsub.c b/lib/zsub.c
index dab99a88f02de79b04d5719871dd14e47b05d119..dc3e96e779e6c50d528ea76226af9162dc3bae80 100644
--- a/lib/zsub.c
+++ b/lib/zsub.c
@@ -1,37 +1,5 @@
-#include <stdlib.h>
+#include "zsub.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-
-#include "power.h"
-
-#include "map.h"
-
-#include "c.h"
-
-#include "util.h"
-
-#include "alias.h"
-
-#include "compare.h"
-
-#include "uint64gmp.h"
-
-#include "add.h"
-
-#include "sub.h"
-
-#include "abs.h"
-
-#include "z.h"
-
-#include "zutil.h"
-
-#include "add_1.h"
-
-#include "sub_1.h"
void wmpz_sub(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
wmpz_ptr u1, v1;
@@ -103,12 +71,7 @@ void wmpz_sub(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
}
}
wsize = abs_usize;
- while (wsize > 0) {
- if (!(wp[wsize - 1] == UINT64_C(0))) {
- break;
- }
- wsize = wsize - 1;
- }
+ normalize(wp, &wsize);
if (usize < 0) {
wsize = -wsize;
}
@@ -118,23 +81,13 @@ void wmpz_sub(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
vp2 = PTR(v1);
if (wmpn_cmp(wp, vp2, abs_usize) < 0) {
usb3 = sub_n_ry(vp2, wp, abs_usize);
- while (wsize > 0) {
- if (!(wp[wsize - 1] == UINT64_C(0))) {
- break;
- }
- wsize = wsize - 1;
- }
+ normalize(wp, &wsize);
if (usize >= 0) {
wsize = -wsize;
}
} else {
usb4 = sub_n_rx(wp, vp2, abs_usize);
- while (wsize > 0) {
- if (!(wp[wsize - 1] == UINT64_C(0))) {
- break;
- }
- wsize = wsize - 1;
- }
+ normalize(wp, &wsize);
if (usize < 0) {
wsize = -wsize;
}
@@ -145,23 +98,13 @@ void wmpz_sub(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
up2 = PTR(u1);
if (wmpn_cmp(up2, wp, abs_usize) < 0) {
usb5 = sub_n_rx(wp, up2, abs_usize);
- while (wsize > 0) {
- if (!(wp[wsize - 1] == UINT64_C(0))) {
- break;
- }
- wsize = wsize - 1;
- }
+ normalize(wp, &wsize);
if (usize >= 0) {
wsize = -wsize;
}
} else {
usb6 = sub_n_ry(up2, wp, abs_usize);
- while (wsize > 0) {
- if (!(wp[wsize - 1] == UINT64_C(0))) {
- break;
- }
- wsize = wsize - 1;
- }
+ normalize(wp, &wsize);
if (usize < 0) {
wsize = -wsize;
}
@@ -172,23 +115,13 @@ void wmpz_sub(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v) {
vp3 = PTR(v1);
if (wmpn_cmp(up3, vp3, abs_usize) < 0) {
usb7 = sub_n(wp, vp3, up3, abs_usize);
- while (wsize > 0) {
- if (!(wp[wsize - 1] == UINT64_C(0))) {
- break;
- }
- wsize = wsize - 1;
- }
+ normalize(wp, &wsize);
if (usize >= 0) {
wsize = -wsize;
}
} else {
usb8 = sub_n(wp, up3, vp3, abs_usize);
- while (wsize > 0) {
- if (!(wp[wsize - 1] == UINT64_C(0))) {
- break;
- }
- wsize = wsize - 1;
- }
+ normalize(wp, &wsize);
if (usize < 0) {
wsize = -wsize;
}
@@ -245,7 +178,7 @@ void wmpz_sub_ui(wmpz_ptr w, wmpz_ptr u, uint64_t v) {
if (usize == 0) {
wp = PTR(w);
*wp = v;
- SIZ(w) = -(!(v == UINT64_C(0)) ? 1 : 0);
+ SIZ(w) = -(!(v == UINT64_C(0)));
(void)(w);
return;
}
@@ -277,7 +210,7 @@ void wmpz_sub_ui(wmpz_ptr w, wmpz_ptr u, uint64_t v) {
wsize = -1;
} else {
wmpn_sub_1_in_place(wp1, abs_usize, v);
- wsize = abs_usize - (wp1[abs_usize - 1] == UINT64_C(0) ? 1 : 0);
+ wsize = abs_usize - (wp1[abs_usize - 1] == UINT64_C(0));
}
} else {
up1 = PTR(u);
@@ -286,7 +219,7 @@ void wmpz_sub_ui(wmpz_ptr w, wmpz_ptr u, uint64_t v) {
wsize = -1;
} else {
wmpn_sub_1(wp1, up1, abs_usize, v);
- wsize = abs_usize - (wp1[abs_usize - 1] == UINT64_C(0) ? 1 : 0);
+ wsize = abs_usize - (wp1[abs_usize - 1] == UINT64_C(0));
}
(void)(u);
}
@@ -319,7 +252,7 @@ void wmpz_ui_sub(wmpz_ptr w, uint64_t uval, wmpz_ptr v) {
wmpn_sub_1(wp, vp, vsize, uval);
(void)(v);
}
- wsize = -(vsize - (wp[vsize - 1] == UINT64_C(0) ? 1 : 0));
+ wsize = -(vsize - (wp[vsize - 1] == UINT64_C(0)));
SIZ(w) = wsize;
(void)(w);
return;
@@ -329,7 +262,7 @@ void wmpz_ui_sub(wmpz_ptr w, uint64_t uval, wmpz_ptr v) {
if (vw) {
if (uval >= *wp1) {
*wp1 = uval - *wp1;
- wsize = !(*wp1 == UINT64_C(0)) ? 1 : 0;
+ wsize = !(*wp1 == UINT64_C(0));
} else {
*wp1 = *wp1 - uval;
wsize = -1;
@@ -338,7 +271,7 @@ void wmpz_ui_sub(wmpz_ptr w, uint64_t uval, wmpz_ptr v) {
vp1 = PTR(v);
if (uval >= *vp1) {
*wp1 = uval - *vp1;
- wsize = !(*wp1 == UINT64_C(0)) ? 1 : 0;
+ wsize = !(*wp1 == UINT64_C(0));
} else {
*wp1 = *vp1 - uval;
wsize = -1;
@@ -352,7 +285,7 @@ void wmpz_ui_sub(wmpz_ptr w, uint64_t uval, wmpz_ptr v) {
if (vsize == 0) {
wp2 = PTR(w);
*wp2 = uval;
- wsize = !(uval == UINT64_C(0)) ? 1 : 0;
+ wsize = !(uval == UINT64_C(0));
SIZ(w) = wsize;
(void)(w);
return;
@@ -362,12 +295,12 @@ void wmpz_ui_sub(wmpz_ptr w, uint64_t uval, wmpz_ptr v) {
if (vw) {
cy = wmpn_add_1_in_place(wp3, vsize, uval);
wp3[vsize] = cy;
- wsize = vsize + (!(cy == UINT64_C(0)) ? 1 : 0);
+ wsize = vsize + !(cy == UINT64_C(0));
} else {
vp2 = PTR(v);
cy1 = wmpn_add_1(wp3, vp2, vsize, uval);
wp3[vsize] = cy1;
- wsize = vsize + (!(cy1 == UINT64_C(0)) ? 1 : 0);
+ wsize = vsize + !(cy1 == UINT64_C(0));
(void)(v);
}
SIZ(w) = wsize;
@@ -377,4 +310,3 @@ void wmpz_ui_sub(wmpz_ptr w, uint64_t uval, wmpz_ptr v) {
}
}
}
-
diff --git a/lib/zsub.h b/lib/zsub.h
index 27e415c0673585fb7b0bd86b002b8c3e840d3830..b58f71cc11d61797042a6dca708db0771527e37d 100644
--- a/lib/zsub.h
+++ b/lib/zsub.h
@@ -1,10 +1,18 @@
#ifndef ZSUB_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "util.h"
+#include "alias.h"
+#include "compare.h"
+#include "uint64gmp.h"
+#include "add.h"
+#include "sub.h"
+#include "z.h"
+#include "zutil.h"
+#include "add_1.h"
+#include "sub_1.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
+
void wmpz_sub(wmpz_ptr w, wmpz_ptr u, wmpz_ptr v);
void wmpz_sub_ui(wmpz_ptr w, wmpz_ptr u, uint64_t v);
diff --git a/lib/zutil.c b/lib/zutil.c
index 18118c91f526a5bae97235fadfa14b763304be5f..ea3afebb539c4c906d49af2bc5999e88ea48714a 100644
--- a/lib/zutil.c
+++ b/lib/zutil.c
@@ -1,39 +1,17 @@
-#include <stdlib.h>
+#include "zutil.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-#include "int.h"
-#include "abs.h"
-
-#include "int32.h"
-
-#include "c.h"
-
-#include "map.h"
-
-#include "types.h"
-
-#include "uint64gmp.h"
-
-#include "power.h"
-
-#include "z.h"
-
-
-wmpz_ptr __wmpz_init () {
-wmpz_ptr x = malloc(sizeof(__wmpz_struct));
-ALLOC(x) = 1;
-SIZ(x) = 0;
-PTR(x) = malloc(sizeof(uint64_t));
-PTR(x)[0] = 0;
-return x;
+void __wmpz_init (wmpz_ptr x) {
+ ALLOC(x) = 1;
+ SIZ(x) = 0;
+ PTR(x) = malloc(sizeof(uint64_t));
+ PTR(x)[0] = 0;
+ return;
}
void wmpz_clear (wmpz_ptr x)
{
-free (PTR(x));
+ free (PTR(x));
}
uint64_t * wmpz_do_realloc(wmpz_ptr x, int32_t sz) {
@@ -54,11 +32,3 @@ uint64_t * wmpz_realloc(wmpz_ptr x, int32_t sz) {
return PTR(x);
}
}
-
-void mpz_ptr_swap(wmpz_ptr * x, wmpz_ptr * y) {
- wmpz_ptr z;
- z = *x;
- *x = *y;
- *y = z;
-}
-
diff --git a/lib/zutil.h b/lib/zutil.h
index 41152a93884787cebc88939e860e2a8cbdb7a4cd..031604280456db5c9b257b8f07b132bab1b89f66 100644
--- a/lib/zutil.h
+++ b/lib/zutil.h
@@ -1,19 +1,16 @@
#ifndef ZUTIL_H_INCLUDED
-#include <stdlib.h>
+#include "c.h"
+#include "uint64gmp.h"
+#include "z.h"
#include <stdint.h>
-#include <stdio.h>
-#include <assert.h>
-#include <alloca.h>
-wmpz_ptr __wmpz_init ();
-void wmpz_clear (wmpz_ptr x);
+void __wmpz_init (wmpz_ptr);
+void wmpz_clear (wmpz_ptr);
uint64_t * wmpz_do_realloc(wmpz_ptr x, int32_t sz);
uint64_t * wmpz_realloc(wmpz_ptr x, int32_t sz);
-void mpz_ptr_swap(wmpz_ptr * x, wmpz_ptr * y);
-
#define ZUTIL_H_INCLUDED
#endif // ZUTIL_H_INCLUDED
diff --git a/why3 b/why3
index 430a6a362838ae773b2cad1adcdf704278fcbe7e..226ba5b0f0777654d637b1b88006ab54c46a31a2 160000
--- a/why3
+++ b/why3
@@ -1 +1 @@
-Subproject commit 430a6a362838ae773b2cad1adcdf704278fcbe7e
+Subproject commit 226ba5b0f0777654d637b1b88006ab54c46a31a2
diff --git a/wmp-gmp.h b/wmp-gmp.h
index d41c87a64f2d92a5da9dac87b77f742f922e19bd..8c38efa76d83379727aa8de201fe2c9fce2f16c2 100644
--- a/wmp-gmp.h
+++ b/wmp-gmp.h
@@ -1,7 +1,7 @@
#ifndef __WMP_H__
#include <gmp.h>
-#include <wmp.h>
+#include "wmp.h"
#undef mpn_add
#undef mpn_add_1
@@ -11,12 +11,14 @@
#undef mpn_copyd
#undef mpn_copyi
#undef mpn_divrem_1
+#undef mpn_get_str
#undef mpn_lshift
#undef mpn_mul
#undef mpn_mul_1
#undef mpn_mul_n
#undef mpn_powm
#undef mpn_rshift
+#undef mpn_set_str
#undef mpn_sqrtrem
#undef mpn_sub
#undef mpn_sub_1
@@ -26,11 +28,16 @@
#undef mpn_zero
#undef mpn_zero_p
+#undef mpz_abs
#undef mpz_add
#undef mpz_add_ui
#undef mpz_clear
#undef mpz_cmp
+#undef mpz_cmp_si
#undef mpz_cmp_ui
+#undef mpz_cmpabs
+#undef mpz_cmpabs_ui
+#undef mpz_get_str
#undef mpz_get_ui
#undef mpz_init
#undef mpz_mul
@@ -39,10 +46,14 @@
#undef mpz_mul_ui
#undef mpz_realloc
#undef mpz_set_si
+#undef mpz_set_str
#undef mpz_set_ui
+#undef mpz_sgn
#undef mpz_sub
#undef mpz_sub_ui
#undef mpz_tdiv_q_2exp
+#undef mpz_tdiv_qr
+#undef mpz_tdiv_qr_ui
#undef mpz_ui_sub
#define mpn_add wmpn_add
@@ -53,12 +64,14 @@
#define mpn_copyd wmpn_copyd
#define mpn_copyi wmpn_copyi
#define mpn_divrem_1 wmpn_divrem_1
+#define mpn_get_str wmpn_get_str
#define mpn_lshift wmpn_lshift
#define mpn_mul wmpn_mul
#define mpn_mul_1 wmpn_mul_1
#define mpn_mul_n wmpn_mul_n
#define mpn_powm wmpn_powm
#define mpn_rshift wmpn_rshift
+#define mpn_set_str wmpn_set_str
#define mpn_sqrtrem wmpn_sqrtrem
#define mpn_sub wmpn_sub
#define mpn_sub_1 wmpn_sub_1
@@ -68,11 +81,16 @@
#define mpn_zero wmpn_zero
#define mpn_zero_p wmpn_zero_p
+#define mpz_abs wmpz_abs
#define mpz_add wmpz_add
#define mpz_add_ui wmpz_add_ui
#define mpz_clear wmpz_clear
#define mpz_cmp wmpz_cmp
+#define mpz_cmp_si wmpz_cmp_si
#define mpz_cmp_ui wmpz_cmp_ui
+#define mpz_cmpabs wmpz_cmpabs
+#define mpz_cmpabs_ui wmpz_cmpabs_ui
+#define mpz_get_str wmpz_get_str
#define mpz_get_ui wmpz_get_ui
#define mpz_init wmpz_init
#define mpz_mul wmpz_mul
@@ -81,10 +99,14 @@
#define mpz_mul_ui wmpz_mul_ui
#define mpz_realloc wmpz_realloc
#define mpz_set_si wmpz_set_si
+#define mpz_set_str wmpz_set_str
#define mpz_set_ui wmpz_set_ui
+#define mpz_sgn wmpz_sgn
#define mpz_sub wmpz_sub
#define mpz_sub_ui wmpz_sub_ui
#define mpz_tdiv_q_2exp wmpz_tdiv_q_2exp
+#define mpz_tdiv_qr wmpz_tdiv_qr
+#define mpz_tdiv_qr_ui wmpz_tdiv_qr_ui
#define mpz_ui_sub wmpz_ui_sub
#endif
diff --git a/wmp.h b/wmp.h
index 4c7612d966526c68761f965003c2f82c748721af..c791a7f900e24024c074add7501dda71c9497251 100644
--- a/wmp.h
+++ b/wmp.h
@@ -1,6 +1,7 @@
#ifndef __WMP_H__
#define __WMP_H__
+#include <stdlib.h>
#include <stdint.h>
typedef int32_t wmp_size_t;
@@ -39,13 +40,21 @@ void wmpz_set_ui (wmpz_ptr, uint64_t);
void wmpz_set_si (wmpz_ptr, int64_t);
uint64_t wmpz_get_ui (wmpz_srcptr);
-int32_t wmpz_cmp (wmpz_srcptr, wmpz_ptr);
+int32_t wmpz_cmp (wmpz_srcptr, wmpz_srcptr);
int32_t wmpz_cmp_ui (wmpz_srcptr, uint64_t);
+int32_t wmpz_cmp_si(wmpz_srcptr, int64_t);
-void wmpz_add (wmpz_ptr, wmpz_srcptr, wmpz_ptr);
+int32_t wmpz_cmpabs(wmpz_srcptr, wmpz_srcptr);
+int32_t wmpz_cmpabs_ui(wmpz_srcptr, uint64_t);
+
+int32_t wmpz_sgn(wmpz_srcptr);
+
+void wmpz_abs(wmpz_ptr, wmpz_srcptr);
+
+void wmpz_add (wmpz_ptr, wmpz_srcptr, wmpz_srcptr);
void wmpz_add_ui (wmpz_ptr, wmpz_srcptr, uint64_t);
-void wmpz_sub (wmpz_ptr, wmpz_srcptr, wmpz_ptr);
+void wmpz_sub (wmpz_ptr, wmpz_srcptr, wmpz_srcptr);
void wmpz_sub_ui (wmpz_ptr, wmpz_srcptr, uint64_t);
void wmpz_ui_sub (wmpz_ptr, uint64_t, wmpz_srcptr);
@@ -56,6 +65,11 @@ void wmpz_mul_ui (wmpz_ptr, wmpz_srcptr, uint64_t);
void wmpz_mul2exp (wmpz_ptr, wmpz_srcptr, uint64_t);
void wmpz_tdiv_q_2exp (wmpz_ptr, wmpz_srcptr, uint64_t);
+void wmpz_tdiv_qr (wmpz_ptr quot, wmpz_ptr rem, wmpz_srcptr, wmpz_srcptr);
+uint64_t wmpz_tdiv_qr_ui (wmpz_ptr quot, wmpz_ptr rem, wmpz_srcptr, uint64_t);
+
+char *wmpz_get_str (char *, int32_t base, wmpz_srcptr);
+int32_t wmpz_set_str (wmpz_ptr, char const *, int32_t base);
int32_t wmpn_cmp (wmp_srcptr, wmp_srcptr, wmp_size_t);
@@ -96,6 +110,9 @@ void wmpn_tdiv_qr (wmp_ptr qp, wmp_ptr rp, wmp_size_t qxn, wmp_srcptr np,
// not verified when rp and np are aliased.
wmp_size_t wmpn_sqrtrem (wmp_ptr sp, wmp_ptr rp, wmp_srcptr np, wmp_size_t);
+wmp_size_t wmpn_get_str (unsigned char *, int32_t base, wmp_srcptr, wmp_size_t);
+wmp_size_t wmpn_set_str (wmp_ptr, unsigned char const *, size_t, int32_t base);
+
#ifdef __cplusplus
}
#endif