polynome.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  Smonome
 Warning! Do not modify this file that is automatically generated! More...
struct  Spolynome

Defines

#define monome_coeff(pm)   ((pm)->coeff)
 Macros definitions.
#define monome_term(pm)   ((pm)->term)
#define polynome_monome(pp)   ((pp)->monome)
#define polynome_succ(pp)   ((pp)->succ)
#define is_single_monome(pp)   ((!POLYNOME_NUL_P(pp)) && (POLYNOME_NUL_P(polynome_succ(pp))))
#define monome_constant_new(coeff)   make_monome(coeff, TCST, 1)
#define monome_power1_new(coeff, var)   make_monome(coeff, var, 1)
#define MONOME_NUL   ((Pmonome) -256)
 Null/undefined, monomial/polynomial definitions.
#define MONOME_NUL_P(pm)   ((pm)==MONOME_NUL)
#define MONOME_UNDEFINED   ((Pmonome) -252)
#define MONOME_UNDEFINED_P(pm)   ((pm)==MONOME_UNDEFINED)
#define MONOME_CONSTANT_P(pm)   (term_cst((pm)->term))
#define POLYNOME_NUL   ((Ppolynome) NULL)
#define POLYNOME_NUL_P(pp)   ((pp)==POLYNOME_NUL)
#define POLYNOME_UNDEFINED   ((Ppolynome) -248)
#define POLYNOME_UNDEFINED_P(pp)   ((pp)==POLYNOME_UNDEFINED)
#define MONOME_COEFF_MULTIPLY_SYMBOL   "*"
#define MONOME_VAR_MULTIPLY_SYMBOL   "."
#define POLYNOME_NUL_SYMBOL   "0"
#define POLYNOME_UNDEFINED_SYMBOL   "<polynome undefined>"
#define MONOME_NUL_SYMBOL   "<monome nul>"
#define MONOME_UNDEFINED_SYMBOL   "<monome undefined>"
#define MAX_NAME_LENGTH   50
#define PNOME_MACH_EPS   1E-8
#define PNOME_FLOAT_N_DECIMALES   2
#define PNOME_FLOAT_TO_EXP_LEVEL   1E8
#define PNOME_FLOAT_TO_FRAC_LEVEL   9

Typedefs

typedef struct Smonome Smonome
 Warning! Do not modify this file that is automatically generated!
typedef struct Smonome * Pmonome
typedef struct Spolynome Spolynome
typedef struct Spolynome * Ppolynome

Functions

Pmonome new_monome (void)
 POLYNOME_INCLUDED.
Ppolynome new_polynome (void)
 allocation of an unitialized polynome (to avoid various direct unchecked call to malloc)
Pmonome make_monome (double, Variable, Value)
Ppolynome make_polynome (double, Variable, Value)
Ppolynome monome_to_new_polynome (Pmonome)
 Ppolynome monome_to_new_polynome(Pmonome pm) PRIVATE allocates space for, and creates the polynomial containing the monomial pointed by pm, which is NOT duplicated but attached to the polynomial.
Pmonome monome_dup (Pmonome)
 Pmonome monome_dup(Pmonome pm) PRIVATE creates and returns a copy of pm.
void monome_rm (Pmonome *)
 void monome_rm(Pmonome* ppm) PRIVATE frees space occupied by monomial *ppm returns *ppm pointing to MONOME_NUL !usage: monome_rm(&pm);
void polynome_rm (Ppolynome *)
 void polynome_rm(Ppolynome* ppp) frees space occupied by polynomial *ppp returns *ppp pointing to POLYNOME_NUL !usage: polynome_rm(&pp);
Ppolynome polynome_free (Ppolynome)
 Ppolynome polynome_free(Ppolynome pp) frees space occupied by polynomial pp returns pp == POLYNOME_NUL !usage: polynome_rm(pp);.
Ppolynome polynome_dup (Ppolynome)
 Ppolynome polynome_dup(Ppolynome pp) creates and returns a copy of pp.
void polynome_monome_add (Ppolynome *, Pmonome)
 pnome-bin.c
Ppolynome polynome_monome_addition (Ppolynome, Pmonome)
 Ppolynome polynome_monome_addition(Ppolynome pp, Pmonome pm) PRIVATE Add monomial pm to polynomial pp, in place.
void polynome_add (Ppolynome *, Ppolynome)
 void polynome_add(Ppolynome* ppp, Ppolynome pp2) (*ppp) = (*ppp) + pp2.
Ppolynome polynome_addition (Ppolynome, Ppolynome)
 Ppolynome polynome_addition(Ppolynome pp, Ppolynome pp2) pp = pp + pp2.
Ppolynome polynome_monome_mult (Ppolynome, Pmonome)
 Ppolynome polynome_monome_mult(Ppolynome pp, Pmonome pm) PRIVATE returns pp * pm.
Ppolynome polynome_mult (Ppolynome, Ppolynome)
 Ppolynome polynome_mult(Ppolynome pp1, Ppolynome pp2) returns pp1 * pp2.
Pmonome monome_monome_div (Pmonome, Pmonome)
 Pmonome monome_monome_div(Pmonome pm1, Pmonome pm2) PRIVATE (pm1) = (pm1) / pm2.
Ppolynome polynome_monome_div (Ppolynome, Pmonome)
 Ppolynome polynome_monome_div(Ppolynome pp, Pmonome pm) PRIVATE returns p = pp / pm.
Ppolynome polynome_div (Ppolynome, Ppolynome)
 Ppolynome polynome_div(Ppolynome pp1, Ppolynome pp2) returns p = pp1 / pp2.
void polynome_error (char *, char *,...)
 pnome-error.c
void good_polynome_assert (char *,...)
 void good_polynome_assert(va_alist) Check if the second argument is a valid polynomial.
boolean monome_check (Pmonome)
 boolean monome_check(Pmonome pm) Return TRUE if all's right.
boolean polynome_check (Ppolynome)
 boolean polynome_check(Ppolynome pp) Return TRUE if all's right.
boolean is_polynome_a_monome (Ppolynome)
 boolean is_polynome_a_monome(Ppolynome pp) Return TRUE if the pp is just a monome.
void float_to_frac (double, char **)
 pnome-io.c
void monome_fprint (FILE *, Pmonome, Pbase, boolean, char *(*)(Variable))
char * monome_sprint (Pmonome, Pbase, boolean, char *(*)(Variable))
void polynome_fprint (FILE *, Ppolynome, char *(*)(Variable), int(*)(Pvecteur *, Pvecteur *))
char * polynome_sprint (Ppolynome, char *(*)(Variable), int(*)(Pvecteur *, Pvecteur *))
char * default_variable_name (Variable)
 char *default_variable_name(Variable var) returns for variable var the name "Vxxxx" where xxxx are four letters computed from (int) var.
int default_is_inferior_var (Variable, Variable)
 boolean default_is_inferior_var(Variable var1, Variable var2) return TRUE if var1 is before var2, lexicographically, according to the "default_variable_name" naming.
int default_is_inferior_varval (Pvecteur, Pvecteur)
 boolean default_is_inferior_varval(Pvecteur varval1, Pvecteur varval2) return TRUE if var1 is before var2, lexicographically, according to the "default_variable_name" naming.
int default_is_inferior_pvarval (Pvecteur *, Pvecteur *)
 boolean default_is_inferior_pvarval(Pvecteur * pvarval1, Pvecteur * pvarval2) return TRUE if var1 is before var2, lexicographically, according to the "default_variable_name" naming.
Ppolynome polynome_sscanf (char *, Variable(*)(Variable))
 Ppolynome polynome_sscanf(char *sp, (*name_to_variable)()) converts into polynomial structure the expression passed in ASCII form in string sp.
Pmonome monome_del_var (Pmonome, Variable)
 pnome-private.c
boolean monome_colin (Pmonome, Pmonome)
 boolean monome_colin(Pmonome pm1, Pmonome pm2) PRIVATE returns TRUE if the two monomials are "colinear": same variables, same exponents.
boolean monome_equal (Pmonome, Pmonome)
 boolean monome_equal(Pmonome pm1, Pmonome pm2) PRIVATE returns TRUE if the two monomials are equal same coeff., same variables, same exponents.
float Bernouilli (int)
 float Bernouilli(int i) PRIVATE returns Bi = i-th Bernouilli number
int factorielle (int)
 int factorielle (int n) PRIVATE returns n!
double intpower (double, int)
 double intpower(double d, int n) returns d^n for all integers n
boolean is_inferior_monome (Pmonome, Pmonome, int(*)(Pvecteur *, Pvecteur *))
Ppolynome polynome_var_subst (Ppolynome, Variable, Ppolynome)
 pnome-reduc.c
int polynome_degree (Ppolynome, Variable)
 int polynome_degree(Ppolynome pp, Variable var) returns the degree of polynomial pp viewed as a polynomial of one variable, var.
int polynome_max_degree (Ppolynome)
 int polynome_max_degree(Ppolynome pp) returns the degree of polynomial pp Let's hope there aren't too many negative powers.
Ppolynome polynome_factorize (Ppolynome, Variable, int)
 Ppolynome polynome_factorize(Ppolynome pp, Variable var, int n) returns the (polynomial) coefficient of var^n in polynomial pp.
float polynome_TCST (Ppolynome)
 float polynome_TCST(Ppolynome pp) returns the constant term of polynomial pp.
boolean polynome_constant_p (Ppolynome)
 boolean polynome_constant_p(Ppolynome pp) return TRUE if pp is a constant polynomial (including null polynomial) If pp is POLYNOME_UNDEFINED: abort.
Pbase polynome_used_var (Ppolynome, int(*)(Pvecteur *, Pvecteur *))
boolean polynome_contains_var (Ppolynome, Variable)
 boolean polynome_contains_var(Ppolynome pp, Variable var) PRIVATE returns TRUE if variable var is in polynomial pp.
boolean polynome_equal (Ppolynome, Ppolynome)
 boolean polynome_equal(Ppolynome pp1, Ppolynome pp2) return (pp1 == pp2) >>>TO BE CONTINUED<<<
void polynome_scalar_mult (Ppolynome *, double)
 pnome-scal.c
Ppolynome polynome_scalar_multiply (Ppolynome, double)
void polynome_scalar_add (Ppolynome *, double)
Ppolynome polynome_scalar_addition (Ppolynome, double)
Ppolynome polynome_power_n (Ppolynome, int)
 Ppolynome polynome_power_n(Ppolynome pp, int n) returns pp ^ n (n>=0).
Ppolynome number_replaces_var (Ppolynome, Variable, double)
Ppolynome polynome_incr (Ppolynome)
 Ppolynome polynome_incr(Ppolynome pp) returns pp + 1.
Ppolynome polynome_decr (Ppolynome)
 Ppolynome polynome_decr(Ppolynome pp) returns pp - 1.
void polynome_negate (Ppolynome *)
 pnome-unaires.c
Ppolynome polynome_opposed (Ppolynome)
 Ppolynome polynome_opposed(Ppolynome pp); changes sign of polynomial pp.
Ppolynome polynome_sum_of_power (Ppolynome, int)
 Ppolynome polynome_sum_of_power(Ppolynome ppsup, int p) calculates the sum of i^p for i=1 to (ppsup), returns the polynomial sigma{i=1, ppsup} (i^p).
Ppolynome polynome_sigma (Ppolynome, Variable, Ppolynome, Ppolynome)
 Ppolynome polynome_sigma(Ppolynome pp, Variable var, Ppolynome ppinf, ppsup) returns the sum of pp when its variable var is moving from ppinf to ppsup.
Ppolynome polynome_sort (Ppolynome *, int(*)(Pvecteur *, Pvecteur *))
void polynome_chg_var (Ppolynome *, Variable, Variable)
 void polynome_chg_var(Ppolynome *ppp, Variable v_old, Variable v_new) replace the variable v_old by v_new

Define Documentation

#define is_single_monome ( pp   )     ((!POLYNOME_NUL_P(pp)) && (POLYNOME_NUL_P(polynome_succ(pp))))

Definition at line 156 of file polynome.h.

#define MAX_NAME_LENGTH   50

Definition at line 180 of file polynome.h.

#define monome_coeff ( pm   )     ((pm)->coeff)

Macros definitions.

Definition at line 149 of file polynome.h.

#define MONOME_COEFF_MULTIPLY_SYMBOL   "*"

Definition at line 173 of file polynome.h.

#define monome_constant_new ( coeff   )     make_monome(coeff, TCST, 1)

Definition at line 158 of file polynome.h.

#define MONOME_CONSTANT_P ( pm   )     (term_cst((pm)->term))

Definition at line 166 of file polynome.h.

#define MONOME_NUL   ((Pmonome) -256)

Null/undefined, monomial/polynomial definitions.

Definition at line 162 of file polynome.h.

#define MONOME_NUL_P ( pm   )     ((pm)==MONOME_NUL)

Definition at line 163 of file polynome.h.

#define MONOME_NUL_SYMBOL   "<monome nul>"

Definition at line 177 of file polynome.h.

#define monome_power1_new ( coeff,
var   )     make_monome(coeff, var, 1)

Definition at line 159 of file polynome.h.

#define monome_term ( pm   )     ((pm)->term)

Definition at line 150 of file polynome.h.

#define MONOME_UNDEFINED   ((Pmonome) -252)

Definition at line 164 of file polynome.h.

#define MONOME_UNDEFINED_P ( pm   )     ((pm)==MONOME_UNDEFINED)

Definition at line 165 of file polynome.h.

#define MONOME_UNDEFINED_SYMBOL   "<monome undefined>"

Definition at line 178 of file polynome.h.

#define MONOME_VAR_MULTIPLY_SYMBOL   "."

Definition at line 174 of file polynome.h.

#define PNOME_FLOAT_N_DECIMALES   2

Definition at line 183 of file polynome.h.

#define PNOME_FLOAT_TO_EXP_LEVEL   1E8

Definition at line 184 of file polynome.h.

#define PNOME_FLOAT_TO_FRAC_LEVEL   9

Definition at line 185 of file polynome.h.

#define PNOME_MACH_EPS   1E-8

Definition at line 182 of file polynome.h.

#define polynome_monome ( pp   )     ((pp)->monome)

Definition at line 151 of file polynome.h.

#define POLYNOME_NUL   ((Ppolynome) NULL)

Definition at line 168 of file polynome.h.

#define POLYNOME_NUL_P ( pp   )     ((pp)==POLYNOME_NUL)

Definition at line 169 of file polynome.h.

#define POLYNOME_NUL_SYMBOL   "0"

Definition at line 175 of file polynome.h.

#define polynome_succ ( pp   )     ((pp)->succ)

Definition at line 152 of file polynome.h.

#define POLYNOME_UNDEFINED   ((Ppolynome) -248)

Definition at line 170 of file polynome.h.

#define POLYNOME_UNDEFINED_P ( pp   )     ((pp)==POLYNOME_UNDEFINED)

Definition at line 171 of file polynome.h.

#define POLYNOME_UNDEFINED_SYMBOL   "<polynome undefined>"

Definition at line 176 of file polynome.h.

Typedef Documentation

typedef struct Smonome * Pmonome
typedef struct Spolynome * Ppolynome
typedef struct Smonome Smonome

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/polynome/polynome-local.h instead, to add your own modifications. header file built by cproto

typedef struct Spolynome Spolynome

Function Documentation

float Bernouilli ( int   ) 

float Bernouilli(int i) PRIVATE returns Bi = i-th Bernouilli number

later, we could compute bigger Bernouilli(i) with the recurrence

To please the gcc compiler

Definition at line 105 of file pnome-private.c.

References polynome_error().

Referenced by polynome_sum_of_power().

00107 {
00108     switch (i) {
00109     case  1: return((float) 1/6);
00110     case  2: return((float) 1/30);
00111     case  3: return((float) 1/42);
00112     case  4: return((float) 1/30);
00113     case  5: return((float) 5/66);
00114     case  6: return((float) 691/2730);
00115     case  7: return((float) 7/6); 
00116     case  8: return((float) 3617/510);
00117     case  9: return((float) 43867/798);
00118     case 10: return((float) 174611/330);
00119     case 11: return((float) 854513/138);
00120     case 12: return((float) 236364091/2730);
00121     default: polynome_error("Bernouilli(i)", "i=%d illegal\n", i);
00122         /* later, we could compute bigger Bernouilli(i) with the recurrence */
00123     }
00124     /* To please the gcc compiler */
00125     return 0.;
00126 }

Here is the call graph for this function:

Here is the caller graph for this function:

int default_is_inferior_pvarval ( Pvecteur *  ,
Pvecteur *   
)

boolean default_is_inferior_pvarval(Pvecteur * pvarval1, Pvecteur * pvarval2) return TRUE if var1 is before var2, lexicographically, according to the "default_variable_name" naming.

Definition at line 283 of file pnome-io.c.

References default_variable_name(), and vecteur_var.

Referenced by block_to_complexity(), final_statement_to_complexity_evaluation(), and polynome_equal().

00284 {
00285     return strcmp(default_variable_name(vecteur_var(* pvarval1)),
00286                        default_variable_name(vecteur_var(* pvarval2)));
00287 }

Here is the call graph for this function:

Here is the caller graph for this function:

int default_is_inferior_var ( Variable  ,
Variable   
)

boolean default_is_inferior_var(Variable var1, Variable var2) return TRUE if var1 is before var2, lexicographically, according to the "default_variable_name" naming.

Definition at line 262 of file pnome-io.c.

References default_variable_name().

00264 {
00265     return strcmp(default_variable_name(var1), 
00266                        default_variable_name(var2));
00267 }

Here is the call graph for this function:

int default_is_inferior_varval ( Pvecteur  ,
Pvecteur   
)

boolean default_is_inferior_varval(Pvecteur varval1, Pvecteur varval2) return TRUE if var1 is before var2, lexicographically, according to the "default_variable_name" naming.

Definition at line 273 of file pnome-io.c.

References default_variable_name(), and vecteur_var.

00274 {
00275     return strcmp(default_variable_name(vecteur_var(varval1)),
00276                        default_variable_name(vecteur_var(varval2)));
00277 }

Here is the call graph for this function:

char* default_variable_name ( Variable  var  ) 

char *default_variable_name(Variable var) returns for variable var the name "Vxxxx" where xxxx are four letters computed from (int) var.

I guess that many variables can have the same name since the naming is done modulo 26^4 ? RK. To be fixed...

Parameters:
var ar

Definition at line 239 of file pnome-io.c.

References i, intptr_t, malloc(), s, and TCST.

Referenced by default_is_inferior_pvarval(), default_is_inferior_var(), and default_is_inferior_varval().

00241 {
00242     char *s = (char *) malloc(6);
00243     int i = (intptr_t) var;
00244     
00245     if (var != TCST) {
00246         sprintf(s, "V%c%c%c%c",
00247                 (char) 93 + (i % 26),
00248                 (char) 93 + ((i / 26) % 26),
00249                 (char) 93 + ((i / 26 / 26) % 26),
00250                 (char) 93 + ((i / 26 / 26 / 26) % 26));
00251     }
00252     else 
00253         sprintf(s, "TCST");
00254     return(s);
00255 }

Here is the call graph for this function:

Here is the caller graph for this function:

int factorielle ( int   ) 

int factorielle (int n) PRIVATE returns n!

Definition at line 133 of file pnome-private.c.

References factorielle(), and polynome_error().

Referenced by average_probability_matrix(), and factorielle().

00135 {
00136     int fact = -1;
00137 
00138     if (n<0) 
00139         polynome_error("factorielle", "n=%d", n);
00140     else if (n<2) 
00141         fact = 1;
00142     else 
00143         fact = factorielle(n-1) * n;
00144 
00145     return fact;
00146 }

Here is the call graph for this function:

Here is the caller graph for this function:

void float_to_frac ( double  ,
char **   
)

pnome-io.c

void good_polynome_assert ( char *  function,
  ... 
)

void good_polynome_assert(va_alist) Check if the second argument is a valid polynomial.

If not, print first argument ((char *) function name) and abort.

Parameters:
function unction

Definition at line 81 of file pnome-error.c.

References fprintf(), and polynome_check().

Referenced by polynome_monome_add(), and polynome_monome_addition().

00082 {
00083     va_list args;
00084     Ppolynome pp;
00085 
00086     va_start(args, function);
00087     pp = va_arg(args, Ppolynome);
00088 
00089     if (polynome_check(pp)) return;
00090 
00091     fprintf(stderr, "Bad internal polynomial representation in %s\n", function);
00092     va_end(args);
00093     abort();
00094 }

Here is the call graph for this function:

Here is the caller graph for this function:

double intpower ( double  ,
int   
)

double intpower(double d, int n) returns d^n for all integers n

Definition at line 152 of file pnome-private.c.

References intpower().

Referenced by float_to_frac(), intpower(), and polynome_sum_of_power().

00155 {
00156     if (n>0) 
00157         return (intpower(d, n-1) * d);
00158     else if (n==0) 
00159         return((double) 1);
00160     else 
00161         return (intpower(d, n+1) / d);
00162 }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean is_inferior_monome ( Pmonome  ,
Pmonome  ,
int(*)(Pvecteur *, Pvecteur *)   
)
boolean is_polynome_a_monome ( Ppolynome  pp  ) 

boolean is_polynome_a_monome(Ppolynome pp) Return TRUE if the pp is just a monome.

that means the polynom has only one term Check each monomial, make sure there's no nul or undefined monomial, then check unicity of each monomial.

LZ 06 Nov. 92

Parameters:
pp p

Definition at line 159 of file pnome-error.c.

References FALSE, polynome_check(), POLYNOME_NUL, polynome_succ, and TRUE.

Referenced by polynome_power_n().

00161 {
00162     if ( ! polynome_check(pp) )
00163         return (FALSE);
00164     else if ( pp != POLYNOME_NUL && polynome_succ(pp) == POLYNOME_NUL )
00165         return (TRUE);
00166     else
00167         return (FALSE);
00168 }

Here is the call graph for this function:

Here is the caller graph for this function:

Pmonome make_monome ( double  ,
Variable  ,
Value   
)
Ppolynome make_polynome ( double  ,
Variable  ,
Value   
)
boolean monome_check ( Pmonome  pm  ) 

boolean monome_check(Pmonome pm) Return TRUE if all's right.

Looks if pm is MONOME_UNDEFINED; if not: make sure that the coeff is non nul, that the term is non nul, and checks the (Pvecteur) term. All this also checks that pm is pointing to a valid address.

Modification:

  • MONOME_NUL means 0 monome, and it's a good monome. LZ 10/10/91
Parameters:
pm m

Definition at line 107 of file pnome-error.c.

References FALSE, monome_coeff, MONOME_NUL_P, monome_term, MONOME_UNDEFINED_P, TRUE, vect_check(), and VECTEUR_NUL_P.

Referenced by polynome_check().

00109 {
00110     if ( MONOME_UNDEFINED_P(pm) )
00111         return (FALSE); 
00112     else if (MONOME_NUL_P(pm) )
00113         return (TRUE);
00114     else 
00115         return ((monome_coeff(pm) != 0) && 
00116                 !VECTEUR_NUL_P(monome_term(pm)) &&
00117                 vect_check(monome_term(pm)));
00118 }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean monome_colin ( Pmonome  pm1,
Pmonome  pm2 
)

boolean monome_colin(Pmonome pm1, Pmonome pm2) PRIVATE returns TRUE if the two monomials are "colinear": same variables, same exponents.

We consider that MONOME_UNDEFINED is only colinear to MONOME_UNDEFINED. [???]

Parameters:
pm1 m1
pm2 m2

Definition at line 74 of file pnome-private.c.

References MONOME_NUL_P, monome_term, MONOME_UNDEFINED_P, and vect_equal().

Referenced by polynome_check(), polynome_monome_add(), and polynome_monome_addition().

00076 {
00077     if (MONOME_UNDEFINED_P(pm1) || MONOME_UNDEFINED_P(pm2)
00078         ||    MONOME_NUL_P(pm1) || MONOME_NUL_P(pm2))
00079         return(pm1 == pm2);    
00080     else 
00081         return(vect_equal(monome_term(pm1), monome_term(pm2)));
00082 }

Here is the call graph for this function:

Here is the caller graph for this function:

Pmonome monome_del_var ( Pmonome  pm,
Variable  var 
)

pnome-private.c

is it the only variable

now it is a constant term

Parameters:
pm m
var ar

Definition at line 44 of file pnome-private.c.

References monome_coeff, MONOME_NUL, MONOME_NUL_P, monome_term, MONOME_UNDEFINED, MONOME_UNDEFINED_P, new_monome(), TCST, VALUE_ONE, vect_del_var(), vect_new(), and VECTEUR_NUL_P.

Referenced by polynome_factorize(), and polynome_var_subst().

00047 {
00048     if (MONOME_UNDEFINED_P(pm)) 
00049         return (MONOME_UNDEFINED);
00050     else if (MONOME_NUL_P(pm)) 
00051         return (MONOME_NUL);
00052     else {
00053         Pmonome newpm = new_monome();
00054 
00055         monome_coeff(newpm) = monome_coeff(pm);
00056         monome_term(newpm)  = vect_del_var(monome_term(pm), var);
00057         if (VECTEUR_NUL_P(monome_term(newpm))) {
00058             /* is it the only variable */
00059             monome_term(newpm) = vect_new(TCST, VALUE_ONE); 
00060             /* now it is a constant term   */
00061         }
00062     
00063         return(newpm);
00064     }
00065 }

Here is the call graph for this function:

Here is the caller graph for this function:

Pmonome monome_dup ( Pmonome   ) 

Pmonome monome_dup(Pmonome pm) PRIVATE creates and returns a copy of pm.

Definition at line 136 of file pnome-alloc.c.

References monome_coeff, MONOME_NUL, MONOME_NUL_P, monome_term, MONOME_UNDEFINED, MONOME_UNDEFINED_P, new_monome(), and vect_dup().

Referenced by monome_gen_copy_tree(), polynome_dup(), polynome_monome_add(), and polynome_monome_addition().

00138 {
00139     if (MONOME_NUL_P(pm)) 
00140         return (MONOME_NUL);
00141     else if (MONOME_UNDEFINED_P(pm)) 
00142         return (MONOME_UNDEFINED);
00143     else {
00144         Pmonome pmd = new_monome();
00145         monome_coeff(pmd) = monome_coeff(pm);
00146         monome_term(pmd) = vect_dup(monome_term(pm));
00147         return(pmd);
00148     }
00149 }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean monome_equal ( Pmonome  ,
Pmonome   
)

boolean monome_equal(Pmonome pm1, Pmonome pm2) PRIVATE returns TRUE if the two monomials are equal same coeff., same variables, same exponents.

Definition at line 90 of file pnome-private.c.

References monome_coeff, MONOME_NUL_P, monome_term, MONOME_UNDEFINED_P, and vect_equal().

00092 {
00093     if (MONOME_UNDEFINED_P(pm1) || MONOME_UNDEFINED_P(pm2)
00094         ||    MONOME_NUL_P(pm1) || MONOME_NUL_P(pm2))
00095         return(pm1 == pm2);    
00096     else 
00097         return(vect_equal(monome_term(pm1), monome_term(pm2))
00098                && ((monome_coeff(pm1) == monome_coeff(pm2))));
00099 }

Here is the call graph for this function:

void monome_fprint ( FILE *  ,
Pmonome  ,
Pbase  ,
boolean  ,
char *  *)(Variable 
)
Pmonome monome_monome_div ( Pmonome  pm1,
Pmonome  pm2 
)

Pmonome monome_monome_div(Pmonome pm1, Pmonome pm2) PRIVATE (pm1) = (pm1) / pm2.

!usage: monome_monome_div(pm, pm2); Lei Zhou , 09/07/91

returns ppm pointing to MONOME_NUL

Parameters:
pm1 m1
pm2 m2

Definition at line 311 of file pnome-bin.c.

References monome_coeff, MONOME_CONSTANT_P, MONOME_NUL_P, monome_rm(), monome_term, MONOME_UNDEFINED, MONOME_UNDEFINED_P, new_monome(), polynome_error(), TCST, VALUE_ONE, vect_chg_sgn(), vect_dup(), vect_new(), vect_substract(), and VECTEUR_NUL.

Referenced by polynome_monome_div().

00313 {
00314     if (MONOME_UNDEFINED_P(pm1))
00315         return (MONOME_UNDEFINED);
00316     else if (MONOME_UNDEFINED_P(pm2)) {
00317         monome_rm(&pm1);
00318         return (MONOME_UNDEFINED);
00319     }
00320     else if (!MONOME_NUL_P(pm1)) {
00321         if (MONOME_NUL_P(pm2)) {
00322             monome_rm(&pm1);    /* returns ppm pointing to MONOME_NUL */
00323             return (MONOME_UNDEFINED);
00324         }
00325         else {
00326             Pmonome pmr = new_monome();
00327 
00328             if (MONOME_CONSTANT_P(pm2))
00329                 monome_term(pmr) = vect_dup(monome_term(pm1));
00330             else if (MONOME_CONSTANT_P(pm1)) {
00331                 Pvecteur pv = vect_dup(monome_term(pm2));
00332                 vect_chg_sgn(pv);
00333                 monome_term(pmr) = pv;
00334                 }
00335             else {
00336                 monome_term(pmr) = vect_substract(monome_term(pm1), monome_term(pm2));
00337                 if ( monome_term(pmr) == VECTEUR_NUL )
00338                     monome_term(pmr) = vect_new(TCST, VALUE_ONE);
00339             }
00340             monome_coeff(pmr) = monome_coeff(pm1)/monome_coeff(pm2);
00341 
00342             return (pmr);
00343         }
00344     }
00345     polynome_error("monome_monome_div","Unreachable...\n");
00346     return MONOME_UNDEFINED;
00347 }

Here is the call graph for this function:

Here is the caller graph for this function:

void monome_rm ( Pmonome *   ) 

void monome_rm(Pmonome* ppm) PRIVATE frees space occupied by monomial *ppm returns *ppm pointing to MONOME_NUL !usage: monome_rm(&pm);

Definition at line 158 of file pnome-alloc.c.

References free(), MONOME_NUL, MONOME_NUL_P, monome_term, MONOME_UNDEFINED_P, and vect_rm().

Referenced by monome_gen_free(), monome_monome_div(), monome_monome_mult(), polynome_decr(), polynome_free(), polynome_incr(), polynome_rm(), polynome_scalar_add(), polynome_scalar_addition(), polynome_sscanf(), and polynome_var_subst().

00160 {
00161     if ((!MONOME_NUL_P(*ppm)) && (!MONOME_UNDEFINED_P(*ppm))) {
00162         vect_rm((Pvecteur) monome_term(*ppm));
00163         free((char *) *ppm);
00164     }
00165     *ppm = MONOME_NUL;
00166 }

Here is the call graph for this function:

Here is the caller graph for this function:

char* monome_sprint ( Pmonome  ,
Pbase  ,
boolean  ,
char *  *)(Variable 
)
Ppolynome monome_to_new_polynome ( Pmonome   ) 

Ppolynome monome_to_new_polynome(Pmonome pm) PRIVATE allocates space for, and creates the polynomial containing the monomial pointed by pm, which is NOT duplicated but attached to the polynomial.

Definition at line 117 of file pnome-alloc.c.

References MONOME_NUL_P, MONOME_UNDEFINED_P, new_polynome(), polynome_monome, POLYNOME_NUL, polynome_succ, and POLYNOME_UNDEFINED.

Referenced by make_polynome(), number_replaces_var(), polynome_dup(), polynome_gen_read(), polynome_monome_add(), polynome_monome_addition(), and polynome_var_subst().

00119 {
00120     if (MONOME_NUL_P(pm)) 
00121         return (POLYNOME_NUL);
00122     else if (MONOME_UNDEFINED_P(pm)) 
00123         return (POLYNOME_UNDEFINED);
00124     else {
00125         Ppolynome pp = new_polynome();
00126         polynome_monome(pp) = pm;
00127         polynome_succ(pp) = POLYNOME_NUL;
00128         return (pp);
00129     }
00130 }

Here is the call graph for this function:

Here is the caller graph for this function:

Pmonome new_monome ( void   ) 

POLYNOME_INCLUDED.

pnome-alloc.c

POLYNOME_INCLUDED.

allocation of an unitialized monome (to avoid various direct unchecked call to malloc)

(void) fprintf(stderr, "%10.3f MB", (sbrk(0) - etext)/(double)(1 << 20));

xit(-1);

Definition at line 44 of file pnome-alloc.c.

References fprintf(), malloc(), and NULL.

Referenced by make_monome(), monome_del_var(), monome_dup(), and monome_monome_div().

00045 {
00046     Pmonome pm = (Pmonome) malloc(sizeof(Smonome));
00047     if (pm == NULL) {
00048         (void) fprintf(stderr,"new_monome: Out of memory space\n");
00049         /* (void) fprintf(stderr, "%10.3f MB", 
00050                        (sbrk(0) - etext)/(double)(1 << 20)); */
00051         abort();
00052         /*exit(-1);*/
00053     }
00054     return pm;
00055 }

Here is the call graph for this function:

Here is the caller graph for this function:

Ppolynome new_polynome ( void   ) 

allocation of an unitialized polynome (to avoid various direct unchecked call to malloc)

(void) fprintf(stderr, "%10.3f MB", (sbrk(0) - etext)/(double)(1 << 20));

xit(-1);

Definition at line 60 of file pnome-alloc.c.

References fprintf(), malloc(), and NULL.

Referenced by monome_to_new_polynome().

00061 {
00062     Ppolynome pp = (Ppolynome) malloc(sizeof(Spolynome));
00063     if (pp == NULL) {
00064         (void) fprintf(stderr,"new_polynome: Out of memory space\n");
00065         /* (void) fprintf(stderr, "%10.3f MB", 
00066            (sbrk(0) - etext)/(double)(1 << 20)); */
00067         abort();
00068         /*exit(-1);*/
00069     }
00070     return pp;
00071 }

Here is the call graph for this function:

Here is the caller graph for this function:

Ppolynome number_replaces_var ( Ppolynome  ,
Variable  ,
double   
)
void polynome_add ( Ppolynome *  ppp,
Ppolynome  pp2 
)

void polynome_add(Ppolynome* ppp, Ppolynome pp2) (*ppp) = (*ppp) + pp2.

!usage: polynome_add(&pp, pp2);

Parameters:
ppp pp
pp2 p2

Definition at line 168 of file pnome-bin.c.

References polynome_dup(), polynome_monome, polynome_monome_add(), POLYNOME_NUL, POLYNOME_NUL_P, polynome_rm(), polynome_succ, POLYNOME_UNDEFINED, and POLYNOME_UNDEFINED_P.

Referenced by create_farkas_poly(), make_causal_external(), make_causal_internal(), mapping_on_broadcast(), old_vecteur_to_polynome(), plc_make_distance(), plc_make_proto(), polynome_gen_read(), polynome_mult(), polynome_sigma(), polynome_sum_of_power(), polynome_var_subst(), pu_expression_to_polynome(), and vecteur_mult().

00170 {
00171     if (POLYNOME_NUL_P(*ppp)) {
00172         if ( !POLYNOME_NUL_P(pp2))
00173             *ppp = polynome_dup(pp2);
00174         else
00175             *ppp = POLYNOME_NUL;
00176     }
00177     else if (POLYNOME_UNDEFINED_P(pp2)) {
00178         polynome_rm(ppp);
00179         *ppp = POLYNOME_UNDEFINED;
00180     }
00181     else if (!POLYNOME_UNDEFINED_P(*ppp)) {
00182         for (;pp2 != POLYNOME_NUL; pp2 = polynome_succ(pp2)) {
00183             polynome_monome_add(ppp, polynome_monome(pp2));
00184         }
00185     }
00186 }

Here is the call graph for this function:

Here is the caller graph for this function:

Ppolynome polynome_addition ( Ppolynome  pp,
Ppolynome  pp2 
)

Ppolynome polynome_addition(Ppolynome pp, Ppolynome pp2) pp = pp + pp2.

!usage: pp = polynome_add(pp, pp2);

Parameters:
pp p
pp2 p2

Definition at line 192 of file pnome-bin.c.

References polynome_dup(), polynome_free(), polynome_monome, polynome_monome_addition(), POLYNOME_NUL, POLYNOME_NUL_P, polynome_succ, POLYNOME_UNDEFINED, and POLYNOME_UNDEFINED_P.

Referenced by complexity_add(), complexity_polynome_add(), and complexity_sub().

00194 {
00195     Ppolynome newpp = POLYNOME_UNDEFINED;
00196 
00197     if (POLYNOME_NUL_P(pp)) {
00198         if ( !POLYNOME_NUL_P(pp2))
00199             newpp = polynome_dup(pp2);
00200         else
00201             newpp = POLYNOME_NUL;
00202     }
00203     else if (POLYNOME_UNDEFINED_P(pp2)) {
00204         pp = polynome_free(pp);
00205         newpp = POLYNOME_UNDEFINED;
00206     }
00207     else if (!POLYNOME_UNDEFINED_P(pp)) {
00208         newpp = pp;
00209         for (;pp2 != POLYNOME_NUL; pp2 = polynome_succ(pp2)) {
00210             newpp = polynome_monome_addition(newpp, polynome_monome(pp2));
00211         }
00212     }
00213     return newpp;
00214 }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean polynome_check ( Ppolynome  pp  ) 

boolean polynome_check(Ppolynome pp) Return TRUE if all's right.

Check each monomial, make sure there's no nul or undefined monomial, then check unicity of each monomial.

Modification:

  • POLYNOME_NUL means 0 polynome, and it's a good one. LZ 10/10/91
Parameters:
pp p

Definition at line 128 of file pnome-error.c.

References FALSE, monome_check(), monome_colin(), polynome_monome, POLYNOME_NUL, POLYNOME_NUL_P, polynome_succ, POLYNOME_UNDEFINED_P, and TRUE.

Referenced by complexity_check(), good_polynome_assert(), and is_polynome_a_monome().

00130 {
00131     if ( POLYNOME_UNDEFINED_P(pp) )
00132         return (FALSE);
00133     if ( POLYNOME_NUL_P(pp) )
00134         return (TRUE);
00135     else {
00136         Ppolynome curpp, curpp2;
00137 
00138         for (curpp = pp; curpp != POLYNOME_NUL; curpp = polynome_succ(curpp)) {
00139             if ( !monome_check(polynome_monome(curpp)) ) {
00140                 return (FALSE);
00141             }
00142             for (curpp2 = polynome_succ(curpp); curpp2 != POLYNOME_NUL;
00143                  curpp2 = polynome_succ(curpp2))
00144                 if (monome_colin(polynome_monome(curpp),polynome_monome(curpp2))) 
00145                     return (FALSE);
00146         }
00147         return (TRUE);
00148     }
00149 }

Here is the call graph for this function:

Here is the caller graph for this function:

void polynome_chg_var ( Ppolynome *  ,
Variable  ,
Variable   
)

void polynome_chg_var(Ppolynome *ppp, Variable v_old, Variable v_new) replace the variable v_old by v_new

Should it be comparated against MONOME_NUL (that is different of 0) instead?

Definition at line 250 of file pnome-unaires.c.

References monome_term, NULL, polynome_monome, POLYNOME_NUL, polynome_succ, and vect_chg_var().

00253 {
00254     Ppolynome ppcur;
00255 
00256     for (ppcur = *ppp; ppcur != POLYNOME_NUL; ppcur = polynome_succ(ppcur)) {
00257         Pmonome pmcur = polynome_monome(ppcur);
00258         /* Should it be comparated against MONOME_NUL (that is different
00259            of 0) instead? */
00260         if ( pmcur != NULL ) {
00261             Pvecteur pvcur = monome_term(pmcur);
00262 
00263             vect_chg_var(&pvcur,v_old,v_new);
00264         }
00265     }
00266 }

Here is the call graph for this function:

boolean polynome_constant_p ( Ppolynome  pp  ) 

boolean polynome_constant_p(Ppolynome pp) return TRUE if pp is a constant polynomial (including null polynomial) If pp is POLYNOME_UNDEFINED: abort.

[???]

polynome_constant_p: polynome is undefined

Parameters:
pp p

Definition at line 180 of file pnome-reduc.c.

References assert, b, monome_term, polynome_monome, POLYNOME_NUL, POLYNOME_NUL_P, polynome_succ, POLYNOME_UNDEFINED_P, TCST, TRUE, VALUE_ONE, vect_equal(), vect_new(), and vect_rm().

Referenced by complexity_constant_p(), if_conv_init_statement(), and polynome_sum_of_power().

00182 {
00183     /* polynome_constant_p: polynome is undefined */
00184     assert(!POLYNOME_UNDEFINED_P(pp));
00185 
00186     if (POLYNOME_NUL_P(pp)) 
00187         return(TRUE);
00188     else {
00189         Pvecteur pvTCST = vect_new((Variable) TCST, VALUE_ONE);
00190         boolean b = (vect_equal(pvTCST, monome_term(polynome_monome(pp)))
00191                      && (polynome_succ(pp) == POLYNOME_NUL));
00192 
00193         vect_rm(pvTCST);
00194         return(b);
00195     }
00196 }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean polynome_contains_var ( Ppolynome  ,
Variable   
)

boolean polynome_contains_var(Ppolynome pp, Variable var) PRIVATE returns TRUE if variable var is in polynomial pp.

Definition at line 238 of file pnome-reduc.c.

References FALSE, monome_term, polynome_monome, POLYNOME_NUL, polynome_succ, POLYNOME_UNDEFINED_P, TRUE, and vect_coeff().

Referenced by complexity_sigma(), include_trans_in_poly(), and is_uniform_rec().

00241 {
00242     if ( POLYNOME_UNDEFINED_P(pp) )
00243         return (FALSE);
00244     else {
00245         for ( ; pp != POLYNOME_NUL; pp = polynome_succ(pp))
00246             if (vect_coeff(var, monome_term(polynome_monome(pp))) != 0)
00247                 return (TRUE);
00248         return(FALSE);
00249     }
00250 }

Here is the call graph for this function:

Here is the caller graph for this function:

Ppolynome polynome_decr ( Ppolynome  pp  ) 

Ppolynome polynome_decr(Ppolynome pp) returns pp - 1.

pp is NOT duplicated.

Parameters:
pp p

Definition at line 219 of file pnome-scal.c.

References make_monome(), monome_rm(), polynome_monome_add(), POLYNOME_UNDEFINED, POLYNOME_UNDEFINED_P, TCST, and VALUE_ONE.

Referenced by add_constraint_on_x(), and make_causal_external().

00221 {
00222     if (POLYNOME_UNDEFINED_P(pp)) 
00223         return (POLYNOME_UNDEFINED);
00224     else {
00225         Pmonome minus_one = make_monome(-1.0, TCST, VALUE_ONE);
00226 
00227         polynome_monome_add(&pp, minus_one);
00228         monome_rm(&minus_one);
00229 
00230         return(pp);
00231     }
00232 }

Here is the call graph for this function:

Here is the caller graph for this function:

int polynome_degree ( Ppolynome  pp,
Variable  var 
)

int polynome_degree(Ppolynome pp, Variable var) returns the degree of polynomial pp viewed as a polynomial of one variable, var.

If pp is POLYNOME_UNDEFINED: abort. [???]

polynome_degree: polynome is undefined

Parameters:
pp p
var ar

Definition at line 93 of file pnome-reduc.c.

References assert, monome_term, polynome_monome, POLYNOME_NUL, polynome_succ, POLYNOME_UNDEFINED_P, and vect_coeff().

Referenced by polynome_sigma().

00096 {
00097     int power, deg = 0;
00098 
00099     /* polynome_degree: polynome is undefined */
00100     assert(!POLYNOME_UNDEFINED_P(pp));
00101     for( ; pp != POLYNOME_NUL; pp = polynome_succ(pp)) {
00102         power = (int) vect_coeff(var, monome_term(polynome_monome(pp)));
00103         if (deg < power) deg = power;
00104     }
00105     return(deg);
00106 }

Here is the call graph for this function:

Here is the caller graph for this function:

Ppolynome polynome_div ( Ppolynome  ,
Ppolynome   
)

Ppolynome polynome_div(Ppolynome pp1, Ppolynome pp2) returns p = pp1 / pp2.

Definition at line 378 of file pnome-bin.c.

References exit(), fprintf(), is_single_monome, polynome_monome, polynome_monome_div(), POLYNOME_NUL, POLYNOME_NUL_P, POLYNOME_UNDEFINED, and POLYNOME_UNDEFINED_P.

Referenced by complexity_div(), polynome_power_n(), and pu_expression_to_polynome().

00380 {
00381     if (POLYNOME_UNDEFINED_P(pp1) || POLYNOME_UNDEFINED_P(pp2)
00382                                   || POLYNOME_NUL_P(pp2)   )
00383         return (POLYNOME_UNDEFINED);
00384     if (POLYNOME_NUL_P(pp1))
00385         return (POLYNOME_NUL);
00386     else {
00387         Ppolynome ppresult;
00388 
00389         if (is_single_monome(pp2)) {
00390             ppresult = polynome_monome_div(pp1, polynome_monome(pp2));
00391         }
00392         else {
00393             fprintf(stdout,"The divider has at least two elements!\n");
00394             exit(3);
00395         }
00396         return (ppresult);
00397     }
00398 }

Here is the call graph for this function:

Here is the caller graph for this function:

Ppolynome polynome_dup ( Ppolynome   ) 

Ppolynome polynome_dup(Ppolynome pp) creates and returns a copy of pp.

Definition at line 215 of file pnome-alloc.c.

References monome_dup(), monome_to_new_polynome(), polynome_monome, POLYNOME_NUL, POLYNOME_NUL_P, polynome_succ, POLYNOME_UNDEFINED, and POLYNOME_UNDEFINED_P.

Referenced by complexity_dup(), cutting_conditions(), is_not_trivial_p(), make_causal_external(), make_causal_internal(), old_polynome_to_sc(), plc_make_distance(), polynome_add(), polynome_addition(), polynome_equal(), polynome_gen_copy_tree(), polynome_monome_div(), polynome_monome_mult(), polynome_power_n(), polynome_sum_of_power(), polynome_to_new_complexity(), polynome_to_sc(), prgm_mapping(), prototype_var_subst(), search_scc_bdt(), and valuer().

00217 {
00218     Ppolynome ppdup, curpp;
00219 
00220     if (POLYNOME_NUL_P(pp)) 
00221         return (POLYNOME_NUL);
00222     else if (POLYNOME_UNDEFINED_P(pp)) 
00223         return (POLYNOME_UNDEFINED);
00224     else {
00225         ppdup = monome_to_new_polynome(monome_dup(polynome_monome(pp)));
00226         curpp = ppdup;
00227         while ((pp = polynome_succ(pp)) != POLYNOME_NUL) {
00228             polynome_succ(curpp) =
00229                 monome_to_new_polynome(monome_dup(polynome_monome(pp)));
00230             curpp = polynome_succ(curpp);
00231         }
00232         return (ppdup);
00233     }
00234 }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean polynome_equal ( Ppolynome  ,
Ppolynome   
)

boolean polynome_equal(Ppolynome pp1, Ppolynome pp2) return (pp1 == pp2) >>>TO BE CONTINUED<<<

TO BE CONTINUED

Definition at line 257 of file pnome-reduc.c.

References default_is_inferior_pvarval(), FALSE, polynome_dup(), polynome_error(), and polynome_sort().

00259 {
00260     Ppolynome ppcopy1 = polynome_dup(pp1);
00261     Ppolynome ppcopy2 = polynome_dup(pp2);
00262 
00263     polynome_sort(&ppcopy1, default_is_inferior_pvarval);
00264     polynome_sort(&ppcopy2, default_is_inferior_pvarval);
00265     
00266 
00267     /* TO BE CONTINUED */
00268     polynome_error ("polynome_equal", "To be implemented!\n");
00269     return FALSE;
00270 }

Here is the call graph for this function:

void polynome_error ( char *  name,
char *  fmt,
  ... 
)

pnome-error.c

pnome-error.c

void polynome_error(va_dcl va_list): should be called to terminate execution and to core dump when data structures are corrupted or when an undefined operation is requested (zero divide for instance). polynome_error should be called as:

polynome_error(function_name, format, expression-list)

where function_name is a string containing the name of the function calling POLYNOME_ERROR, and where format and expression-list are passed as arguments to vprintf. POLYNOME_ERROR terminates execution with abort. Ex: polynome_error("polynome_power_n", "negative power: %d\n", p);ARARGS0

print name of function causing error

print out remainder of message

create a core file for debug

Parameters:
name ame
fmt mt

Definition at line 59 of file pnome-error.c.

References fprintf().

Referenced by Bernouilli(), factorielle(), monome_monome_div(), polynome_equal(), polynome_power_n(), polynome_sum_of_power(), and polynome_used_var().

00060 {
00061     va_list args;
00062 
00063     va_start(args, fmt);
00064 
00065     /* print name of function causing error */
00066     (void) fprintf(stderr, "\npolynome error in %s: ", name);
00067 
00068     /* print out remainder of message */
00069     (void) vfprintf(stderr, fmt, args);
00070     va_end(args);
00071 
00072     /* create a core file for debug */
00073     (void) abort();
00074 }

Here is the call graph for this function:

Here is the caller graph for this function:

Ppolynome polynome_factorize ( Ppolynome  ,
Variable  ,
int   
)

Ppolynome polynome_factorize(Ppolynome pp, Variable var, int n) returns the (polynomial) coefficient of var^n in polynomial pp.

Definition at line 131 of file pnome-reduc.c.

References monome_del_var(), monome_term, polynome_monome, polynome_monome_add(), POLYNOME_NUL, polynome_succ, POLYNOME_UNDEFINED, POLYNOME_UNDEFINED_P, and vect_coeff().

Referenced by old_polynome_to_sc(), and polynome_sigma().

00135 {
00136     Ppolynome ppfact = POLYNOME_NUL;
00137     Pmonome pm;
00138 
00139     if (POLYNOME_UNDEFINED_P(pp))
00140         return (POLYNOME_UNDEFINED);
00141     else {
00142         for( ; pp != POLYNOME_NUL; pp = polynome_succ(pp))
00143             if (n == (int) vect_coeff(var, monome_term(polynome_monome(pp)))) {
00144                 pm = monome_del_var(polynome_monome(pp), var);
00145                 polynome_monome_add(&ppfact, pm);
00146             }
00147 
00148         return(ppfact);
00149     }
00150 }

Here is the call graph for this function:

Here is the caller graph for this function:

void polynome_fprint ( FILE *  ,
Ppolynome  ,
char *  *)(Variable,
int(*)(Pvecteur *, Pvecteur *)   
)
Ppolynome polynome_free ( Ppolynome   ) 

Ppolynome polynome_free(Ppolynome pp) frees space occupied by polynomial pp returns pp == POLYNOME_NUL !usage: polynome_rm(pp);.

correct?

Definition at line 195 of file pnome-alloc.c.

References free(), monome_rm(), polynome_monome, POLYNOME_NUL, polynome_succ, and POLYNOME_UNDEFINED_P.

Referenced by complexity_mult(), complexity_stats_add(), polynome_addition(), polynome_monome_addition(), polynome_scalar_multiply(), and valuer().

00197 {
00198     Ppolynome pp1 = pp, pp2;
00199 
00200     if (!POLYNOME_UNDEFINED_P(pp)) {
00201         while (pp1 != POLYNOME_NUL) {
00202             pp2 = polynome_succ(pp1);
00203             monome_rm(&polynome_monome(pp1));
00204             free((char *) pp1);               /* correct? */
00205             pp1 = pp2;
00206         }
00207     }
00208     return POLYNOME_NUL;
00209 }

Here is the call graph for this function:

Here is the caller graph for this function:

Ppolynome polynome_incr ( Ppolynome  pp  ) 

Ppolynome polynome_incr(Ppolynome pp) returns pp + 1.

pp is NOT duplicated.

Parameters:
pp p

Definition at line 199 of file pnome-scal.c.

References make_monome(), monome_rm(), polynome_monome_add(), POLYNOME_UNDEFINED, POLYNOME_UNDEFINED_P, TCST, and VALUE_ONE.

00201 {
00202     if (POLYNOME_UNDEFINED_P(pp)) 
00203         return (POLYNOME_UNDEFINED);
00204     else {
00205         Pmonome one = make_monome(1.0, TCST, VALUE_ONE);
00206 
00207         polynome_monome_add(&pp, one);
00208         monome_rm(&one);
00209 
00210         return(pp);
00211     }
00212 }

Here is the call graph for this function:

int polynome_max_degree ( Ppolynome  pp  ) 

int polynome_max_degree(Ppolynome pp) returns the degree of polynomial pp Let's hope there aren't too many negative powers.

.. If pp is POLYNOME_UNDEFINED: abort. [???]

polynome_degree: polynome is undefined

Parameters:
pp p

Definition at line 113 of file pnome-reduc.c.

References assert, monome_term, polynome_monome, POLYNOME_NUL, polynome_succ, POLYNOME_UNDEFINED, POLYNOME_UNDEFINED_P, and vect_sum().

Referenced by complexity_degree().

00114 {
00115     int power, deg = 0;
00116     Ppolynome m = POLYNOME_UNDEFINED;
00117 
00118     /* polynome_degree: polynome is undefined */
00119     assert(!POLYNOME_UNDEFINED_P(pp));
00120     for(m = pp ; m != POLYNOME_NUL; m = polynome_succ(m)) {
00121         power = (int) vect_sum(monome_term(polynome_monome(m)));
00122         if (deg < power) deg = power;
00123     }
00124     return deg;
00125 }

Here is the call graph for this function:

Here is the caller graph for this function:

void polynome_monome_add ( Ppolynome *  ppp,
Pmonome  pm 
)

pnome-bin.c

pnome-bin.c

There is no new polynomial malloc. Monomial pm doesn't become part of the polynomial: it is duplicated if needed. !usage: polynome_monome_add(&pp, pm);

This monomial is null now. We free it

no element in polynome

Save new value of monomial coefficient.

Add a copy of the monomial at the end

Parameters:
ppp pp
pm m

Definition at line 47 of file pnome-bin.c.

References good_polynome_assert(), monome_coeff, monome_colin(), monome_dup(), MONOME_NUL_P, monome_to_new_polynome(), MONOME_UNDEFINED_P, PNOME_MACH_EPS, polynome_monome, POLYNOME_NUL, POLYNOME_NUL_P, polynome_rm(), polynome_succ, POLYNOME_UNDEFINED, POLYNOME_UNDEFINED_P, and printf().

Referenced by polynome_add(), polynome_decr(), polynome_factorize(), polynome_incr(), polynome_monome_div(), polynome_scalar_add(), polynome_sscanf(), and polynome_var_subst().

00050 {
00051     Ppolynome prevpp = POLYNOME_NUL;
00052     float coeff;
00053 
00054     if (POLYNOME_NUL_P(*ppp)) {
00055         *ppp = monome_to_new_polynome(monome_dup(pm));
00056     }
00057     else if (POLYNOME_UNDEFINED_P(*ppp))
00058         ;
00059     else if (MONOME_UNDEFINED_P(pm)) {
00060         polynome_rm(ppp);
00061         *ppp = POLYNOME_UNDEFINED;
00062     }
00063     else if (!MONOME_NUL_P(pm)) {
00064         Ppolynome curpp;
00065         for(curpp = *ppp; curpp != POLYNOME_NUL; prevpp = curpp,curpp = polynome_succ(curpp)) {
00066             if (monome_colin(polynome_monome(curpp), pm)) {
00067                 coeff = monome_coeff(polynome_monome(curpp)) + monome_coeff(pm);
00068                 if ((coeff < PNOME_MACH_EPS) && (coeff > -PNOME_MACH_EPS)) {
00069                     /* This monomial is null now. We free it */
00070                     if (curpp == *ppp) 
00071                         *ppp = polynome_succ(*ppp);
00072                     else 
00073                         polynome_succ(prevpp) = polynome_succ(curpp);
00074                     polynome_succ(curpp) = POLYNOME_NUL;
00075                     polynome_rm(&curpp);
00076                     curpp = ( prevpp==POLYNOME_NUL ? *ppp : prevpp );
00077                     if ( curpp == POLYNOME_NUL ) /* no element in polynome */
00078                         *ppp = POLYNOME_NUL;
00079                 }
00080                 else            /* Save new value of monomial coefficient. */
00081                     monome_coeff(polynome_monome(curpp)) = coeff;
00082                 break;
00083             }
00084         }
00085 
00086         if ( curpp == POLYNOME_NUL && !POLYNOME_NUL_P(*ppp) ) { 
00087             /* Add a copy of the monomial at the end */
00088             good_polynome_assert("polynome_monome_add about prevpp before",prevpp);
00089             if ( polynome_succ(prevpp) == POLYNOME_NUL ) {
00090                 if ( MONOME_NUL_P(pm) || MONOME_UNDEFINED_P(pm) )
00091                     printf("monome is poor\n");
00092                 else 
00093                     polynome_succ(prevpp) = monome_to_new_polynome(monome_dup(pm));
00094             }
00095             good_polynome_assert("polynome_monome_add about prevpp at end",prevpp);
00096         }
00097     }
00098     good_polynome_assert("polynome_monome_add about *ppp at end",*ppp);
00099 }

Here is the call graph for this function:

Here is the caller graph for this function:

Ppolynome polynome_monome_addition ( Ppolynome  pp,
Pmonome  pm 
)

Ppolynome polynome_monome_addition(Ppolynome pp, Pmonome pm) PRIVATE Add monomial pm to polynomial pp, in place.

There is no new polynomial malloc. Monomial pm doesn't become part of the polynomial: it is duplicated if needed. !usage: pp = polynome_monome_add(pp, pm);

This monomial is null now. We free it

no element in polynome

Save new value of monomial coefficient.

Add a copy of the monomial at the end

Parameters:
pp p
pm m

Definition at line 109 of file pnome-bin.c.

References good_polynome_assert(), monome_coeff, monome_colin(), monome_dup(), MONOME_NUL_P, monome_to_new_polynome(), MONOME_UNDEFINED_P, PNOME_MACH_EPS, polynome_free(), polynome_monome, POLYNOME_NUL, POLYNOME_NUL_P, polynome_rm(), polynome_succ, POLYNOME_UNDEFINED, POLYNOME_UNDEFINED_P, and printf().

Referenced by polynome_addition(), and polynome_scalar_addition().

00112 {
00113     Ppolynome prevpp = POLYNOME_UNDEFINED;
00114 
00115     if (POLYNOME_NUL_P(pp)) {
00116         pp = monome_to_new_polynome(monome_dup(pm));
00117     }
00118     else if (POLYNOME_UNDEFINED_P(pp))
00119         ;
00120     else if (MONOME_UNDEFINED_P(pm)) {
00121         pp = polynome_free(pp);
00122         pp = POLYNOME_UNDEFINED;
00123     }
00124     else if (!MONOME_NUL_P(pm)) {
00125         Ppolynome curpp;
00126         for(curpp = pp; curpp != POLYNOME_NUL; prevpp = curpp,curpp = polynome_succ(curpp)) {
00127             if (monome_colin(polynome_monome(curpp), pm)) {
00128                 float coeff = monome_coeff(polynome_monome(curpp)) + monome_coeff(pm);
00129 
00130                 if ((coeff < PNOME_MACH_EPS) && (coeff > -PNOME_MACH_EPS)) {
00131                     /* This monomial is null now. We free it */
00132                     if (curpp == pp) 
00133                         pp = polynome_succ(pp);
00134                     else 
00135                         polynome_succ(prevpp) = polynome_succ(curpp);
00136                     polynome_succ(curpp) = POLYNOME_NUL;
00137                     polynome_rm(&curpp);
00138                     curpp = ( prevpp==POLYNOME_NUL ? pp : prevpp );
00139                     if ( curpp == POLYNOME_NUL ) /* no element in polynome */
00140                         pp = POLYNOME_NUL;
00141                 }
00142                 else            /* Save new value of monomial coefficient. */
00143                     monome_coeff(polynome_monome(curpp)) = coeff;
00144                 break;
00145             }
00146         }
00147 
00148         if ( curpp == POLYNOME_NUL && !POLYNOME_NUL_P(pp) ) { 
00149             /* Add a copy of the monomial at the end */
00150             good_polynome_assert("polynome_monome_add about prevpp before",prevpp);
00151             if ( polynome_succ(prevpp) == POLYNOME_NUL ) {
00152                 if ( MONOME_NUL_P(pm) || MONOME_UNDEFINED_P(pm) )
00153                     printf("monome is poor\n");
00154                 else 
00155                     polynome_succ(prevpp) = monome_to_new_polynome(monome_dup(pm));
00156             }
00157             good_polynome_assert("polynome_monome_add about prevpp at end",prevpp);
00158         }
00159     }
00160     good_polynome_assert("polynome_monome_add about pp at end",pp);
00161     return pp;
00162 }

Here is the call graph for this function:

Here is the caller graph for this function:

Ppolynome polynome_monome_div ( Ppolynome  ,
Pmonome   
)

Ppolynome polynome_monome_div(Ppolynome pp, Pmonome pm) PRIVATE returns p = pp / pm.

Definition at line 353 of file pnome-bin.c.

References monome_monome_div(), MONOME_NUL_P, MONOME_UNDEFINED_P, polynome_dup(), polynome_monome, polynome_monome_add(), POLYNOME_NUL, POLYNOME_NUL_P, polynome_succ, POLYNOME_UNDEFINED, and POLYNOME_UNDEFINED_P.

Referenced by polynome_div().

00356 {
00357     if (POLYNOME_UNDEFINED_P(pp) || MONOME_UNDEFINED_P(pm))
00358         return (POLYNOME_UNDEFINED);
00359     else if (POLYNOME_NUL_P(pp) || MONOME_NUL_P(pm))
00360         return (POLYNOME_NUL);
00361     else {
00362         Ppolynome ppresult = POLYNOME_NUL;
00363         Ppolynome curpp, ppdup;
00364         ppdup = polynome_dup(pp);
00365 
00366         for (curpp = ppdup ; curpp != POLYNOME_NUL; curpp = polynome_succ(curpp)) {
00367             Pmonome pmtmp = monome_monome_div(polynome_monome(curpp), pm);
00368             polynome_monome_add(&ppresult,pmtmp);
00369         }
00370         return (ppresult);
00371     }
00372 }

Here is the call graph for this function:

Here is the caller graph for this function:

Ppolynome polynome_monome_mult ( Ppolynome  ,
Pmonome   
)

Ppolynome polynome_monome_mult(Ppolynome pp, Pmonome pm) PRIVATE returns pp * pm.

Definition at line 263 of file pnome-bin.c.

References monome_monome_mult(), MONOME_NUL_P, MONOME_UNDEFINED_P, polynome_dup(), polynome_monome, POLYNOME_NUL, POLYNOME_NUL_P, polynome_succ, POLYNOME_UNDEFINED, and POLYNOME_UNDEFINED_P.

Referenced by polynome_mult(), and polynome_var_subst().

00266 {
00267     Ppolynome curpp, ppdup;
00268     if (POLYNOME_UNDEFINED_P(pp) || MONOME_UNDEFINED_P(pm))
00269         return (POLYNOME_UNDEFINED);
00270     else if (POLYNOME_NUL_P(pp) || MONOME_NUL_P(pm))
00271         return (POLYNOME_NUL);
00272     else {
00273         ppdup = polynome_dup(pp);
00274         for (curpp = ppdup ; curpp != POLYNOME_NUL; curpp = polynome_succ(curpp))
00275             monome_monome_mult(&(polynome_monome(curpp)), pm);
00276         return (ppdup);
00277     }
00278 }

Here is the call graph for this function:

Here is the caller graph for this function:

Ppolynome polynome_mult ( Ppolynome  ,
Ppolynome   
)

Ppolynome polynome_mult(Ppolynome pp1, Ppolynome pp2) returns pp1 * pp2.

Definition at line 284 of file pnome-bin.c.

References polynome_add(), polynome_monome, polynome_monome_mult(), POLYNOME_NUL, POLYNOME_NUL_P, polynome_rm(), polynome_succ, POLYNOME_UNDEFINED, and POLYNOME_UNDEFINED_P.

Referenced by complexity_mult(), mapping_on_broadcast(), plc_make_distance(), plc_make_proto(), polynome_power_n(), polynome_sigma(), and pu_expression_to_polynome().

00286 {
00287     Ppolynome mp2 = POLYNOME_UNDEFINED;
00288 
00289     if (POLYNOME_UNDEFINED_P(pp1) || POLYNOME_UNDEFINED_P(pp2))
00290         return (POLYNOME_UNDEFINED);
00291     if (POLYNOME_NUL_P(pp1) || POLYNOME_NUL_P(pp2))
00292         return (POLYNOME_NUL);
00293     else {
00294         Ppolynome pppartiel, ppresult = POLYNOME_NUL;
00295 
00296         for (mp2 = pp2 ; mp2 != POLYNOME_NUL; mp2 = polynome_succ(mp2)) {
00297             pppartiel = polynome_monome_mult(pp1, polynome_monome(mp2));
00298             polynome_add(&ppresult, pppartiel);
00299             polynome_rm(&pppartiel);
00300         }
00301         return (ppresult);
00302     }
00303 }

Here is the call graph for this function:

Here is the caller graph for this function:

void polynome_negate ( Ppolynome *  ppp  ) 

pnome-unaires.c

pnome-unaires.c

!usage: polynome_negate(&pp);

Parameters:
ppp pp

Definition at line 42 of file pnome-unaires.c.

References monome_coeff, polynome_monome, POLYNOME_NUL, POLYNOME_NUL_P, polynome_succ, and POLYNOME_UNDEFINED_P.

Referenced by make_causal_external(), make_causal_internal(), plc_make_distance(), polynome_sigma(), and pu_expression_to_polynome().

00044 {
00045     Ppolynome curpp;
00046 
00047     if ( !POLYNOME_UNDEFINED_P(*ppp) && !POLYNOME_NUL_P(*ppp) )
00048         for(curpp = *ppp; curpp != POLYNOME_NUL; curpp = polynome_succ(curpp))
00049             monome_coeff(polynome_monome(curpp)) = - monome_coeff(polynome_monome(curpp));
00050 }

Here is the caller graph for this function:

Ppolynome polynome_opposed ( Ppolynome  pp  ) 

Ppolynome polynome_opposed(Ppolynome pp); changes sign of polynomial pp.

!usage: pp = polynome_negate(pp);

Parameters:
pp p

Definition at line 56 of file pnome-unaires.c.

References monome_coeff, polynome_monome, POLYNOME_NUL, POLYNOME_NUL_P, polynome_succ, and POLYNOME_UNDEFINED_P.

Referenced by complexity_sub().

00058 {
00059     Ppolynome curpp;
00060 
00061     if ( !POLYNOME_UNDEFINED_P(pp) && !POLYNOME_NUL_P(pp) )
00062         for(curpp = pp; curpp != POLYNOME_NUL; curpp = polynome_succ(curpp))
00063             monome_coeff(polynome_monome(curpp)) = - monome_coeff(polynome_monome(curpp));
00064 
00065     return pp;
00066 }

Here is the caller graph for this function:

Ppolynome polynome_power_n ( Ppolynome  pp,
int  n 
)

Ppolynome polynome_power_n(Ppolynome pp, int n) returns pp ^ n (n>=0).

Modification:

  • treat n < 0 if pp is a monomail. LZ 6 Nov. 92

FI: a unique return would be welcome! No enough time for cleaning

Parameters:
pp p

Definition at line 117 of file pnome-scal.c.

References i, is_polynome_a_monome(), make_polynome(), polynome_div(), polynome_dup(), polynome_error(), polynome_mult(), POLYNOME_NUL, POLYNOME_NUL_P, polynome_rm(), POLYNOME_UNDEFINED, POLYNOME_UNDEFINED_P, TCST, and VALUE_ONE.

Referenced by polynome_sigma(), polynome_sum_of_power(), polynome_var_subst(), and power_op_handler().

00120 {
00121     if (POLYNOME_UNDEFINED_P(pp)) 
00122         return (POLYNOME_UNDEFINED);
00123     else if (POLYNOME_NUL_P(pp)) {
00124         if(n>0)
00125             return POLYNOME_NUL;
00126         else if (n == 0)
00127             return make_polynome(1.0, TCST, VALUE_ONE);
00128         else
00129             return POLYNOME_UNDEFINED;
00130     }
00131     else if (n < 0) {
00132         if ( is_polynome_a_monome(pp) ) {
00133             int i,m=-n;
00134             Ppolynome pptemp, ppresult = polynome_dup(pp);
00135 
00136             for(i = 1; i < m; i++)      {
00137                 pptemp = polynome_mult(ppresult, pp);
00138                 polynome_rm(&ppresult);
00139                 ppresult = pptemp;
00140             }
00141             return(polynome_div(make_polynome(1.0, TCST, VALUE_ONE), 
00142                                 ppresult));
00143         }
00144         else
00145             polynome_error("polynome_power_n",
00146                            "negative power n=%d"
00147                            " and polynome is not a monome\n",n);
00148     }
00149     else if (n == 0) 
00150         return(make_polynome(1.0, TCST, VALUE_ONE));
00151     else if (n == 1) 
00152         return(polynome_dup(pp));
00153     else if (n > 1) {
00154         int i;
00155         Ppolynome pptemp, ppresult = polynome_dup(pp);
00156 
00157         for(i = 1; i < n; i++)  {
00158             pptemp = polynome_mult(ppresult, pp);
00159             polynome_rm(&ppresult);
00160             ppresult = pptemp;
00161         }
00162         return(ppresult);
00163     }
00164     /* FI: a unique return would be welcome! No enough time for cleaning */
00165     polynome_error("polynome_power_n", "Cannot happen!\n");
00166     return POLYNOME_UNDEFINED;
00167 }

Here is the call graph for this function:

Here is the caller graph for this function:

void polynome_rm ( Ppolynome *   ) 

void polynome_rm(Ppolynome* ppp) frees space occupied by polynomial *ppp returns *ppp pointing to POLYNOME_NUL !usage: polynome_rm(&pp);

correct?

Definition at line 174 of file pnome-alloc.c.

References free(), monome_rm(), polynome_monome, POLYNOME_NUL, polynome_succ, and POLYNOME_UNDEFINED_P.

Referenced by complexity_float_add(), complexity_sigma(), cutting_conditions(), make_causal_external(), make_causal_internal(), make_single_var_complexity(), number_replaces_var(), polynome_add(), polynome_gen_free(), polynome_monome_add(), polynome_monome_addition(), polynome_mult(), polynome_power_n(), polynome_scalar_mult(), polynome_sigma(), polynome_sum_of_power(), polynome_var_subst(), power_op_handler(), and reference_to_polynome().

00176 {
00177     Ppolynome pp1 = *ppp, pp2;
00178 
00179     if (!POLYNOME_UNDEFINED_P(*ppp)) {
00180         while (pp1 != POLYNOME_NUL) {
00181             pp2 = polynome_succ(pp1);
00182             monome_rm(&polynome_monome(pp1));
00183             free((char *) pp1);               /* correct? */
00184             pp1 = pp2;
00185         }
00186         *ppp = POLYNOME_NUL;
00187     }
00188 }

Here is the call graph for this function:

Here is the caller graph for this function:

void polynome_scalar_add ( Ppolynome *  ,
double   
)
Ppolynome polynome_scalar_addition ( Ppolynome  ,
double   
)
void polynome_scalar_mult ( Ppolynome *  ,
double   
)

pnome-scal.c

Ppolynome polynome_scalar_multiply ( Ppolynome  ,
double   
)
Ppolynome polynome_sigma ( Ppolynome  pp,
Variable  var,
Ppolynome  ppinf,
Ppolynome  ppsup 
)

Ppolynome polynome_sigma(Ppolynome pp, Variable var, Ppolynome ppinf, ppsup) returns the sum of pp when its variable var is moving from ppinf to ppsup.

Neither ppinf nor ppsup must contain variable var.

compute: sum(ppinf,ppsup) ppfact * x ^ i as: ppfact * ( sum(1, ppsup) x ^ i - sum(1, ppinf) x ^ i + ppfin ^ i ) where: ppfact is the term associated to x ^ i in pp

Note that this decomposition is correct wrt standard mathematical notations if and only if: ppsup >= ppinf >= 1 although the correct answer can be obtained when ppsup >= ppinf

Thus: sum(1, ppsup) x ^ i is extended for ppsup < 1 and defined as:

  • (sum(ppsup, -1) x ^ i)

LZ: if ppinf == 1: no need to compute next sigma (pptemp), nor ppinf^i (FI: apparently not implemented)

ppacc = sigma{1,ppsup} - sigma{1,ppinf}

ppacc == (sigma{k=1,ppsup} k^i) - (sigma{k=1,ppinf} k^i)

Parameters:
pp p
var ar
ppinf pinf
ppsup psup

Definition at line 146 of file pnome-unaires.c.

References i, polynome_add(), polynome_degree(), polynome_factorize(), polynome_mult(), polynome_negate(), POLYNOME_NUL, POLYNOME_NUL_P, polynome_power_n(), polynome_rm(), polynome_sum_of_power(), POLYNOME_UNDEFINED, and POLYNOME_UNDEFINED_P.

Referenced by complexity_sigma().

00150 {
00151     Ppolynome ppacc, pptemp, ppfact, ppresult = POLYNOME_NUL;
00152     int i;
00153 
00154     if (POLYNOME_UNDEFINED_P(pp) || POLYNOME_UNDEFINED_P(ppinf)
00155         || POLYNOME_UNDEFINED_P(ppsup)) 
00156         return (POLYNOME_UNDEFINED);
00157 
00158     for(i = 0; i <= polynome_degree(pp, var); i++) {
00159         /* compute:
00160          *     sum(ppinf,ppsup) ppfact * x ^ i 
00161          * as:
00162          *     ppfact * ( sum(1, ppsup) x ^ i -
00163          *                sum(1, ppinf) x ^ i +
00164          *                ppfin ^ i )
00165          * where:
00166          * ppfact is the term associated to x ^ i in pp
00167          *
00168          * Note that this decomposition is correct wrt standard
00169          * mathematical notations if and only if:
00170          *     ppsup >= ppinf >= 1
00171          * although the correct answer can be obtained when
00172          *     ppsup >= ppinf
00173          *
00174          * Thus:
00175          *      sum(1, ppsup) x ^ i
00176          * is extended for ppsup < 1 and defined as:
00177          *      - (sum(ppsup, -1) x ^ i)
00178          */
00179         ppfact = polynome_factorize(pp, var, i);
00180 
00181         if (!POLYNOME_NUL_P(ppfact)) {
00182             ppacc  = polynome_sum_of_power(ppsup, i);
00183             /* LZ: if ppinf == 1: no need to compute next sigma (pptemp), 
00184              * nor ppinf^i (FI: apparently not implemented) */
00185             pptemp = polynome_sum_of_power(ppinf, i);
00186 
00187             polynome_negate(&pptemp);
00188             polynome_add(&ppacc, pptemp);
00189             /* ppacc = sigma{1,ppsup} - sigma{1,ppinf} */
00190             polynome_rm(&pptemp);
00191 
00192             /* ppacc == (sigma{k=1,ppsup} k^i) - (sigma{k=1,ppinf} k^i)  */
00193 
00194             pptemp = polynome_power_n(ppinf, i);
00195             polynome_add(&ppacc, pptemp);
00196             polynome_rm(&pptemp);
00197 
00198             pptemp = polynome_mult(ppfact, ppacc);
00199 
00200             polynome_add(&ppresult, pptemp);
00201 
00202             polynome_rm(&pptemp);
00203             polynome_rm(&ppacc);
00204         }
00205     }
00206     return(ppresult);
00207 }

Here is the call graph for this function:

Here is the caller graph for this function:

Ppolynome polynome_sort ( Ppolynome *  ,
int(*)(Pvecteur *, Pvecteur *)   
)
char* polynome_sprint ( Ppolynome  ,
char *  *)(Variable,
int(*)(Pvecteur *, Pvecteur *)   
)
Ppolynome polynome_sscanf ( char *  sp,
Variable(*)(Variable)  name_to_variable 
)

Ppolynome polynome_sscanf(char *sp, (*name_to_variable)()) converts into polynomial structure the expression passed in ASCII form in string sp.

(for debug only) pas vraiment quick mais bien dirty

printf(stderr, "\ns='%s'\n", s);

printf(stderr, "au milieu: s='%s'\n", s);

Parameters:
sp p

Definition at line 356 of file pnome-io.c.

References FALSE, float_to_value, make_monome(), MONOME_NUL_P, monome_rm(), monome_term, name_to_variable(), parse_coeff(), parse_var_name(), polynome_monome_add(), POLYNOME_NUL, remove_blanks(), s, strdup(), TRUE, VALUE_ONE, and vect_add_elem().

00359 {
00360     Ppolynome pp = POLYNOME_NUL;
00361     Pmonome curpm;
00362     boolean constructing_monome = FALSE;
00363     float coeff = 0.;
00364     char *varname;
00365     Value power;
00366     char *s;
00367 
00368     s = (char*) strdup(sp);
00369     remove_blanks(&s);
00370 
00371     while (*s != '\0')
00372     {
00373         /*fprintf(stderr, "\ns='%s'\n", s);*/
00374         power = VALUE_ONE;
00375         if (!constructing_monome) { coeff = parse_coeff(&s);
00376                                 }
00377         varname = parse_var_name(&s);
00378         if (strlen(varname)!=0) {
00379             if (*s == '^') {
00380                 s++;
00381                 power = float_to_value(parse_coeff(&s));
00382             }
00383             else 
00384                 while ((*s == '.') || (*s == '*')) s++;
00385         }
00386         else varname = (char*) strdup("TCST");
00387 
00388         if (constructing_monome) {
00389             vect_add_elem(&(monome_term(curpm)), 
00390                           name_to_variable(varname), 
00391                           power);
00392         }
00393         else {
00394             curpm = make_monome(coeff, name_to_variable(varname), power);
00395             constructing_monome = TRUE;
00396         }
00397         /*fprintf(stderr, "au milieu: s='%s'\n", s);*/
00398 
00399         if ((*s == '+') || (*s == '-'))
00400         {
00401             polynome_monome_add(&pp, curpm);
00402             monome_rm(&curpm);
00403             constructing_monome = FALSE;
00404         }
00405     }
00406     if (!MONOME_NUL_P(curpm)) {
00407         polynome_monome_add(&pp, curpm);
00408         monome_rm(&curpm);
00409     }
00410 
00411     return (pp);
00412 }

Here is the call graph for this function:

Ppolynome polynome_sum_of_power ( Ppolynome  ppsup,
int  p 
)

Ppolynome polynome_sum_of_power(Ppolynome ppsup, int p) calculates the sum of i^p for i=1 to (ppsup), returns the polynomial sigma{i=1, ppsup} (i^p).

It does the job well until p=13; after, it goes wrong (the Bernouilli numbers are computed until p=12)

if the upper bound is constant ...

lse if (cste==1) ppresult = POLYNOME_NUL;

if the upper bound is a non-constant polynomial ...

(ppsup^(p+1)) / (p+1)

1/2 * ppsup^p

computes factors p(p-1).../(2i!) incrementally

the current term of the remaining of the sum is:

Ti = (1/(2i)!)*(Bi*p*(p-1)* . *(p-2*i+2)*ppsup^(p-2*i+1))

Parameters:
ppsup psup

Definition at line 76 of file pnome-unaires.c.

References Bernouilli(), i, intpower(), make_polynome(), polynome_add(), polynome_constant_p(), polynome_dup(), polynome_error(), polynome_power_n(), polynome_rm(), polynome_scalar_mult(), polynome_TCST(), POLYNOME_UNDEFINED, POLYNOME_UNDEFINED_P, TCST, and VALUE_ONE.

Referenced by polynome_sigma().

00079 {
00080     Ppolynome ppresult, ppacc;
00081     int i;
00082 
00083     if (POLYNOME_UNDEFINED_P(ppsup)) 
00084         return (POLYNOME_UNDEFINED);
00085     if (p < 0) 
00086         polynome_error("polynome_sum_of_power", "negative power: %d\n", p);
00087     else if (p == 0) 
00088         ppresult = polynome_dup(ppsup);
00089     else {
00090         if ( polynome_constant_p(ppsup) ) {    /* if the upper bound is constant ... */
00091             double factor, result = 0;
00092             double cste = (double)polynome_TCST(ppsup);
00093             
00094             if (cste<1)
00095                 polynome_error("polynome_sum_of_power",
00096                                "compute a sum from 1 to %f!\n", (float) cste);
00097             /*else if (cste==1)
00098                 ppresult = POLYNOME_NUL;*/
00099             else {
00100                 result = intpower(cste, p) * ((double) (cste / (p+1)) + 0.5);
00101                 factor = ((double) p/2);
00102                 
00103                 for (i=1; 0<p-2*i+1; i++) {
00104                     result += (intpower(cste, p-2*i+1) 
00105                                * ((double) (Bernouilli(i) * factor)));
00106                     factor *= - ((double) (p-2*i+1)*(p-2*i)) / ((double) (2*i+1)*(2*i+2));
00107                 }
00108                 ppresult = make_polynome((float) result, TCST, VALUE_ONE);
00109             }
00110         } 
00111         else {    /* if the upper bound is a non-constant polynomial ... */
00112             float factor;
00113               /*  (ppsup^(p+1)) / (p+1)  */
00114             ppresult = polynome_power_n(ppsup, p+1);        
00115             polynome_scalar_mult(&ppresult, (float) 1/(p+1));
00116               /*  1/2 * ppsup^p  */
00117             ppacc = polynome_power_n(ppsup, p);                     
00118             polynome_scalar_mult(&ppacc, (float) 1/2);
00119             polynome_add(&ppresult, ppacc);
00120             polynome_rm(&ppacc);
00121             
00122             factor = ((float) p / 2);  
00123             /* computes factors p(p-1).../(2i!) incrementally */
00124 
00125             for (i=1; 0 < p-2*i+1; i++) {
00126                 /* the current term of the remaining of the sum is:     */
00127                 /* Ti = (1/(2i)!)*(Bi*p*(p-1)* . *(p-2*i+2)*ppsup^(p-2*i+1)) */
00128                 
00129                 ppacc = polynome_power_n(ppsup, p-2*i+1);
00130                 polynome_scalar_mult(&ppacc, (float) Bernouilli(i) * factor);
00131                 
00132                 polynome_add(&ppresult, ppacc);
00133                 polynome_rm(&ppacc);
00134                 
00135                 factor *= -((float)(p-2*i+1)*(p-2*i))/((float)(2*i+1)*(2*i+2));
00136             }
00137         }       
00138     }
00139     return(ppresult);
00140 }

Here is the call graph for this function:

Here is the caller graph for this function:

float polynome_TCST ( Ppolynome  pp  ) 

float polynome_TCST(Ppolynome pp) returns the constant term of polynomial pp.

If pp is POLYNOME_UNDEFINED: abort. [???]

polynome_TCST: polynome is undefined

Parameters:
pp p

Definition at line 156 of file pnome-reduc.c.

References assert, monome_coeff, monome_term, polynome_monome, POLYNOME_NUL, polynome_succ, POLYNOME_UNDEFINED_P, TCST, VALUE_ONE, vect_equal(), vect_new(), and vect_rm().

Referenced by complexity_TCST(), if_conv_init_statement(), old_prototype_factorize(), polynome_sum_of_power(), and prototype_factorize().

00158 {
00159     Pmonome pm;
00160     Pvecteur pvTCST = vect_new((Variable) TCST, VALUE_ONE);
00161 
00162     /* polynome_TCST: polynome is undefined */
00163     assert(!POLYNOME_UNDEFINED_P(pp));
00164     for( ; pp != POLYNOME_NUL; pp = polynome_succ(pp) ) {
00165         pm = polynome_monome(pp);
00166         if (vect_equal(pvTCST, monome_term(pm)))
00167             return(monome_coeff(pm));
00168     }
00169 
00170     vect_rm(pvTCST);
00171     return ((float) 0);
00172 
00173 }

Here is the call graph for this function:

Here is the caller graph for this function:

Pbase polynome_used_var ( Ppolynome  ,
int(*)(Pvecteur *, Pvecteur *)   
)
Ppolynome polynome_var_subst ( Ppolynome  pp,
Variable  var,
Ppolynome  ppsubst 
)

pnome-reduc.c

the monomial curpm contains the variable var.

We duplicate it, remove variable var from it,

we multiply it with ppsubst^n (where n was the

power of var), and we add the result to newpp.

Parameters:
pp p
var ar
ppsubst psubst

Definition at line 44 of file pnome-reduc.c.

References monome_del_var(), monome_rm(), monome_term, monome_to_new_polynome(), polynome_add(), polynome_monome, polynome_monome_add(), polynome_monome_mult(), POLYNOME_NUL, polynome_power_n(), polynome_rm(), polynome_succ, POLYNOME_UNDEFINED, POLYNOME_UNDEFINED_P, and vect_coeff().

Referenced by complexity_var_subst(), number_replaces_var(), and prototype_var_subst().

00048 {
00049     Ppolynome ppsubst_n, ppmult;
00050     Ppolynome newpp = POLYNOME_NUL;
00051     Pmonome curpm, newpm;
00052     int varpower;
00053     
00054     if (POLYNOME_UNDEFINED_P(pp))
00055         return (POLYNOME_UNDEFINED);
00056     else {
00057         for( ; pp != POLYNOME_NUL; pp = polynome_succ(pp)) {
00058             curpm = polynome_monome(pp);
00059             if ((varpower = (int) vect_coeff(var, monome_term(curpm))) == 0)
00060                 polynome_monome_add(&newpp, curpm);
00061             else {
00062                 /* the monomial curpm contains the variable var.  */
00063                 /* We duplicate it, remove variable var from it,  */
00064                 /* we multiply it with ppsubst^n (where n was the */
00065                 /* power of var), and we add the result to newpp. */
00066                 
00067                 if (POLYNOME_UNDEFINED_P(ppsubst))
00068                     return (POLYNOME_UNDEFINED);
00069                 else {
00070                     Ppolynome pptmp;
00071                     newpm = monome_del_var(curpm, var);
00072                     pptmp = monome_to_new_polynome(newpm);
00073 
00074                     ppsubst_n = polynome_power_n(ppsubst, varpower);
00075                     ppmult = polynome_monome_mult(ppsubst_n, newpm);
00076                     polynome_add(&newpp, ppmult);
00077 
00078                     polynome_rm(&ppmult);
00079                     polynome_rm(&ppsubst_n);
00080                     monome_rm(&newpm);
00081                 }
00082             }
00083         }
00084         return(newpp);
00085     }
00086 }

Here is the call graph for this function:

Here is the caller graph for this function:

Generated by  doxygen 1.6.2-20100208