package doglet;
import nova.*;
import java.math.BigInteger;
import java.util.*;
import java.util.function.BiFunction;
import java.util.function.Function;
/**
* Warranty & Liability
* To the extent permitted by applicable law and unless explicitly
* otherwise agreed upon, XLOG Technologies AG makes no warranties
* regarding the provided information. XLOG Technologies AG assumes
* no liability that any problems might be solved with the information
* provided by XLOG Technologies AG.
*
* Rights & License
* All industrial property rights regarding the information - copyright
* and patent rights in particular - are the sole property of XLOG
* Technologies AG. If the company was not the originator of some
* excerpts, XLOG Technologies AG has at least obtained the right to
* reproduce, change and translate the information.
*
* Reproduction is restricted to the whole unaltered document. Reproduction
* of the information is only allowed for non-commercial uses. Selling,
* giving away or letting of the execution of the library is prohibited.
* The library can be distributed as part of your applications and libraries
* for execution provided this comment remains unchanged.
*
* Restrictions
* Only to be distributed with programs that add significant and primary
* functionality to the library. Not to be distributed with additional
* software intended to replace any components of the library.
*
* Trademarks
* Jekejeke is a registered trademark of XLOG Technologies AG.
*/
public final class fastlib {
/******************************************************************/
/* term_singletons/2 */
/******************************************************************/
/**
* term_singletons(T, L):
* The built-in succeeds in L with the singleton variables of T.
*/
private static boolean test_term_singletons(Object[] args) {
Object alpha = Machine.exec_build(args[0]);
Object res;
try {
res = eval.walk_compute(alpha, fastlib::init_map, fastlib::union_map);
} finally {
eval.walk_uncompute(alpha);
}
Iterator it = ((Map)res).entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry)it.next();
if (((Boolean)entry.getValue()).booleanValue())
it.remove();
}
res = theatre.set_to_list(((Map)res).keySet());
return Machine.exec_unify(args[1], res);
}
private static final Map EMPTY_MAP = new LinkedHashMap();
private static Map init_map(Object first) {
if (Store.is_variable(first)) {
return Collections.singletonMap(first, Boolean.FALSE);
} else {
return EMPTY_MAP;
}
}
private static Map union_map(Object alpha, Object beta) {
Map first = (Map)alpha;
Map second = (Map)beta;
if (first.size() == 0)
return second;
if (second.size() == 0)
return first;
first = new LinkedHashMap(first);
Iterator it = second.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry)it.next();
Object value = first.get(entry.getKey());
if (value != null) {
value = Boolean.TRUE;
} else {
value = entry.getValue();
}
first.put(entry.getKey(), value);
}
return first;
}
/******************************************************************/
/* ground/1 and nonground/2 */
/******************************************************************/
/**
* ground(T): [TC2 8.3.10]
* The built-in succceeds if T is ground.
*/
private static boolean test_ground(Object[] args) {
Object alpha = Machine.exec_build(args[0]);
boolean res = special.walk_vars(alpha, node -> true, Store.VAR_MASK_SEEN);
special.walk_vars(alpha, node -> true, 0);
return !res;
}
/**
* nonground(T, V):
* The built-in succeeds if T is non-ground and V is the first variable.
*/
private static boolean test_nonground(Object[] args) {
Object alpha = Machine.exec_build(args[0]);
nonground2 h = new nonground2();
boolean res = special.walk_vars(alpha, h::run, Store.VAR_MASK_SEEN);
special.walk_vars(alpha, node -> true, 0);
return res && Machine.exec_unify(args[1], h.hit);
}
private static class nonground2 {
private Object hit = null;
public boolean run(Object node) {
hit = node;
return true;
}
}
/******************************************************************/
/* divmod/4 and gcd/3 */
/******************************************************************/
/**
* divmod(X, Y, Z, T):
* If X and Y are both integers then the predicate succeeds in
* Z with the division of X by Y, and in T with the modulo of X by Y.
*/
private static boolean test_divmod(Object[] args) {
Object alpha = Machine.exec_build(args[0]);
special.check_integer(alpha);
Object beta = Machine.exec_build(args[1]);
special.check_integer(beta);
Number resdiv;
Number resmod;
if (alpha instanceof Integer && beta instanceof Integer) {
int u = ((Integer) beta).intValue();
if (u == 0)
throw Machine.make_error(new Store.Compound("evaluation_error",
new Object[]{"zero_divisor"}));
int v = ((Integer) alpha).intValue();
if (v == Integer.MIN_VALUE && u == -1) {
resdiv = eval.NEG_MIN_INTEGER;
resmod = Integer.valueOf(0);
} else {
int[] res2 = intDivMod(v, u);
resdiv = Integer.valueOf(res2[0]);
resmod = Integer.valueOf(res2[1]);
}
} else {
BigInteger p = special.widen_bigint((Number) beta);
if (p.signum() == 0)
throw Machine.make_error(new Store.Compound("evaluation_error",
new Object[]{"zero_divisor"}));
BigInteger[] res2 = bigDivMod(special.widen_bigint((Number) alpha), p);
resdiv = special.norm_bigint(res2[0]);
resmod = special.norm_bigint(res2[1]);
}
if (!Machine.exec_unify(args[2],resdiv))
return false;
return Machine.exec_unify(args[3],resmod);
}
private static int[] intDivMod(int v, int u) {
int[] res = new int[2];
res[0] = v / u;
res[1] = v % u;
if ((v < 0) != (u < 0)) {
if (res[1] != 0) {
res[0]--;
res[1] += u;
}
}
return res;
}
private static BigInteger[] bigDivMod(BigInteger v, BigInteger u) {
BigInteger[] res = v.divideAndRemainder(u);
if ((v.signum() < 0) != (u.signum() < 0)) {
if (res[1].signum() != 0) {
res[0] = res[0].subtract(BigInteger.ONE);
res[1] = res[1].add(u);
}
}
return res;
}
/**
* gcd(X, Y, Z):
* If X and Y are integers then the predicate succeeds in Z
* with the greatest common divisor of X and Y.
*/
private static Number arit_gcd(Object[] args) {
Number alpha = Machine.exec_eval(args[0]);
special.check_integer(alpha);
Number beta = Machine.exec_eval(args[1]);
special.check_integer(beta);
if (alpha instanceof Integer && beta instanceof Integer) {
return Integer.valueOf(intGcd(alpha.intValue(),
beta.intValue()));
} else {
return special.norm_bigint(
special.widen_bigint(alpha).gcd(
special.widen_bigint(beta)));
}
}
private static int intGcd(int a, int b) {
a = Math.abs(a);
b = Math.abs(b);
while (b != 0) {
int h = Math.abs(a % b);
a = b;
b = h;
}
return a;
}
/******************************************************************/
/* Fast Lib Init */
/******************************************************************/
public static void main() {
Store.set("term_singletons", 2, special.make_check(fastlib::test_term_singletons));
Store.set("ground", 1, special.make_check(fastlib::test_ground));
Store.set("nonground", 2, special.make_check(fastlib::test_nonground));
Store.set("divmod", 4, special.make_check(fastlib::test_divmod));
Store.set("gcd", 3, special.make_arithmetic(fastlib::arit_gcd));
}
}