 |
My Project
UNKNOWN_GIT_VERSION
|
Go to the documentation of this file.
63 number lo = fun(
lower,
R->cf, r->cf),
64 up = fun(
upper,
R->cf, r->cf);
87 for (
i = 0;
i < n;
i++)
102 for (
i = 0;
i < n;
i++)
113 for (
i = 0;
i < n;
i++)
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";
767 l->next =
f->m->Read(
f);
769 number lo = (number)
l->CopyD(),
770 up = (number)
l->next->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++)
1009 WerrorS(
"can only intersect boxes");
1014 number lowerb[n], upperb[n];
1017 for (
i = 0;
i < n;
i++)
1019 lowerb[
i] =
B->intervals[
i]->lower;
1020 upperb[
i] =
B->intervals[
i]->upper;
1028 WerrorS(
"can only intersect boxes");
1033 for (
i = 0;
i < n;
i++)
1037 lowerb[
i] =
B->intervals[
i]->lower;
1041 upperb[
i] =
B->intervals[
i]->upper;
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";
1090 for (
i = 0;
i <
N;
i++)
1092 iv.
data = (
void*)
B->intervals[
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,
interval(const ring r=currRing)
BOOLEAN blackboxDefaultOp2(int, leftv, leftv, leftv)
default procedure blackboxDefaultOp2, to be called as "default:" branch
static BOOLEAN interval_Assign(leftv result, leftv args)
void StringAppendS(const char *st)
static void * interval_Init(blackbox *)
static bool intervalEqual(interval *I, interval *J)
#define pGetExp(p, i)
Exponent.
static BOOLEAN length(leftv result, leftv arg)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
const CanonicalForm CFMap CFMap & N
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...
Class used for (list of) interpreter objects.
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
static interval * intervalSubtract(interval *I, interval *J)
static BOOLEAN interval_Op2(int op, leftv result, leftv i1, leftv i2)
static interval * intervalMultiply(interval *I, interval *J)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
static char * interval_String(blackbox *, void *d)
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of 'a' and 'b', i.e., a+b
static BOOLEAN interval_serialize(blackbox *, void *d, si_link f)
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
int SI_MOD_INIT() interval(SModulFunctions *psModulFunctions)
static void * interval_Copy(blackbox *, void *d)
static void * box_Init(blackbox *)
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
box & setInterval(int, interval *)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
static BOOLEAN interval_deserialize(blackbox **, void **d, si_link f)
static void box_Destroy(blackbox *, void *d)
void CleanUp(ring r=currRing)
static BOOLEAN box_serialize(blackbox *, void *d, si_link f)
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
static BOOLEAN box_deserialize(blackbox **, void **d, si_link f)
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 char * box_String(blackbox *, void *d)
void StringSetS(const char *st)
static interval * intervalPower(interval *I, int p)
void Werror(const char *fmt,...)
static BOOLEAN box_OpM(int op, leftv result, leftv args)
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),...
static void * box_Copy(blackbox *, void *d)
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
void WerrorS(const char *s)
static BOOLEAN box_Op2(int op, leftv result, leftv b1, leftv b2)
static interval * intervalAdd(interval *I, interval *J)
static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
static bool intervalContainsZero(interval *I)
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 boxSet(leftv result, leftv args)
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 interval_Destroy(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
BOOLEAN blackboxDefaultOpM(int op, leftv res, leftv args)
default procedure blackboxDefaultOpM, to be called as "default:" branch
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
static BOOLEAN box_Assign(leftv result, leftv args)
static interval * intervalScalarMultiply(number a, interval *I)
static BOOLEAN evalPolyAtBox(leftv result, leftv args)
int setBlackboxStuff(blackbox *bb, const char *n)
define a new type