int
Block::integer (const symbol key) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return integer (expand_reference (key));
return frame.integer (key);
}
int factor_lehman_method(const Ptr<RCP<const Integer>> &f, const Integer &n)
{
int ret_val;
mpz_class rop;
ret_val = _factor_lehman_method(rop, n.as_mpz());
*f = integer(rop);
return ret_val;
}
void set(const string& value) {
switch(type) {
case Type::Bool: *(bool*)data = (value == "true"); break;
case Type::Signed: *(signed*)data = integer(value); break;
case Type::Unsigned: *(unsigned*)data = decimal(value); break;
case Type::Double: *(double*)data = real(value); break;
case Type::String: *(string*)data = value; break;
}
}
void set(string s) {
switch(type) {
case boolean_t: *(bool*)data = (s == "true"); break;
case signed_t: *(signed*)data = integer(s); break;
case unsigned_t: *(unsigned*)data = decimal(s); break;
case double_t: *(double*)data = fp(s); break;
case string_t: s.trim("\""); *(string*)data = s; break;
}
}
static void applyNEG(void)
{
Cell *c = getN(1);
evaluate(c);
if(c->tag == INT)
makeINT(-integer(c));
else
makeREAL(-real(c));
}
cons_t* proc_truncate(cons_t* p, environment_t*)
{
assert_length(p, 1);
assert_number(car(p));
if ( integerp(car(p)) )
return integer(car(p)->number.integer);
else
return real(truncf(car(p)->number.real));
}
static void test_strutils()
{
// string conversion
check(to_string(integer(0)) == "0");
check(to_string(integer(-1)) == "-1");
check(to_string(INTEGER_MAX) == INTEGER_MAX_STR);
check(to_string(INTEGER_MIN) == INTEGER_MIN_STR);
check(to_string(1, 10, 4, '0') == "0001");
check(to_string(integer(123456789)) == "123456789");
check(to_string(-123, 10, 7, '0') == "-000123");
check(to_string(0xabcde, 16, 6) == "0ABCDE");
bool e = true, o = true;
check(from_string("0", &e, &o) == 0);
check(!o); check(!e);
check(from_string(INTEGER_MAX_STR, &e, &o) == INTEGER_MAX);
check(from_string(INTEGER_MAX_STR_PLUS, &e, &o) == uinteger(INTEGER_MAX) + 1);
check(from_string("92233720368547758070", &e, &o) == 0); check(o);
check(from_string("-1", &e, &o) == 0 ); check(e);
check(from_string("89abcdef", &e, &o, 16) == 0x89abcdef);
check(from_string("afg", &e, &o, 16) == 0); check(e);
check(remove_filename_path("/usr/bin/true") == "true");
check(remove_filename_path("usr/bin/true") == "true");
check(remove_filename_path("/true") == "true");
check(remove_filename_path("true") == "true");
check(remove_filename_path("c:\\Windows\\false") == "false");
check(remove_filename_path("\\Windows\\false") == "false");
check(remove_filename_path("Windows\\false") == "false");
check(remove_filename_path("\\false") == "false");
check(remove_filename_path("false") == "false");
check(remove_filename_ext("/usr/bin/true.exe") == "/usr/bin/true");
check(remove_filename_ext("true.exe") == "true");
check(remove_filename_ext("true") == "true");
check(to_printable('a') == "a");
check(to_printable('\\') == "\\\\");
check(to_printable('\'') == "\\'");
check(to_printable('\x00') == "\\x00");
check(to_printable('\x7f') == "\\x7F");
check(to_printable("abc \x01'\\") == "abc \\x01\\'\\\\");
}
RCP<const Integer> totient(const RCP<const Integer> &n)
{
if (n->is_zero())
return integer(1);
integer_class phi = n->as_integer_class(), p;
if (phi < 0)
phi = -phi;
map_integer_uint prime_mul;
prime_factor_multiplicities(prime_mul, *n);
for (const auto &it : prime_mul) {
p = it.first->as_integer_class();
mp_divexact(phi, phi, p);
// phi is exactly divisible by p.
phi *= p - 1;
}
return integer(std::move(phi));
}
void bvisit(const Complex &x)
{
RCP<const Integer> den, den1, den2;
RCP<const Integer> num1, num2;
num1 = integer(get_num(x.real_));
num2 = integer(get_num(x.imaginary_));
den1 = integer(get_den(x.real_));
den2 = integer(get_den(x.imaginary_));
den = lcm(*den1, *den2);
num1 = rcp_static_cast<const Integer>(mul(num1, div(den, den1)));
num2 = rcp_static_cast<const Integer>(mul(num2, div(den, den2)));
*numer_ = Complex::from_two_nums(*num1, *num2);
*denom_ = den;
}
void gcd_ext(const Ptr<RCP<const Integer>> &g, const Ptr<RCP<const Integer>> &s,
const Ptr<RCP<const Integer>> &t, const Integer &a, const Integer &b)
{
mpz_t g_t;
mpz_t s_t;
mpz_t t_t;
mpz_init(g_t);
mpz_init(s_t);
mpz_init(t_t);
mpz_gcdext(g_t, s_t, t_t, a.as_mpz().get_mpz_t(), b.as_mpz().get_mpz_t());
*g = integer(mpz_class(g_t));
*s = integer(mpz_class(s_t));
*t = integer(mpz_class(t_t));
mpz_clear(g_t);
mpz_clear(s_t);
mpz_clear(t_t);
}
void emit_spiral() {
my._BEING_MANIPULATED = 0;
my.emask |= ENABLE_CLICK;
my.event = ObjectManipulationCore;
var eff_frac; eff_frac = 0;
wait(1);
while(my) {
vec_set(parted_temp_vec,nullvector);
vec_add(parted_temp_vec,my.x);
eff_frac += 4.000*time_step*6.25;
if(eff_frac >= 1){
effect(New_Base_Effect_base,integer(eff_frac),parted_temp_vec,nullvector);
eff_frac -= integer(eff_frac);
}
wait(1);
}
}
static void applyTIMES(void)
{
Cell *c1 = getN(1), *c2 = getN(2);
evaluate(c1);
evaluate(c2);
if(c1->tag == INT)
{
if(c2->tag == INT)
makeINT(integer(c1) * integer(c2));
else
makeREAL(integer(c1) * real(c2));
}
else
{
if(c2->tag == INT)
makeREAL(real(c1) * integer(c2));
else
makeREAL(real(c1) * real(c2));
}
}
void emit_doublehelix() {
my._BEING_MANIPULATED = 0;
my.emask |= ENABLE_CLICK;
my.event = ObjectManipulationCore;
var my_time;my_time = 0;
var timetable_num;timetable_num = 0;
var eff_frac; eff_frac = 0;
wait(1);
while(my) {
my_time += time_step/16;
if(my_time >= 0.000)my_time = 0;
timetable_num = 1;
parted_temp_vec.x = 20.000;
parted_temp_vec.y = -20.000;
parted_temp_vec.z = 0.000;
vec_add(parted_temp_vec,my.x);
if(!(total_frames % 3) && timetable_num) {
eff_frac += 1.000*timetable_num*time_step*6.25;
if(eff_frac >= 1){
effect(Base_Effect_base3,integer(eff_frac),parted_temp_vec,nullvector);
eff_frac -= integer(eff_frac);
}
}
timetable_num = 1;
parted_temp_vec.x = -20.000;
parted_temp_vec.y = 20.000;
parted_temp_vec.z = 0.000;
vec_add(parted_temp_vec,my.x);
if(!(total_frames % 3) && timetable_num) {
eff_frac += 1.000*timetable_num*time_step*6.25;
if(eff_frac >= 1){
effect(Base_Effect1_base3,integer(eff_frac),parted_temp_vec,nullvector);
eff_frac -= integer(eff_frac);
}
}
wait(1);
}
}
void emit_fire2() {
my._BEING_MANIPULATED = 0;
my.emask |= ENABLE_CLICK;
my.event = ObjectManipulationCore;
var my_time;my_time = 0;
var timetable_num;timetable_num = 0;
var eff_frac; eff_frac = 0;
wait(1);
while(my) {
my_time += time_step/16;
if(my_time >= 0.000)my_time = 0;
timetable_num = 1;
parted_temp_vec.x = random(10.000)+-5.000;
parted_temp_vec.y = random(10.000)+-5.000;
parted_temp_vec.z = random(0.000)+0.000;
vec_add(parted_temp_vec,my.x);
if(!(total_frames % 2) && timetable_num) {
eff_frac += 2.000*timetable_num*time_step*6.25;
if(eff_frac >= 1){
effect(Base_Effect4_base,integer(eff_frac),parted_temp_vec,nullvector);
eff_frac -= integer(eff_frac);
}
}
timetable_num = 1;
parted_temp_vec.x = random(10.000)+-5.000;
parted_temp_vec.y = random(10.000)+-5.000;
parted_temp_vec.z = random(0.000)+0.000;
vec_add(parted_temp_vec,my.x);
if(!(total_frames % 8) && timetable_num) {
eff_frac += 1.000*timetable_num*time_step*6.25;
if(eff_frac >= 1){
effect(New_effect1_base,integer(eff_frac),parted_temp_vec,nullvector);
eff_frac -= integer(eff_frac);
}
}
wait(1);
}
}
f_abs()
{
struct value a;
(void) pop(&a);
switch (a.type) {
case INT:
push( integer(&a,abs(a.v.int_val)) );
break;
case CMPLX:
push( complex(&a,magnitude(&a), 0.0) );
}
}
unint f8_to_unint (f8 x)
{
if (!x) return 0;
unint e = exponent(x);
unint i = integer(x);
if (e) {
return (i + INT_ADD) << (e - 1);
} else {
return i;
}
}
static void some_logging_1()
{
short s = 123;
int i = 456;
long l = 789;
float f = (float)(0.123);
double d = 0.456;
long double ld = 0.789;
void *p = &l;
char const *lstr = "{a pointer to a C-style string}";
#if 0
log_INFORMATIONAL( "This is a (hopefully) typical error string, containing: "
, "some integers (", integer(s), ", ", integer(i), ", ", integer(l), "); "
, "some real numbers (", real(f), ", ", real(d), ", ", real(ld), "); "
, "a pointer (", pointer(p, fmt::hex), "); "
, "some strings (", lstr, ", ", str, ", ", sstr, "); "
, "and a converted time value (", tm, ")"
);
#endif /* 0 */
}
/************************************************************
Evaluates its argument to an integer and returns its value
*************************************************************/
Integer evalint(Cell *c, int hashtablenr)
{
evaluate(c);
if(c->tag == REAL)
{
Real r = real(c);
Integer i;
if(r >= LONG_MIN && r <= LONG_MAX && r == (i = r)) return i;
runtimeerror(INT, hashtablenr);
}
return integer(c);
}
f_ceil()
{
struct value a;
(void) pop(&a);
switch (a.type) {
case INT:
push( integer(&a,(int)ceil((double)a.v.int_val)));
break;
case CMPLX:
push( complex(&a,ceil(a.v.cmplx_val.real), ceil(a.v.cmplx_val.imag)) );
}
}
bool Json::operator == (const Json& other) const {
if (this == &other) return true;
if (IsNull()) return other.IsNull();
if (other.IsNull()) return false;
if (value_->type() != other.value_->type()) return false;
if (IsInteger()) return integer() == other.integer();
if (IsUInteger()) return uinteger() == other.uinteger();
if (IsReal()) return real() == other.real();
if (IsString()) return string() == other.string();
if (IsArray()) return array() == other.array();
if (IsObject()) return object() == other.object();
return false;
}
cons_t* proc_abs(cons_t* p, environment_t*)
{
assert_length(p, 1);
assert_number(car(p));
if ( realp(car(p)) ) {
real_t n = car(p)->number.real;
return real(n<0.0? -n : n);
}
int n = car(p)->number.integer;
return integer(n<0? -n : n);
}
void emit_spacehole() {
my._BEING_MANIPULATED = 0;
my.emask |= ENABLE_CLICK;
my.event = ObjectManipulationCore;
var eff_frac; eff_frac = 0;
wait(1);
while(my) {
parted_temp_vec.x = 0.000;
parted_temp_vec.y = 0.000;
parted_temp_vec.z = 0.000;
vec_add(parted_temp_vec,my.x);
eff_frac += 6.000*time_step*6.25;
if(eff_frac >= 1){
effect(Base_Effect2_base,integer(eff_frac),parted_temp_vec,nullvector);
eff_frac -= integer(eff_frac);
}
wait(1);
}
}
cons_t* proc_round(cons_t* p, environment_t*)
{
assert_length(p, 1);
assert_number(car(p));
if ( integerp(car(p)) )
return integer(car(p)->number.integer);
else if ( rationalp(car(p)) )
return real(roundf(make_inexact(car(p))->number.real));
assert_type(REAL, car(p));
return real(roundf(car(p)->number.real));
}
extern "C" cons_t* proc_usleep(cons_t* p, environment_t*)
{
assert_length(p, 1);
assert_type(INTEGER, car(p));
int usecs = car(p)->number.integer;
if ( usecs < 0 )
raise(runtime_exception("usleep doesn't like negative time"));
// TODO: If it returns -1, lookup error and return it
return integer(usleep(usecs));
}
RCP<const Integer> iabs(const Integer &n)
{
mpz_class m;
mpz_t m_t;
mpz_init(m_t);
mpz_abs(m_t, n.as_mpz().get_mpz_t());
m = mpz_class(m_t);
mpz_clear(m_t);
return integer(mpz_class(m));
}
int i_nth_root(const Ptr<RCP<const Integer>> &r, const Integer &a,
unsigned long int n)
{
if (n == 0)
throw SymEngineException("i_nth_root: Can not find Zeroth root");
int ret_val;
integer_class t;
ret_val = mp_root(t, a.as_integer_class(), n);
*r = integer(std::move(t));
return ret_val;
}
f_gamma()
{
extern int signgam;
register double y;
struct value a;
y = gamma(real(pop(&a)));
if (y > 88.0) {
undefined = TRUE;
push( integer(&a,0) );
}
else
push( complex(&a,signgam * exp(y),0.0) );
}
// Factorization
int factor(const Ptr<RCP<const Integer>> &f, const Integer &n, double B1)
{
int ret_val = 0;
integer_class _n, _f;
_n = n.as_integer_class();
#ifdef HAVE_SYMENGINE_ECM
if (mp_perfect_power_p(_n)) {
unsigned long int i = 1;
integer_class m, rem;
rem = 1; // Any non zero number
m = 2; // set `m` to 2**i, i = 1 at the begining
// calculate log2n, this can be improved
for (; m < _n; ++i)
m = m * 2;
// eventually `rem` = 0 zero as `n` is a perfect power. `f_t` will
// be set to a factor of `n` when that happens
while (i > 1 and rem != 0) {
mp_rootrem(_f, rem, _n, i);
--i;
}
ret_val = 1;
} else {
if (mp_probab_prime_p(_n, 25) > 0) { // most probably, n is a prime
ret_val = 0;
_f = _n;
} else {
for (int i = 0; i < 10 and not ret_val; ++i)
ret_val = ecm_factor(get_mpz_t(_f), get_mpz_t(_n), B1, nullptr);
mp_demote(_f);
if (not ret_val)
throw SymEngineException(
"ECM failed to factor the given number");
}
}
#else
// B1 is discarded if gmp-ecm is not installed
ret_val = _factor_trial_division_sieve(_f, _n);
#endif // HAVE_SYMENGINE_ECM
*f = integer(std::move(_f));
return ret_val;
}
cons_t* proc_divf(cons_t *p, environment_t*)
{
assert_length(p, 2);
cons_t *a = car(p);
cons_t *b = cadr(p);
real_t x = (type_of(a) == REAL)? a->number.real : a->number.integer;
real_t y = (type_of(b) == REAL)? b->number.real : b->number.integer;
// Automatically convert back to int if possible
real_t q = x / y;
return iswhole(q)? integer(static_cast<int>(q)) : real(q);
}
// Factorization
int factor(const Ptr<RCP<const Integer>> &f, const Integer &n, double B1)
{
int ret_val = 0;
mpz_class _n, _f;
_n = n.as_mpz();
#ifdef HAVE_CSYMPY_ECM
if (mpz_perfect_power_p(_n.get_mpz_t())) {
unsigned long int i = 1;
mpz_class m, rem;
rem = 1; // Any non zero number
m = 2; // set `m` to 2**i, i = 1 at the begining
// calculate log2n, this can be improved
for (; m < _n; i++)
m = m * 2;
// eventually `rem` = 0 zero as `n` is a perfect power. `f_t` will
// be set to a factor of `n` when that happens
while (i > 1 && rem != 0) {
mpz_rootrem(_f.get_mpz_t(), rem.get_mpz_t(), _n.get_mpz_t(), i);
i--;
}
ret_val = 1;
}
else {
if (mpz_probab_prime_p(_n.get_mpz_t(), 25) > 0) { // most probably, n is a prime
ret_val = 0;
_f = _n;
}
else {
for (int i = 0; i < 10 && !ret_val; i++)
ret_val = ecm_factor(_f.get_mpz_t(), _n.get_mpz_t(), B1, NULL);
if (!ret_val)
throw std::runtime_error("ECM failed to factor the given number");
}
}
#else
// B1 is discarded if gmp-ecm is not installed
ret_val = _factor_trial_division_sieve(_f, _n);
#endif // HAVE_CSYMPY_ECM
*f = integer(_f);
return ret_val;
}
