63 number lo = fun(
lower,
R->cf, r->cf),
64 up = fun(
upper,
R->cf, r->cf);
85 if (intervals !=
NULL)
87 for (i = 0; i < n; i++)
100 if (intervals !=
NULL)
102 for (i = 0; i < n; i++)
113 for (i = 0; i < n; i++)
117 omFree((
void**) intervals);
124 if (0 <= i && i < R->
N)
210 n1 = (number) args->
CopyD();
214 WerrorS(
"Input not supported: first argument not int or number");
235 WerrorS(
"Input not supported: second argument not int or number");
256 result->
data = (
void*) RES;
274 WerrorS(
"syntax: length(<interval>)");
310 int i, imax = 0, imin = 0;
311 for (i = 1; i < 4; i++)
323 lo =
n_Copy(nums[imin], I->
R->cf);
324 up =
n_Copy(nums[imax], I->
R->cf);
327 for (i = 0; i < 4; i++)
448 WerrorS(
"syntax: <interval> + <interval>");
456 WerrorS(
"adding intervals defined in different rings not supported");
467 WerrorS(
"syntax: <interval> - <interval>");
475 WerrorS(
"subtracting intervals defined in different rings not supported");
484 if (i1->
Typ() == i2->
Typ())
492 WerrorS(
"multiplying intervals defined in different rings not supported");
502 leftv iscalar, iinterv;
517 switch (iscalar->
Typ())
520 { n =
nInit((
int)(
long) iscalar->
Data());
break; }
522 { n = (number) iscalar->
CopyD();
break; }
524 {
WerrorS(
"first argument not int/number/interval");
return TRUE; }
546 WerrorS(
"second interval contains zero");
562 WerrorS(
"dividing intervals from different rings not supported");
586 WerrorS(
"first argument not int/number/interval");
606 { n =
nInit((
int)(
long) i2->
Data());
break; }
608 { n =
nCopy((number) i2->
Data());
break; }
611 WerrorS(
"second argument not int/number/interval");
618 WerrorS(
"<interval>/0 not supported");
636 WerrorS(
"syntax: <interval> ^ <int>");
639 int p = (int)(
long) i2->
Data();
642 WerrorS(
"<interval> ^ n not implemented for n < 0");
654 WerrorS(
"syntax: <interval> == <interval>");
671 WerrorS(
"syntax: <interval>[<int>]");
676 int n = (int)(
long) i2->
Data();
689 WerrorS(
"Allowed indices are 1 and 2");
696 number r = (number) result->
Data();
701 result->
data = (
void*) out;
720 result->
data = (
void*) RES;
734 memset(&l, 0,
sizeof(l));
735 memset(&lo, 0,
sizeof(lo));
736 memset(&up, 0,
sizeof(up));
739 l.
data = (
void*)
"interval";
751 f->m->SetRing(f, R,
TRUE);
767 l->
next = f->m->Read(f);
769 number lo = (number) l->
CopyD(),
784 return (
void*)
new box();
789 return (
void*)
new box((
box*) d);
811 for (i = 1; i < n; i++)
846 int M = m > (n-1) ? (n-1) :
m;
848 for (i = 0; i <=
M; i++)
852 WerrorS(
"list contains non-intervals");
866 WerrorS(
"Input not supported: first argument not box, list, or interval");
883 result->
data = (
void*) RES;
894 Werror(
"first argument is not box but type(%d), second is type(%d)",
909 WerrorS(
"second argument not int");
917 int i = (int)(
long) b2->
Data();
921 WerrorS(
"index out of bounds");
941 WerrorS(
"second argument not box");
950 WerrorS(
"subtracting boxes from different rings not supported");
955 for (i = 0; i < n; i++)
966 result->
data = (
void*) RES;
975 WerrorS(
"second argument not box");
980 for (i = 0; i < n; i++)
990 result->
data = (
void*) res;
1009 WerrorS(
"can only intersect boxes");
1014 number lowerb[n], upperb[n];
1017 for (i = 0; i < n; i++)
1028 WerrorS(
"can only intersect boxes");
1033 for (i = 0; i < n; i++)
1044 if (
nGreater(lowerb[i], upperb[i]))
1047 result->
data = (
void*) (-1);
1057 for (i = 0; i < n; i++)
1063 result->
data = (
void*) RES;
1080 memset(&l, 0,
sizeof(l));
1081 memset(&iv, 0,
sizeof(iv));
1084 l.
data = (
void*)
"box";
1087 f->m->SetRing(f, B->
R,
TRUE);
1090 for (
i = 0;
i <
N;
i++)
1093 f->m->Write(f, &iv);
1116 for (i = 1; i <
N; i++)
1142 WerrorS(
"boxSet: index out of range");
1153 result->
data = (
void*) RES;
1170 poly
p = (poly) args->
Data();
1172 int i, pot, n = B->
R->N;
1180 for (i = 1; i <= n; i++)
1212 result->
data = (
void*) RES;
1223 blackbox *b_iv = (blackbox*)
omAlloc0(
sizeof(blackbox)),
1224 *b_bx = (blackbox*)
omAlloc0(
sizeof(blackbox));
1250 psModulFunctions->iiAddCproc(
"rootisolation.lib",
"length",
FALSE,
length);
1251 psModulFunctions->iiAddCproc(
"rootisolation.lib",
"boxSet",
FALSE,
boxSet);
1252 psModulFunctions->iiAddCproc(
"rootisolation.lib",
"evalPolyAtBox",
FALSE,
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
box & setInterval(int, interval *)
static bool intervalContainsZero(interval *I)
static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the l...
static BOOLEAN interval_serialize(blackbox *, void *d, si_link f)
Class used for (list of) interpreter objects.
static BOOLEAN evalPolyAtBox(leftv result, leftv args)
interval(const ring r=currRing)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
static void interval_Destroy(blackbox *, void *d)
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
void WerrorS(const char *s)
BOOLEAN blackboxDefaultOp2(int, leftv, leftv, leftv)
default procedure blackboxDefaultOp2, to be called as "default:" branch
static interval * intervalScalarMultiply(number a, interval *I)
static BOOLEAN box_Op2(int op, leftv result, leftv b1, leftv b2)
static char * interval_String(blackbox *, void *d)
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
#define pGetExp(p, i)
Exponent.
const CanonicalForm CFMap CFMap & N
static interval * intervalSubtract(interval *I, interval *J)
static BOOLEAN box_deserialize(blackbox **, void **d, si_link f)
STATIC_VAR int intervalID
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of 'a' and 'b', i.e., a+b
void StringSetS(const char *st)
static BOOLEAN boxSet(leftv result, leftv args)
void StringAppendS(const char *st)
static BOOLEAN box_Assign(leftv result, leftv args)
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
static char * box_String(blackbox *, void *d)
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of 'a'; raise an error if 'a' is not invertible ...
static void * interval_Copy(blackbox *, void *d)
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
static void * interval_Init(blackbox *)
static void * box_Init(blackbox *)
static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
static BOOLEAN box_OpM(int op, leftv result, leftv args)
static bool intervalEqual(interval *I, interval *J)
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
static interval * intervalPower(interval *I, int p)
BOOLEAN iiCheckTypes(leftv args, const short *type_list, int report)
check a list of arguemys against a given field of types return TRUE if the types match return FALSE (...
static void box_Destroy(blackbox *, void *d)
static interval * intervalMultiply(interval *I, interval *J)
static BOOLEAN length(leftv result, leftv arg)
BOOLEAN blackboxDefaultOpM(int op, leftv res, leftv args)
default procedure blackboxDefaultOpM, to be called as "default:" branch
static BOOLEAN box_serialize(blackbox *, void *d, si_link f)
void CleanUp(ring r=currRing)
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff 'a' and 'b' represent the same number; they may have different representations.
static BOOLEAN interval_Assign(leftv result, leftv args)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff 'n' is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long representing n in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or (Im(n) == 0 and Re(n) >= 0) in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0)) in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0) or (LC(numerator(n) is not a constant) in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1) in Z/mZ: TRUE iff the internal mpz is greater than zero in Z: TRUE iff n > 0
static BOOLEAN interval_Op2(int op, leftv result, leftv i1, leftv i2)
int setBlackboxStuff(blackbox *bb, const char *n)
define a new type
static void * box_Copy(blackbox *, void *d)
void Werror(const char *fmt,...)
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
static BOOLEAN interval_deserialize(blackbox **, void **d, si_link f)
static interval * intervalAdd(interval *I, interval *J)