+#include "cell.h"
+#include "index.h"
+#include "IMap.h"
+
+namespace iProlog {
+
+ // https://stackoverflow.com/questions/108318/how-can-i-test-whether-a-number-is-a-power-of-2)
+
+ bool is_a_power_of_2(int size) {
+ return size > 0 && (size & (size - 1)) == 0;
+ }
+
+ IntSet *IntSet::init(IntSet* isp) {
+ int capacity = arraySize(init_cap, m_fillFactor_pc);
+
+ isp->set_mask(capacity);
+ isp->m_data = isp->alloc(capacity);
+ isp->m_threshold = (capacity * m_fillFactor_pc) / 100;
+ isp->m_size = 0;
+
+ return isp;
+ }
+
+ void IntSet::dealloc(IntSet* isp) {
+ if (isp == nullptr) abort();
+ isp->md_free(isp->m_data);
+ free((void*)isp);
+ }
+
+ IntSet::IntSet() {
+
+ assert(is_a_power_of_2(init_cap));
+
+ init(this);
+ }
+
+ void IntSet::rehash(size_t newCapacity) {
+#define TR if(0)
+ TR cout << " !!!!!!!!!!!!! calling rehash, newCapacity="
+ << to_string(newCapacity) << " !!!!!!!!!!!!!!!!!!" << endl;
+ m_threshold = (int)(newCapacity * ((float)m_fillFactor_pc/100));
+ set_mask(newCapacity);
+
+ TR cout << " m_mask is now " << m_mask << endl;
+
+ size_t oldCapacity = length();
+ Vec oldData = m_data;
+
+ TR for (int i = 0; i < oldCapacity; i++)
+ cout << " oldData[" << i << "].key=" << oldData[i].key
+ << " oldData[i].val=" << oldData[i].val << endl;
+
+ m_data = alloc(newCapacity); // sets md_capacity = newCapacity
+ m_size = m_hasFreeKey ? 1 : 0;
+
+ for (int i = 0; i < oldCapacity; i++) {
+ int oldKey = oldData[i].key;
+ if (oldKey != FREE_KEY) {
+ put(oldKey, oldData[i].val);
+ assert(contains(oldKey));
+ }
+ }
+ md_free(oldData);
+#undef TR
+ }
+
+ int IntSet::get(int key) const {
+#define TR if(0)
+ int ptr = mk_ptr(key);
+
+ TR cout << " IntSet::get(" << key << "), ptr="
+ << ptr << endl;
+
+ if (key == FREE_KEY) {
+ int r = m_hasFreeKey ? m_freeValue : NO_VALUE;
+ TR cout << " key==FREE_KEY m_hasFreeKey=" << m_hasFreeKey << endl;
+ return r;
+ }
+ int k = get_key_at(ptr);
+
+ if (k == FREE_KEY) {
+ // TR cout << " k==m_data[" << ptr << "]==" << k << " == FREE_KEY" << ", m_data[ptr + 1] = " << m_data[ptr + 1] << endl;
+ return NO_VALUE; //end of chain already
+ }
+
+ if (k == key) { //we check FREE prior to this call
+ // TR cout << " k==key, returning m_data[" << ptr + 1 << "]=" << m_data[ptr + 1] << endl;
+ return get_val_at(ptr);
+ }
+
+ while (true) {
+ // cout << "get loop" << endl;
+ ptr = next(ptr);
+ k = get_key_at(ptr);
+ if (k == FREE_KEY) {
+ // TR cout << " k=get_key_at(" << ptr << ")==FREE_KEY " << FREE_KEY << " m_data[ptr+1]="<< m_data[ptr+1] << endl;
+ return NO_VALUE;
+ }
+ if (k == key) {
+ TR cout << " k==key at end of chain==" << k << endl;
+ return get_val_at(ptr);
+ }
+ }
+#undef TR
+ }
+
+ int IntSet::put(int key, int value) {
+#define TR if(0)
+ TR cout << endl
+ << " IntSet::put(key=" << to_string(key)
+ << ", value=" << to_string(value) << ")"
+ << " md_capacity=" << to_string(md_capacity)
+ << " m_size()=" << to_string(m_size)
+ << " m_threshold=" << to_string(m_threshold)
+ << endl;
+
+ if (key == FREE_KEY) {
+ int ret = m_freeValue;
+ if (!m_hasFreeKey) {
+ ++m_size;
+ }
+ m_hasFreeKey = true;
+ m_freeValue = value;
+ TR cout << " (1) key == FREE_KEY, returning " << ret << endl;
+ return ret;
+ }
+
+ int ptr = mk_ptr(key);
+ int k = get_key_at(ptr); // m_data[ptr];
+ if (k == FREE_KEY) //end of chain already
+ {
+ set_key_at(ptr,key);
+ set_val_at(ptr,value);
+ if (m_size >= m_threshold) {
+ TR cout << "**** about to call rehash, m_size=" << m_size << " m_threshold=" << m_threshold << endl;
+ // TR cout << "**** m_data.capacity()=" << m_data.capacity() << endl;
+ rehash(length() * 2); //size is set inside
+ }
+ else {
+ ++m_size;
+ }
+ TR cout << " (2) k == FREE_KEY, returning NO_VALUE" << endl;
+ return NO_VALUE;
+ }
+ else if (k == key) //we check FREE prior to this call
+ {
+ int ret = get_val_at(ptr);
+ set_val_at(ptr, value);
+ TR cout << " (3) k == key, get_val_at(ptr)<-value==" << get_val_at(ptr) << " returning past value " << ret << endl;
+ return ret;
+ }
+
+ int count = 0;
+ while (true) {
+ TR cout << "ptr=" << to_string(ptr) << endl;
+ ptr = next(ptr);
+ k = get_key_at(ptr);
+ TR cout << "k=" << k << endl;
+ if (k == FREE_KEY) {
+ set_key_at(ptr, key);
+ set_val_at(ptr, value);
+ if (m_size >= m_threshold) {
+ TR cout << " needing to rehash" << endl;
+ rehash(length() * 2); //size is set inside
+ }
+ else {
+ ++m_size;
+ }
+ TR cout << " (4) at end of chain, returning NO_VALUE" << endl;
+ return NO_VALUE;
+ }
+ else if (k == key) {
+ int ret = get_val_at(ptr);
+ set_val_at(ptr, value);
+ TR cout << " (5) found something, returning " << ret << endl;
+ return ret;
+ }
+ }
+ }
+
+#if 0 // not called
+ int IntSet::remove(int key) {
+ if (key == FREE_KEY) {
+ if (!m_hasFreeKey)
+ return NO_VALUE;
+ m_hasFreeKey = false;
+ --m_size;
+ return m_freeValue; //value is not cleaned
+ }
+
+ int ptr = mk_ptr(key);
+ int k = get_key_at(ptr);
+ if (k == key) //we check FREE prior to this call
+ {
+ int res = get_val_at(ptr);
+ shiftKeys(ptr);
+ --m_size;
+ return res;
+ }
+ else if (k == FREE_KEY)
+ return NO_VALUE; //end of chain already
+ while (true) {
+ ptr = next(ptr);
+ k = get_key_at(ptr);
+ if (k == key) {
+ int res = get_val_at(ptr);
+ shiftKeys(ptr);
+ --m_size;
+ return res;
+ }
+ else if (k == FREE_KEY)
+ return NO_VALUE;
+ }
+ }
+
+ int IntSet::shiftKeys(int pos) {
+ // Shift entries with the same hash.
+ int last, slot;
+ int k;
+
+ while (true) {
+ cout << "shiftkeys loop" << endl;
+ last = pos;
+ pos = next(last);
+ while (true) {
+ cout << "shiftKeys subloop";
+ k = get_key_at(pos);
+ if (k == FREE_KEY) {
+ set_key_at(last,FREE_KEY);
+ return last;
+ }
+ slot = mk_ptr(k); //calculate the starting slot for the current key
+ if (last <= pos ? last >= slot || slot > pos : last >= slot && slot > pos) {
+ break;
+ }
+ pos = next(pos);
+ }
+ set_key_at(last) = k;
+ set_val_at(last, get_val_at(pos));
+ }
+ }
+#endif
+
+ /** Taken from FastUtil implementation */
+
+/** Return the least power of two greater than or equal to the specified value.
+ *
+ * Note that this function will return 1 when the argument is 0.
+ *
+ * @param x a long integer smaller than or equal to 262.
+ * @return the least power of two greater than or equal to the specified value.
+ */
+ long IntSet::nextPowerOfTwo(long x) {
+ if (x == 0)
+ return 1;
+ x--;
+ x |= x >> 1;
+ x |= x >> 2;
+ x |= x >> 4;
+ x |= x >> 8;
+ x |= x >> 16;
+ return (x | x >> 32) + 1;
+ }
+
+ // always init with size = 2^n for n >= 0
+
+ /** Returns the least power of two smaller than or equal to 230
+ * and larger than or equal to Math.ceil( expected / f ).
+ *
+ * @param expected the expected number of elements in a hash table.
+ * @param f the load factor.
+ * @return the minimum possible size for a backing array.
+ * @throws IllegalArgumentException if the necessary size is larger than 230.
+ */
+ int IntSet::arraySize(int expected, int f_pc) {
+ long s = std::max(2L, IntSet::nextPowerOfTwo((long)ceil(expected / ((float) f_pc/100))));
+ if (s > 1 << 30) {
+ string emsg = "Too large " + expected;
+ // emsg += " expected elements with load factor " + f;
+ throw new logic_error(emsg);
+ }
+ return (int)s;
+ }
+
+ // @Override
+string IntSet::show() const {
+ //return java.util.Arrays.toString(m_data);
+ string b = "{";
+ size_t l = md_capacity;
+ // cout << "IntSet::show() md_capacity=" << to_string(md_capacity) << endl;
+ bool first = true;
+ for (int i = 0; i < l; i++) {
+ int v = get_key_at(i);
+ if (v != FREE_KEY) {
+ if (!first) {
+ b += ", ";
+ }
+ first = false;
+#if 0
+ b += "[" + to_string(i);
+ b += "]:#";
+#endif
+ b += to_string(v);
+#if 0
+ b += "->" + to_string(get_val_at(i));
+#endif
+ }
+ }
+ b += "}";
+ return b;
+}
+}
\ No newline at end of file
diff --git a/IP/cpp/iProlog/IntSet.h b/IP/cpp/iProlog/IntSet.h
new file mode 100644
index 00000000..7fcd3c71
--- /dev/null
+++ b/IP/cpp/iProlog/IntSet.h
@@ -0,0 +1,139 @@
+#pragma once
+
+/* "for use as IntSet" - Paul Tarau
+ * iProlog / C++ [derived from Java version]
+ * Original (Java) author: Mikhail Vorontsov
+ * License: public domain
+ * https://github.com/mikvor/hashmapTest/blob/master/LICENSE
+ * Java code modified by Paul Tarau
+ *
+ * derived from code at https://github.com/mikvor/hashmapTest
+ *
+ * Article by Vorontsov:
+ * https://web.archive.org/web/20170606024914/http://java-performance.info/implementing-world-fastest-java-int-to-int-hash-map/
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include "defs.h"
+
+#include
+
+#include "IMap.h"
+
+namespace iProlog {
+ class is_bucket {
+ public:
+ int key;
+ int val;
+ };
+
+ typedef is_bucket* Vec;
+
+ using namespace std;
+
+ // For short logic programs, these are already pretty bulky
+ // compared to their actual indexing maps.
+ // Parameterizing for different kinds of maps
+ // has an additional cost.
+ // Unsatisfactory, but solvable with C++ "concept"?
+ // If I stick with m_data size = 2^n, what are now some per-instance
+ // members could be separated into a "hash table header" class
+ // and each could have an index into a table of these.
+
+ class IntSet {
+ private:
+
+ static const int FREE_KEY = 0;
+ static const int NO_VALUE = 0;
+
+ static const int init_cap = (1 << 2);
+
+ /** Fill factor, must be between (0 and 100) */
+ static const int m_fillFactor_pc = 75;
+ /** We will resize a map once it reaches this size */
+ int m_threshold;
+
+ /** Keys and values */
+ Vec m_data;
+
+ private:
+ /** Do we have 'free' key in the map? */
+ bool m_hasFreeKey;
+ /** Value of 'free' key */
+ int m_freeValue;
+
+ /** Current map size */
+ int m_size;
+
+ /** Mask to calculate the original position */
+ int m_mask;
+
+ /** number of elts if ever full */
+ size_t md_capacity;
+
+ public:
+ IntSet();
+ ~IntSet() { md_free(m_data); }
+
+ inline static int no_value() { return NO_VALUE; }
+ inline size_t length() const { return md_capacity; }
+
+ inline bool is_free(int i) const { return m_data[i].key == FREE_KEY; }
+ inline int get_key_at(int i) const { return m_data[i].key; }
+ inline void set_key_at(int i, int v) { m_data[i].key = v; }
+ inline int get_val_at(int i) const { return m_data[i].val; }
+ inline void set_val_at(int i, int v) { m_data[i].val = v; }
+
+ inline bool contains(int key) const { return NO_VALUE != get(key); }
+ inline bool add_key(int key) { return NO_VALUE != put(key, 666); }
+ // inline bool delete_(int key) { return NO_VALUE != remove(key); }
+ inline bool isEmpty() const { return 0 == m_size; }
+ inline int size() const { return m_size; }
+
+ static IntSet* alloc_intset() { return (IntSet*)malloc(sizeof(IntSet)); }
+ static IntSet* init(IntSet *isp);
+ static void dealloc(IntSet* isp);
+
+ int get(int key) const;
+ int put(int key, int value);
+ // int remove(int key);
+ private:
+ inline void md_free(Vec vs) {
+ free(vs);
+ }
+ inline int wraparound(int i) const { return i & m_mask; }
+ inline int next(int ptr) const { return wraparound(ptr+1); }
+ inline void set_mask(int cap) { m_mask = cap - 1; }
+ inline int mk_ptr(int key) const { return (phiMix(key) & m_mask); }
+
+ inline Vec alloc(int cap) {
+ md_capacity = cap;
+ size_t sz = cap * sizeof(is_bucket);
+ void* p = malloc(sz);
+ memset(p, 0, sz);
+ return (Vec) p;
+ }
+
+ static long nextPowerOfTwo(long x);
+ static int arraySize(int expected, int f_pc);
+ int shiftKeys(int pos);
+ void rehash(size_t newCapacity);
+
+ //taken from FastUtil
+ static const int INT_PHI = 0x9E3779B9;
+
+ inline int phiMix(int x) const {
+ int h = x * INT_PHI;
+ return h ^ h >> 16;
+ }
+
+ public:
+ string show() const;
+ };
+}
\ No newline at end of file
diff --git a/IP/cpp/iProlog/Inty.h b/IP/cpp/iProlog/Inty.h
new file mode 100644
index 00000000..1f211b2d
--- /dev/null
+++ b/IP/cpp/iProlog/Inty.h
@@ -0,0 +1,29 @@
+#pragma once
+
+/* Inty -- for stronger typing in an "ints all the way down" datastructure
+ *
+ * It may make sense to make it a template class, so that there can
+ * be int16, int32, int64 in places where it matters for speed/space,
+ * even varying according to use in data structures.
+ */
+
+namespace iProlog {
+ template class Inty {
+ private:
+ int_type i;
+ public:
+
+ inline Inty() { i = 0; }
+ Inty(int_type x) : Inty() { i = x; }
+
+ inline int_type as_int() const { return i; }
+ inline bool operator == (Inty x) const { return i == x.as_int(); }
+ inline bool operator != (Inty x) const { return i != x.as_int(); }
+ inline Inty dec() const { return Inty(i - 1); }
+ // inline Inty& operator =(const Inty& x) { i = x.as_int(); return *this; }
+ inline void operator =(const Inty& x) { i = x.as_int(); }
+ inline bool operator<(const Inty& x) const { return i < x.as_int(); }
+ inline bool operator>(const Inty& x) const { return i > x.as_int(); }
+ };
+
+} // namespace
\ No newline at end of file
diff --git a/IP/cpp/iProlog/Object.cpp b/IP/cpp/iProlog/Object.cpp
new file mode 100644
index 00000000..9af5c0b8
--- /dev/null
+++ b/IP/cpp/iProlog/Object.cpp
@@ -0,0 +1,28 @@
+
+#include "Object.h"
+
+namespace iProlog {
+
+ using namespace std;
+
+ string Object::toString() const {
+ switch (type) {
+ case e_nullptr:
+ return "$null";
+ case e_integer:
+ return to_string(i);
+ case e_string:
+ return s;
+ case e_vector: {
+ string j;
+ for (auto a : v) {
+ if (!j.empty())
+ j += ",";
+ j += a.toString();
+ }
+ return "(" + j + ")";
+ }
+ }
+ throw logic_error("invalid term");
+ }
+} // end namespace
diff --git a/IP/cpp/iProlog/Object.h b/IP/cpp/iProlog/Object.h
new file mode 100644
index 00000000..b8fcce21
--- /dev/null
+++ b/IP/cpp/iProlog/Object.h
@@ -0,0 +1,31 @@
+#pragma once
+// not sure how derivative of iProlog this is
+#include
+#include
+#include "defs.h"
+
+namespace iProlog {
+
+ using namespace std;
+
+ struct Object {
+ enum { e_nullptr, e_integer, e_string, e_vector } type;
+ int i;
+ string s;
+ vector