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
struct	Spolynome

Macros
#define	POLYNOME_INCLUDED
	Warning! Do not modify this file that is automatically generated! More...
#define	monome_coeff(pm)   ((pm)->coeff)
	Macros definitions. More...
#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. More...
#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 /**below this value, a float is null */
#define	PNOME_FLOAT_N_DECIMALES   2 /**nb of figures after point for coeffs */
#define	PNOME_FLOAT_TO_EXP_LEVEL   1E8 /**numbers >1E8 are printed with exponent */
#define	PNOME_FLOAT_TO_FRAC_LEVEL   9 /**print 1/2..1/9 rather than 0.50..0.11 */

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

Functions
Pmonome	new_monome (void)
	POLYNOME_INCLUDED. More...
Ppolynome	new_polynome (void)
	allocation of an unitialized polynome (to avoid various direct unchecked call to malloc) More...
Pmonome	make_monome (float, Variable, Value)
	Pmonome make_monome(float coeff, Variable var, Value expo) PRIVATE allocates space for, and creates, the monome "coeff*var^expo". More...
Ppolynome	make_polynome (float, Variable, Value)
	Ppolynome make_polynome(float coeff, Variable var, Value expo) PRIVATE allocates space for, and creates, the polynome "coeff*var^expo". More...
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. More...
Pmonome	monome_dup (Pmonome)
	Pmonome monome_dup(Pmonome pm) PRIVATE creates and returns a copy of pm. More...
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); More...
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); More...
Ppolynome	polynome_free (Ppolynome)
	Ppolynome polynome_free(Ppolynome pp) frees space occupied by polynomial pp returns pp == POLYNOME_NUL !usage: polynome_rm(pp);. More...
Ppolynome	polynome_dup (Ppolynome)
	Ppolynome polynome_dup(Ppolynome pp) creates and returns a copy of pp. More...
void	polynome_monome_add (Ppolynome *, Pmonome)
	pnome-bin.c More...
Ppolynome	polynome_monome_addition (Ppolynome, Pmonome)
	Ppolynome polynome_monome_addition(Ppolynome pp, Pmonome pm) PRIVATE Add monomial pm to polynomial pp, in place. More...
void	polynome_add (Ppolynome *, Ppolynome)
	void polynome_add(Ppolynome* ppp, Ppolynome pp2) (*ppp) = (*ppp) + pp2. More...
Ppolynome	polynome_addition (Ppolynome, Ppolynome)
	Ppolynome polynome_addition(Ppolynome pp, Ppolynome pp2) pp = pp + pp2. More...
Ppolynome	polynome_monome_mult (Ppolynome, Pmonome)
	Ppolynome polynome_monome_mult(Ppolynome pp, Pmonome pm) PRIVATE returns pp * pm. More...
Ppolynome	polynome_mult (Ppolynome, Ppolynome)
	Ppolynome polynome_mult(Ppolynome pp1, Ppolynome pp2) returns pp1 * pp2. More...
Pmonome	monome_monome_div (Pmonome, Pmonome)
	Pmonome monome_monome_div(Pmonome pm1, Pmonome pm2) PRIVATE (pm1) = (pm1) / pm2. More...
Ppolynome	polynome_monome_div (Ppolynome, Pmonome)
	Ppolynome polynome_monome_div(Ppolynome pp, Pmonome pm) PRIVATE returns p = pp / pm. More...
Ppolynome	polynome_div (Ppolynome, Ppolynome)
	Ppolynome polynome_div(Ppolynome pp1, Ppolynome pp2) returns p = pp1 / pp2. More...
Ppolynome	vecteur_to_polynome (Pvecteur)
	=========================================================================== More...
void	polynome_error (const char *, char *,...)
	pnome-error.c More...
void	good_polynome_assert (char *,...)
	void good_polynome_assert(va_alist) Check if the second argument is a valid polynomial. More...
bool	monome_check (Pmonome)
	bool monome_check(Pmonome pm) Return true if all's right. More...
bool	polynome_check (Ppolynome)
	bool polynome_check(Ppolynome pp) Return true if all's right. More...
bool	is_polynome_a_monome (Ppolynome)
	bool is_polynome_a_monome(Ppolynome pp) Return true if the pp is just a monome. More...
void	float_to_frac (double, char **)
	pnome-io.c More...
void	monome_fprint (FILE *, Pmonome, Pbase, bool, char *(*)(Variable))
char *	monome_sprint (Pmonome, Pbase, bool, 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. More...
int	default_is_inferior_var (Variable, Variable)
	bool default_is_inferior_var(Variable var1, Variable var2) return true if var1 is before var2, lexicographically, according to the "default_variable_name" naming. More...
int	default_is_inferior_varval (Pvecteur, Pvecteur)
	bool default_is_inferior_varval(Pvecteur varval1, Pvecteur varval2) return true if var1 is before var2, lexicographically, according to the "default_variable_name" naming. More...
int	default_is_inferior_pvarval (Pvecteur *, Pvecteur *)
	bool default_is_inferior_pvarval(Pvecteur * pvarval1, Pvecteur * pvarval2) return true if var1 is before var2, lexicographically, according to the "default_variable_name" naming. More...
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. More...
Pmonome	monome_del_var (Pmonome, Variable)
	pnome-private.c More...
bool	monome_colin (Pmonome, Pmonome)
	bool monome_colin(Pmonome pm1, Pmonome pm2) PRIVATE returns true if the two monomials are "colinear": same variables, same exponents. More...
bool	monome_equal (Pmonome, Pmonome)
	bool monome_equal(Pmonome pm1, Pmonome pm2) PRIVATE returns true if the two monomials are equal same coeff., same variables, same exponents. More...
float	Bernouilli (int)
	float Bernouilli(int i) PRIVATE returns Bi = i-th Bernouilli number More...
int	factorielle (int)
	int factorielle (int n) PRIVATE returns n! More...
double	intpower (double, int)
	double intpower(double d, int n) returns d^n for all integers n More...
bool	is_inferior_monome (Pmonome, Pmonome, int(*)(Pvecteur *, Pvecteur *))
Ppolynome	polynome_var_subst (Ppolynome, Variable, Ppolynome)
	pnome-reduc.c More...
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. More...
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... More...
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. More...
float	polynome_TCST (Ppolynome)
	float polynome_TCST(Ppolynome pp) returns the constant term of polynomial pp. More...
bool	polynome_constant_p (Ppolynome)
	bool polynome_constant_p(Ppolynome pp) return true if pp is a constant polynomial (including null polynomial) If pp is POLYNOME_UNDEFINED: abort. More...
Pbase	polynome_used_var (Ppolynome, int(*)(Pvecteur *, Pvecteur *))
bool	polynome_contains_var (Ppolynome, Variable)
	bool polynome_contains_var(Ppolynome pp, Variable var) PRIVATE returns true if variable var is in polynomial pp. More...
bool	polynome_equal (Ppolynome, Ppolynome)
	bool polynome_equal(Ppolynome pp1, Ppolynome pp2) return (pp1 == pp2) >>>TO BE CONTINUED<<< More...
void	polynome_scalar_mult (Ppolynome *, double)
	pnome-scal.c More...
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) More...
Ppolynome	polynome_nth_root (Ppolynome, int)
	computes the n-root of polynomial if possible, that is if all exponents are multiple of n return POLYNOME_UNDEFINED if not possible symbolically More...
Ppolynome	number_replaces_var (Ppolynome, Variable, double)
Ppolynome	polynome_incr (Ppolynome)
	Ppolynome polynome_incr(Ppolynome pp) returns pp + 1. More...
Ppolynome	polynome_decr (Ppolynome)
	Ppolynome polynome_decr(Ppolynome pp) returns pp - 1. More...
Pvecteur	polynome_roots (Ppolynome, Variable)
	pnome-root.c More...
void	polynome_negate (Ppolynome *)
	pnome-unaires.c More...
Ppolynome	polynome_opposed (Ppolynome)
	Ppolynome polynome_opposed(Ppolynome pp); changes sign of polynomial pp. More...
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). More...
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. More...
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 More...

Macro Definition Documentation

is_single_monome

#define is_single_monome

(

pp

)

((!POLYNOME_NUL_P(pp)) && (POLYNOME_NUL_P(polynome_succ(pp))))

Definition at line 157 of file polynome.h.

MAX_NAME_LENGTH

#define MAX_NAME_LENGTH   50

Definition at line 181 of file polynome.h.

monome_coeff

#define monome_coeff

(

pm

)

((pm)->coeff)

Macros definitions.

Definition at line 150 of file polynome.h.

MONOME_COEFF_MULTIPLY_SYMBOL

#define MONOME_COEFF_MULTIPLY_SYMBOL   "*"

Definition at line 174 of file polynome.h.

monome_constant_new

#define monome_constant_new

(

coeff

)

make_monome(coeff, TCST, 1)

Definition at line 159 of file polynome.h.

MONOME_CONSTANT_P

#define MONOME_CONSTANT_P

(

pm

)

(term_cst((pm)->term))

Definition at line 167 of file polynome.h.

MONOME_NUL

#define MONOME_NUL   ((Pmonome) -256)

Null/undefined, monomial/polynomial definitions.

Definition at line 163 of file polynome.h.

MONOME_NUL_P

#define MONOME_NUL_P

(

pm

)

((pm)==MONOME_NUL)

Definition at line 164 of file polynome.h.

MONOME_NUL_SYMBOL

#define MONOME_NUL_SYMBOL   "<monome nul>"

Definition at line 178 of file polynome.h.

monome_power1_new

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

Definition at line 160 of file polynome.h.

monome_term

#define monome_term

(

pm

)

((pm)->term)

Definition at line 151 of file polynome.h.

MONOME_UNDEFINED

#define MONOME_UNDEFINED   ((Pmonome) -252)

Definition at line 165 of file polynome.h.

MONOME_UNDEFINED_P

#define MONOME_UNDEFINED_P

(

pm

)

((pm)==MONOME_UNDEFINED)

Definition at line 166 of file polynome.h.

MONOME_UNDEFINED_SYMBOL

#define MONOME_UNDEFINED_SYMBOL   "<monome undefined>"

Definition at line 179 of file polynome.h.

MONOME_VAR_MULTIPLY_SYMBOL

#define MONOME_VAR_MULTIPLY_SYMBOL   "."

Definition at line 175 of file polynome.h.

PNOME_FLOAT_N_DECIMALES

#define PNOME_FLOAT_N_DECIMALES   2 /**nb of figures after point for coeffs */

Definition at line 184 of file polynome.h.

PNOME_FLOAT_TO_EXP_LEVEL

#define PNOME_FLOAT_TO_EXP_LEVEL   1E8 /**numbers >1E8 are printed with exponent */

Definition at line 185 of file polynome.h.

PNOME_FLOAT_TO_FRAC_LEVEL

#define PNOME_FLOAT_TO_FRAC_LEVEL   9 /**print 1/2..1/9 rather than 0.50..0.11 */

Definition at line 186 of file polynome.h.

PNOME_MACH_EPS

#define PNOME_MACH_EPS   1E-8 /**below this value, a float is null */

Definition at line 183 of file polynome.h.

POLYNOME_INCLUDED

#define POLYNOME_INCLUDED

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 polynome-local.h

Definition at line 136 of file polynome.h.

polynome_monome

#define polynome_monome

(

pp

)

((pp)->monome)

Definition at line 152 of file polynome.h.

POLYNOME_NUL

#define POLYNOME_NUL   ((Ppolynome) NULL)

Definition at line 169 of file polynome.h.

POLYNOME_NUL_P

#define POLYNOME_NUL_P

(

pp

)

((pp)==POLYNOME_NUL)

Definition at line 170 of file polynome.h.

POLYNOME_NUL_SYMBOL

#define POLYNOME_NUL_SYMBOL   "0"

Definition at line 176 of file polynome.h.

polynome_succ

#define polynome_succ

(

pp

)

((pp)->succ)

Definition at line 153 of file polynome.h.

POLYNOME_UNDEFINED

#define POLYNOME_UNDEFINED   ((Ppolynome) -248)

Definition at line 171 of file polynome.h.

POLYNOME_UNDEFINED_P

#define POLYNOME_UNDEFINED_P

(

pp

)

((pp)==POLYNOME_UNDEFINED)

Definition at line 172 of file polynome.h.

POLYNOME_UNDEFINED_SYMBOL

#define POLYNOME_UNDEFINED_SYMBOL   "<polynome undefined>"

Definition at line 177 of file polynome.h.

Typedef Documentation

Pmonome

typedef struct Smonome * Pmonome

Ppolynome

typedef struct Spolynome * Ppolynome

Smonome

typedef struct Smonome Smonome

Spolynome

typedef struct Spolynome Spolynome

Function Documentation

Bernouilli()

float Bernouilli

(

int

i

)

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 108 of file pnome-private.c.

{
    switch (i) {
    case  1: return((float) 1/6);
    case  2: return((float) 1/30);
    case  3: return((float) 1/42);
    case  4: return((float) 1/30);
    case  5: return((float) 5/66);
    case  6: return((float) 691/2730);
    case  7: return((float) 7/6); 
    case  8: return((float) 3617/510);
    case  9: return((float) 43867/798);
    case 10: return((float) 174611/330);
    case 11: return((float) 854513/138);
    case 12: return((float) 236364091/2730);
    default: polynome_error("Bernouilli(i)", "i=%d illegal\n", i);
        /* later, we could compute bigger Bernouilli(i) with the recurrence */
    }
    /* To please the gcc compiler */
    return 0.;
}

References polynome_error().

Referenced by polynome_sum_of_power().

Here is the call graph for this function:

Here is the caller graph for this function:

default_is_inferior_pvarval()

int default_is_inferior_pvarval	(	Pvecteur *	pvarval1,
		Pvecteur *	pvarval2
	)

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

Parameters

pvarval1	varval1
pvarval2	varval2

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

{
    return strcmp(default_variable_name(vecteur_var(* pvarval1)),
                       default_variable_name(vecteur_var(* pvarval2)));
}

References default_variable_name(), and vecteur_var.

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

Here is the call graph for this function:

Here is the caller graph for this function:

default_is_inferior_var()

int default_is_inferior_var	(	Variable	var1,
		Variable	var2
	)

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

Parameters

var1	ar1
var2	ar2

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

{
    return strcmp(default_variable_name(var1), 
                       default_variable_name(var2));
}

References default_variable_name().

Here is the call graph for this function:

default_is_inferior_varval()

int default_is_inferior_varval	(	Pvecteur	varval1,
		Pvecteur	varval2
	)

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

Parameters

varval1	arval1
varval2	arval2

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

{
    return strcmp(default_variable_name(vecteur_var(varval1)),
                       default_variable_name(vecteur_var(varval2)));
}

References default_variable_name(), and vecteur_var.

Here is the call graph for this function:

default_variable_name()

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 242 of file pnome-io.c.

{
    char *s = (char *) malloc(6);
    int i = (intptr_t) var;
    
    if (var != TCST) {
        sprintf(s, "V%c%c%c%c",
                (char) 93 + (i % 26),
                (char) 93 + ((i / 26) % 26),
                (char) 93 + ((i / 26 / 26) % 26),
                (char) 93 + ((i / 26 / 26 / 26) % 26));
    }
    else 
        sprintf(s, "TCST");
    return(s);
}

References intptr_t, malloc(), and TCST.

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

Here is the call graph for this function:

Here is the caller graph for this function:

factorielle()

int factorielle

(

int

n

)

int factorielle (int n) PRIVATE returns n!

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

{
    int fact = -1;
 
    if (n<0) 
        polynome_error("factorielle", "n=%d", n);
    else if (n<2) 
        fact = 1;
    else 
        fact = factorielle(n-1) * n;
 
    return fact;
}

References polynome_error().

Referenced by average_probability_matrix().

Here is the call graph for this function:

Here is the caller graph for this function:

float_to_frac()

void float_to_frac	(	double	,
		char **
	)

pnome-io.c

good_polynome_assert()

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 84 of file pnome-error.c.

{
    va_list args;
    Ppolynome pp;
 
    va_start(args, function);
    pp = va_arg(args, Ppolynome);
 
    if (polynome_check(pp)) return;
 
    fprintf(stderr, "Bad internal polynomial representation in %s\n", function);
    va_end(args);
    abort();
}

References abort, fprintf(), and polynome_check().

Referenced by polynome_monome_add(), and polynome_monome_addition().

Here is the call graph for this function:

Here is the caller graph for this function:

intpower()

double intpower	(	double	d,
		int	n
	)

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

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

{
    if (n>0) 
        return (intpower(d, n-1) * d);
    else if (n==0) 
        return((double) 1);
    else 
        return (intpower(d, n+1) / d);
}

Referenced by float_to_frac(), and polynome_sum_of_power().

Here is the caller graph for this function:

is_inferior_monome()

bool is_inferior_monome	(	Pmonome	,
		Pmonome	,
		int(*)(Pvecteur *, Pvecteur *)
	)

is_polynome_a_monome()

bool is_polynome_a_monome

(

Ppolynome

pp

)

bool 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 162 of file pnome-error.c.

{
    if ( ! polynome_check(pp) )
        return (false);
    else if ( pp != POLYNOME_NUL && polynome_succ(pp) == POLYNOME_NUL )
        return (true);
    else
        return (false);
}

References polynome_check(), POLYNOME_NUL, and polynome_succ.

Referenced by polynome_power_n().

Here is the call graph for this function:

Here is the caller graph for this function:

make_monome()

Pmonome make_monome	(	float	coeff,
		Variable	var,
		Value	expo
	)

Pmonome make_monome(float coeff, Variable var, Value expo) PRIVATE allocates space for, and creates, the monome "coeff*var^expo".

Parameters

coeff	oeff
var	ar
expo	xpo

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

{
  if (coeff == 0)
    return MONOME_NUL;
 
  Pmonome pm = new_monome();
  monome_coeff(pm) = coeff;
  if (value_zero_p(expo))
    monome_term(pm) = vect_new(TCST, VALUE_ONE);
  else
    monome_term(pm) = vect_new(var, expo);
 
  return pm;
}

References monome_coeff, MONOME_NUL, monome_term, new_monome(), TCST, VALUE_ONE, value_zero_p, and vect_new().

Referenced by make_polynome(), number_replaces_var(), polynome_decr(), polynome_incr(), polynome_scalar_add(), polynome_scalar_addition(), and polynome_sscanf().

Here is the call graph for this function:

Here is the caller graph for this function:

make_polynome()

Ppolynome make_polynome	(	float	coeff,
		Variable	var,
		Value	expo
	)

Ppolynome make_polynome(float coeff, Variable var, Value expo) PRIVATE allocates space for, and creates, the polynome "coeff*var^expo".

Parameters

coeff	oeff
var	ar
expo	xpo

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

{
    Pmonome m = make_monome(coeff, var, expo);
    assert(!MONOME_UNDEFINED_P(m));
    Ppolynome p = monome_to_new_polynome(m);
    return p;
}

References assert, make_monome(), monome_to_new_polynome(), and MONOME_UNDEFINED_P.

Referenced by add_constraint_on_x(), apply_farkas(), complexity_float_add(), complexity_sigma(), create_farkas_poly(), enode_to_polynome(), evalue_to_polynome(), expression_to_polynome(), make_polynome_Xe(), make_single_var_complexity(), mapping_on_broadcast(), my_vecteur_to_polynome(), old_vecteur_to_polynome(), plc_make_proto(), polynome_power_n(), polynome_sum_of_power(), pvecteur_to_polynome(), reference_to_polynome(), sc_enumerate(), vecteur_mult(), and vecteur_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

monome_check()

bool monome_check

(

Pmonome

pm

)

bool 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 110 of file pnome-error.c.

{
    if ( MONOME_UNDEFINED_P(pm) )
        return (false); 
    else if (MONOME_NUL_P(pm) )
        return (true);
    else 
        return ((monome_coeff(pm) != 0) && 
                !VECTEUR_NUL_P(monome_term(pm)) &&
                vect_check(monome_term(pm)));
}

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

Referenced by polynome_check().

Here is the call graph for this function:

Here is the caller graph for this function:

monome_colin()

bool monome_colin	(	Pmonome	pm1,
		Pmonome	pm2
	)

bool 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 77 of file pnome-private.c.

{
    if (MONOME_UNDEFINED_P(pm1) || MONOME_UNDEFINED_P(pm2)
        ||    MONOME_NUL_P(pm1) || MONOME_NUL_P(pm2))
        return(pm1 == pm2);    
    else 
        return(vect_equal(monome_term(pm1), monome_term(pm2)));
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

monome_del_var()

Pmonome monome_del_var	(	Pmonome	pm,
		Variable	var
	)

pnome-private.c

pnome-private.c

is it the only variable

now it is a constant term

Parameters

pm	m
var	ar

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

{
    if (MONOME_UNDEFINED_P(pm)) 
        return (MONOME_UNDEFINED);
    else if (MONOME_NUL_P(pm)) 
        return (MONOME_NUL);
    else {
        Pmonome newpm = new_monome();
 
        monome_coeff(newpm) = monome_coeff(pm);
        monome_term(newpm)  = vect_del_var(monome_term(pm), var);
        if (VECTEUR_NUL_P(monome_term(newpm))) {
            /* is it the only variable */
            monome_term(newpm) = vect_new(TCST, VALUE_ONE); 
            /* now it is a constant term   */
        }
    
        return(newpm);
    }
}

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().

Here is the call graph for this function:

Here is the caller graph for this function:

monome_dup()

Pmonome monome_dup

(

Pmonome

pm

)

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

Parameters

pm

m

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

{
    if (MONOME_NUL_P(pm))
        return (MONOME_NUL);
    else if (MONOME_UNDEFINED_P(pm))
        return (MONOME_UNDEFINED);
    else {
        Pmonome pmd = new_monome();
        monome_coeff(pmd) = monome_coeff(pm);
        monome_term(pmd) = vect_dup(monome_term(pm));
        return(pmd);
    }
}

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(), polynome_monome_addition(), and polynome_roots().

Here is the call graph for this function:

Here is the caller graph for this function:

monome_equal()

bool monome_equal	(	Pmonome	pm1,
		Pmonome	pm2
	)

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

Parameters

pm1	m1
pm2	m2

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

{
    if (MONOME_UNDEFINED_P(pm1) || MONOME_UNDEFINED_P(pm2)
        ||    MONOME_NUL_P(pm1) || MONOME_NUL_P(pm2))
        return(pm1 == pm2);    
    else 
        return(vect_equal(monome_term(pm1), monome_term(pm2))
               && ((monome_coeff(pm1) == monome_coeff(pm2))));
}

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

Here is the call graph for this function:

monome_fprint()

void monome_fprint	(	FILE *	,
		Pmonome	,
		Pbase	,
		bool	,
		char *	*)(Variable
	)

monome_monome_div()

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 314 of file pnome-bin.c.

{
    if (MONOME_UNDEFINED_P(pm1))
        return (MONOME_UNDEFINED);
    else if (MONOME_UNDEFINED_P(pm2)) {
        monome_rm(&pm1);
        return (MONOME_UNDEFINED);
    }
    else if (!MONOME_NUL_P(pm1)) {
        if (MONOME_NUL_P(pm2)) {
            monome_rm(&pm1);    /* returns ppm pointing to MONOME_NUL */
            return (MONOME_UNDEFINED);
        }
        else {
            Pmonome pmr = new_monome();
 
            if (MONOME_CONSTANT_P(pm2))
                monome_term(pmr) = vect_dup(monome_term(pm1));
            else if (MONOME_CONSTANT_P(pm1)) {
                Pvecteur pv = vect_dup(monome_term(pm2));
                vect_chg_sgn(pv);
                monome_term(pmr) = pv;
                }
            else {
                monome_term(pmr) = vect_substract(monome_term(pm1), monome_term(pm2));
                if ( monome_term(pmr) == VECTEUR_NUL )
                    monome_term(pmr) = vect_new(TCST, VALUE_ONE);
            }
            monome_coeff(pmr) = monome_coeff(pm1)/monome_coeff(pm2);
 
            return (pmr);
        }
    }
    polynome_error("monome_monome_div","Unreachable...\n");
    return MONOME_UNDEFINED;
}

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().

Here is the call graph for this function:

Here is the caller graph for this function:

monome_rm()

void monome_rm

(

Pmonome *

ppm

)

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

Parameters

ppm

pm

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

{
    if ((!MONOME_NUL_P(*ppm)) && (!MONOME_UNDEFINED_P(*ppm))) {
        vect_rm((Pvecteur) monome_term(*ppm));
        free((char *) *ppm);
    }
    *ppm = MONOME_NUL;
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

monome_sprint()

char* monome_sprint	(	Pmonome	,
		Pbase	,
		bool	,
		char *	*)(Variable
	)

monome_to_new_polynome()

Ppolynome monome_to_new_polynome

(

Pmonome

pm

)

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.

Parameters

pm

m

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

{
  if (MONOME_NUL_P(pm))
    return POLYNOME_NUL;
  else if (MONOME_UNDEFINED_P(pm))
    return POLYNOME_UNDEFINED;
 
        Ppolynome pp = new_polynome();
        polynome_monome(pp) = pm;
        polynome_succ(pp) = POLYNOME_NUL;
        return pp;
}

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(), and polynome_monome_addition().

Here is the call graph for this function:

Here is the caller graph for this function:

new_monome()

Pmonome new_monome

(

void

)

POLYNOME_INCLUDED.

cproto-generated files 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 48 of file pnome-alloc.c.

{
    Pmonome pm = (Pmonome) malloc(sizeof(Smonome));
    if (pm == NULL) {
        (void) fprintf(stderr,"new_monome: Out of memory space\n");
        /* (void) fprintf(stderr, "%10.3f MB", 
                       (sbrk(0) - etext)/(double)(1 << 20)); */
        abort();
        /*exit(-1);*/
    }
    return pm;
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

new_polynome()

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 64 of file pnome-alloc.c.

{
    Ppolynome pp = (Ppolynome) malloc(sizeof(Spolynome));
    if (pp == NULL) {
        (void) fprintf(stderr,"new_polynome: Out of memory space\n");
        /* (void) fprintf(stderr, "%10.3f MB", 
           (sbrk(0) - etext)/(double)(1 << 20)); */
        abort();
        /*exit(-1);*/
    }
    return pp;
}

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

Referenced by monome_to_new_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

number_replaces_var()

Ppolynome number_replaces_var	(	Ppolynome	,
		Variable	,
		double
	)

polynome_add()

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 171 of file pnome-bin.c.

{
    if (POLYNOME_NUL_P(*ppp)) {
        if ( !POLYNOME_NUL_P(pp2))
            *ppp = polynome_dup(pp2);
        else
            *ppp = POLYNOME_NUL;
    }
    else if (POLYNOME_UNDEFINED_P(pp2)) {
        polynome_rm(ppp);
        *ppp = POLYNOME_UNDEFINED;
    }
    else if (!POLYNOME_UNDEFINED_P(*ppp)) {
        for (;pp2 != POLYNOME_NUL; pp2 = polynome_succ(pp2)) {
            polynome_monome_add(ppp, polynome_monome(pp2));
        }
    }
}

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(), do_computation_intensity(), do_solve_hardware_constraints_on_volume(), edge_cost(), edge_cost_polynome(), enode_to_polynome(), expression_to_polynome(), 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_roots(), polynome_sigma(), polynome_sum_of_power(), polynome_var_subst(), size_of_regions(), and vecteur_mult().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_addition()

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 195 of file pnome-bin.c.

{
    Ppolynome newpp = POLYNOME_UNDEFINED;
 
    if (POLYNOME_NUL_P(pp)) {
        if ( !POLYNOME_NUL_P(pp2))
            newpp = polynome_dup(pp2);
        else
            newpp = POLYNOME_NUL;
    }
    else if (POLYNOME_UNDEFINED_P(pp2)) {
        pp = polynome_free(pp);
        newpp = POLYNOME_UNDEFINED;
    }
    else if (!POLYNOME_UNDEFINED_P(pp)) {
        newpp = pp;
        for (;pp2 != POLYNOME_NUL; pp2 = polynome_succ(pp2)) {
            newpp = polynome_monome_addition(newpp, polynome_monome(pp2));
        }
    }
    return newpp;
}

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(), complexity_sub(), and polynome_roots().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_check()

bool polynome_check

(

Ppolynome

pp

)

bool 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 131 of file pnome-error.c.

{
    if ( POLYNOME_UNDEFINED_P(pp) )
        return (false);
    if ( POLYNOME_NUL_P(pp) )
        return (true);
    else {
        Ppolynome curpp, curpp2;
 
        for (curpp = pp; curpp != POLYNOME_NUL; curpp = polynome_succ(curpp)) {
            if ( !monome_check(polynome_monome(curpp)) ) {
                return (false);
            }
            for (curpp2 = polynome_succ(curpp); curpp2 != POLYNOME_NUL;
                 curpp2 = polynome_succ(curpp2))
                if (monome_colin(polynome_monome(curpp),polynome_monome(curpp2))) 
                    return (false);
        }
        return (true);
    }
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_chg_var()

void polynome_chg_var	(	Ppolynome *	ppp,
		Variable	v_old,
		Variable	v_new
	)

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?

Parameters

ppp	pp
v_old	_old
v_new	_new

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

{
    Ppolynome ppcur;
 
    for (ppcur = *ppp; ppcur != POLYNOME_NUL; ppcur = polynome_succ(ppcur)) {
        Pmonome pmcur = polynome_monome(ppcur);
        /* Should it be comparated against MONOME_NUL (that is different
           of 0) instead? */
        if ( pmcur != NULL ) {
            Pvecteur pvcur = monome_term(pmcur);
 
            vect_chg_var(&pvcur,v_old,v_new);
        }
    }
}

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

Here is the call graph for this function:

polynome_constant_p()

bool polynome_constant_p

(

Ppolynome

pp

)

bool 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.

{
    /* polynome_constant_p: polynome is undefined */
    assert(!POLYNOME_UNDEFINED_P(pp));
 
    if (POLYNOME_NUL_P(pp)) 
        return(true);
    else {
        Pvecteur pvTCST = vect_new((Variable) TCST, VALUE_ONE);
        bool b = (vect_equal(pvTCST, monome_term(polynome_monome(pp)))
                     && (polynome_succ(pp) == POLYNOME_NUL));
 
        vect_rm(pvTCST);
        return(b);
    }
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_contains_var()

bool polynome_contains_var	(	Ppolynome	pp,
		Variable	var
	)

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

Parameters

pp	p
var	ar

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

{
    if ( POLYNOME_UNDEFINED_P(pp) )
        return (false);
    else {
        for ( ; pp != POLYNOME_NUL; pp = polynome_succ(pp))
            if (vect_coeff(var, monome_term(polynome_monome(pp))) != 0)
                return (true);
        return(false);
    }
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_decr()

Ppolynome polynome_decr

(

Ppolynome

pp

)

Ppolynome polynome_decr(Ppolynome pp) returns pp - 1.

pp is NOT duplicated.

Parameters

pp

p

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

{
    if (POLYNOME_UNDEFINED_P(pp)) 
        return (POLYNOME_UNDEFINED);
    else {
        Pmonome minus_one = make_monome(-1.0, TCST, VALUE_ONE);
 
        polynome_monome_add(&pp, minus_one);
        monome_rm(&minus_one);
 
        return(pp);
    }
}

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().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_degree()

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.

{
    int power, deg = 0;
 
    /* polynome_degree: polynome is undefined */
    assert(!POLYNOME_UNDEFINED_P(pp));
    for( ; pp != POLYNOME_NUL; pp = polynome_succ(pp)) {
        power = (int) vect_coeff(var, monome_term(polynome_monome(pp)));
        if (deg < power) deg = power;
    }
    return(deg);
}

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

Referenced by polynome_roots(), and polynome_sigma().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_div()

Ppolynome polynome_div	(	Ppolynome	pp1,
		Ppolynome	pp2
	)

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

Parameters

pp1	p1
pp2	p2

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

{
    if (POLYNOME_UNDEFINED_P(pp1) || POLYNOME_UNDEFINED_P(pp2)
                                  || POLYNOME_NUL_P(pp2)   )
        return (POLYNOME_UNDEFINED);
    if (POLYNOME_NUL_P(pp1))
        return (POLYNOME_NUL);
    else {
        Ppolynome ppresult;
 
        if (is_single_monome(pp2)) {
            ppresult = polynome_monome_div(pp1, polynome_monome(pp2));
        }
        else {
            fprintf(stdout,"The divider has at least two elements!\n");
            exit(3);
        }
        return (ppresult);
    }
}

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(), expression_to_polynome(), polynome_power_n(), and polynome_roots().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_dup()

Ppolynome polynome_dup

(

Ppolynome

pp

)

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

Parameters

pp

p

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

{
    Ppolynome ppdup, curpp;
 
    if (POLYNOME_NUL_P(pp)) 
        return (POLYNOME_NUL);
    else if (POLYNOME_UNDEFINED_P(pp)) 
        return (POLYNOME_UNDEFINED);
    else {
        ppdup = monome_to_new_polynome(monome_dup(polynome_monome(pp)));
        curpp = ppdup;
        while ((pp = polynome_succ(pp)) != POLYNOME_NUL) {
            polynome_succ(curpp) =
                monome_to_new_polynome(monome_dup(polynome_monome(pp)));
            curpp = polynome_succ(curpp);
        }
        return (ppdup);
    }
}

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(), do_computation_intensity(), 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_nth_root(), polynome_power_n(), polynome_roots(), polynome_sum_of_power(), polynome_to_new_complexity(), polynome_to_sc(), prgm_mapping(), prototype_var_subst(), search_scc_bdt(), and valuer().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_equal()

bool polynome_equal	(	Ppolynome	pp1,
		Ppolynome	pp2
	)

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

TO BE CONTINUED

Parameters

pp1	p1
pp2	p2

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

{
    Ppolynome ppcopy1 = polynome_dup(pp1);
    Ppolynome ppcopy2 = polynome_dup(pp2);
 
    polynome_sort(&ppcopy1, default_is_inferior_pvarval);
    polynome_sort(&ppcopy2, default_is_inferior_pvarval);
    
 
    /* TO BE CONTINUED */
    polynome_error ("polynome_equal", "To be implemented!\n");
    return false;
}

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

Here is the call graph for this function:

polynome_error()

void polynome_error	(	const 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 62 of file pnome-error.c.

{
    va_list args;
 
    va_start(args, fmt);
 
    /* print name of function causing error */
    (void) fprintf(stderr, "\npolynome error in %s: ", name);
 
    /* print out remainder of message */
    (void) vfprintf(stderr, fmt, args);
    va_end(args);
 
    /* create a core file for debug */
    (void) abort();
}

References abort, and fprintf().

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

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_factorize()

Ppolynome polynome_factorize	(	Ppolynome	pp,
		Variable	var,
		int	n
	)

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

Parameters

pp	p
var	ar

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

{
    Ppolynome ppfact = POLYNOME_NUL;
    Pmonome pm;
 
    if (POLYNOME_UNDEFINED_P(pp))
        return (POLYNOME_UNDEFINED);
    else {
        for( ; pp != POLYNOME_NUL; pp = polynome_succ(pp))
            if (n == (int) vect_coeff(var, monome_term(polynome_monome(pp)))) {
                pm = monome_del_var(polynome_monome(pp), var);
                polynome_monome_add(&ppfact, pm);
            }
 
        return(ppfact);
    }
}

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().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_fprint()

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

polynome_free()

Ppolynome polynome_free

(

Ppolynome

pp

)

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

correct?

Parameters

pp

p

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

{
    Ppolynome pp1 = pp, pp2;
 
    if (!POLYNOME_UNDEFINED_P(pp)) {
        while (pp1 != POLYNOME_NUL) {
            pp2 = polynome_succ(pp1);
            monome_rm(&polynome_monome(pp1));
            free((char *) pp1);               /* correct? */
            pp1 = pp2;
        }
    }
    return POLYNOME_NUL;
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_incr()

Ppolynome polynome_incr

(

Ppolynome

pp

)

Ppolynome polynome_incr(Ppolynome pp) returns pp + 1.

pp is NOT duplicated.

Parameters

pp

p

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

{
    if (POLYNOME_UNDEFINED_P(pp)) 
        return (POLYNOME_UNDEFINED);
    else {
        Pmonome one = make_monome(1.0, TCST, VALUE_ONE);
 
        polynome_monome_add(&pp, one);
        monome_rm(&one);
 
        return(pp);
    }
}

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

Here is the call graph for this function:

polynome_max_degree()

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.

{
    int power, deg = 0;
    Ppolynome m = POLYNOME_UNDEFINED;
 
    /* polynome_degree: polynome is undefined */
    assert(!POLYNOME_UNDEFINED_P(pp));
    for(m = pp ; m != POLYNOME_NUL; m = polynome_succ(m)) {
        power = (int) vect_sum(monome_term(polynome_monome(m)));
        if (deg < power) deg = power;
    }
    return deg;
}

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

Referenced by complexity_degree(), do_computation_intensity(), and polynomial_to_numerical().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_monome_add()

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 50 of file pnome-bin.c.

{
    Ppolynome prevpp = POLYNOME_NUL;
    float coeff;
 
    if (POLYNOME_NUL_P(*ppp)) {
        *ppp = monome_to_new_polynome(monome_dup(pm));
    }
    else if (POLYNOME_UNDEFINED_P(*ppp))
        ;
    else if (MONOME_UNDEFINED_P(pm)) {
        polynome_rm(ppp);
        *ppp = POLYNOME_UNDEFINED;
    }
    else if (!MONOME_NUL_P(pm)) {
        Ppolynome curpp;
        for(curpp = *ppp; curpp != POLYNOME_NUL; prevpp = curpp,curpp = polynome_succ(curpp)) {
            if (monome_colin(polynome_monome(curpp), pm)) {
                coeff = monome_coeff(polynome_monome(curpp)) + monome_coeff(pm);
                if ((coeff < PNOME_MACH_EPS) && (coeff > -PNOME_MACH_EPS)) {
                    /* This monomial is null now. We free it */
                    if (curpp == *ppp) 
                        *ppp = polynome_succ(*ppp);
                    else 
                        polynome_succ(prevpp) = polynome_succ(curpp);
                    polynome_succ(curpp) = POLYNOME_NUL;
                    polynome_rm(&curpp);
                    curpp = ( prevpp==POLYNOME_NUL ? *ppp : prevpp );
                    if ( curpp == POLYNOME_NUL ) /* no element in polynome */
                        *ppp = POLYNOME_NUL;
                }
                else            /* Save new value of monomial coefficient. */
                    monome_coeff(polynome_monome(curpp)) = coeff;
                break;
            }
        }
 
        if ( curpp == POLYNOME_NUL && !POLYNOME_NUL_P(*ppp) ) { 
            /* Add a copy of the monomial at the end */
            good_polynome_assert("polynome_monome_add about prevpp before",prevpp);
            if ( polynome_succ(prevpp) == POLYNOME_NUL ) {
                if ( MONOME_NUL_P(pm) || MONOME_UNDEFINED_P(pm) )
                    printf("monome is poor\n");
                else 
                    polynome_succ(prevpp) = monome_to_new_polynome(monome_dup(pm));
            }
            good_polynome_assert("polynome_monome_add about prevpp at end",prevpp);
        }
    }
    good_polynome_assert("polynome_monome_add about *ppp at end",*ppp);
}

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 do_solve_hardware_constraints_on_volume(), polynome_add(), polynome_decr(), polynome_factorize(), polynome_incr(), polynome_monome_div(), polynome_roots(), polynome_scalar_add(), polynome_sscanf(), and polynome_var_subst().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_monome_addition()

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 112 of file pnome-bin.c.

{
    Ppolynome prevpp = POLYNOME_UNDEFINED;
 
    if (POLYNOME_NUL_P(pp)) {
        pp = monome_to_new_polynome(monome_dup(pm));
    }
    else if (POLYNOME_UNDEFINED_P(pp))
        ;
    else if (MONOME_UNDEFINED_P(pm)) {
        pp = polynome_free(pp);
        pp = POLYNOME_UNDEFINED;
    }
    else if (!MONOME_NUL_P(pm)) {
        Ppolynome curpp;
        for(curpp = pp; curpp != POLYNOME_NUL; prevpp = curpp,curpp = polynome_succ(curpp)) {
            if (monome_colin(polynome_monome(curpp), pm)) {
                float coeff = monome_coeff(polynome_monome(curpp)) + monome_coeff(pm);
 
                if ((coeff < PNOME_MACH_EPS) && (coeff > -PNOME_MACH_EPS)) {
                    /* This monomial is null now. We free it */
                    if (curpp == pp) 
                        pp = polynome_succ(pp);
                    else 
                        polynome_succ(prevpp) = polynome_succ(curpp);
                    polynome_succ(curpp) = POLYNOME_NUL;
                    polynome_rm(&curpp);
                    curpp = ( prevpp==POLYNOME_NUL ? pp : prevpp );
                    if ( curpp == POLYNOME_NUL ) /* no element in polynome */
                        pp = POLYNOME_NUL;
                }
                else            /* Save new value of monomial coefficient. */
                    monome_coeff(polynome_monome(curpp)) = coeff;
                break;
            }
        }
 
        if ( curpp == POLYNOME_NUL && !POLYNOME_NUL_P(pp) ) { 
            /* Add a copy of the monomial at the end */
            good_polynome_assert("polynome_monome_add about prevpp before",prevpp);
            if ( polynome_succ(prevpp) == POLYNOME_NUL ) {
                if ( MONOME_NUL_P(pm) || MONOME_UNDEFINED_P(pm) )
                    printf("monome is poor\n");
                else 
                    polynome_succ(prevpp) = monome_to_new_polynome(monome_dup(pm));
            }
            good_polynome_assert("polynome_monome_add about prevpp at end",prevpp);
        }
    }
    good_polynome_assert("polynome_monome_add about pp at end",pp);
    return pp;
}

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().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_monome_div()

Ppolynome polynome_monome_div	(	Ppolynome	pp,
		Pmonome	pm
	)

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

Parameters

pp	p
pm	m

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

{
    if (POLYNOME_UNDEFINED_P(pp) || MONOME_UNDEFINED_P(pm))
        return (POLYNOME_UNDEFINED);
    else if (POLYNOME_NUL_P(pp) || MONOME_NUL_P(pm))
        return (POLYNOME_NUL);
    else {
        Ppolynome ppresult = POLYNOME_NUL;
        Ppolynome curpp, ppdup;
        ppdup = polynome_dup(pp);
 
        for (curpp = ppdup ; curpp != POLYNOME_NUL; curpp = polynome_succ(curpp)) {
            Pmonome pmtmp = monome_monome_div(polynome_monome(curpp), pm);
            polynome_monome_add(&ppresult,pmtmp);
        }
        return (ppresult);
    }
}

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().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_monome_mult()

Ppolynome polynome_monome_mult	(	Ppolynome	pp,
		Pmonome	pm
	)

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

Parameters

pp	p
pm	m

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

{
    Ppolynome curpp, ppdup;
    if (POLYNOME_UNDEFINED_P(pp) || MONOME_UNDEFINED_P(pm))
        return (POLYNOME_UNDEFINED);
    else if (POLYNOME_NUL_P(pp) || MONOME_NUL_P(pm))
        return (POLYNOME_NUL);
    else {
        ppdup = polynome_dup(pp);
        for (curpp = ppdup ; curpp != POLYNOME_NUL; curpp = polynome_succ(curpp))
            monome_monome_mult(&(polynome_monome(curpp)), pm);
        return (ppdup);
    }
}

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().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_mult()

Ppolynome polynome_mult	(	Ppolynome	pp1,
		Ppolynome	pp2
	)

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

Parameters

pp1	p1
pp2	p2

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

{
    Ppolynome mp2 = POLYNOME_UNDEFINED;
 
    if (POLYNOME_UNDEFINED_P(pp1) || POLYNOME_UNDEFINED_P(pp2))
        return (POLYNOME_UNDEFINED);
    if (POLYNOME_NUL_P(pp1) || POLYNOME_NUL_P(pp2))
        return (POLYNOME_NUL);
    else {
        Ppolynome pppartiel, ppresult = POLYNOME_NUL;
 
        for (mp2 = pp2 ; mp2 != POLYNOME_NUL; mp2 = polynome_succ(mp2)) {
            pppartiel = polynome_monome_mult(pp1, polynome_monome(mp2));
            polynome_add(&ppresult, pppartiel);
            polynome_rm(&pppartiel);
        }
        return (ppresult);
    }
}

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(), edge_cost_polynome(), enode_to_polynome(), expression_to_polynome(), mapping_on_broadcast(), plc_make_distance(), plc_make_proto(), polynome_power_n(), polynome_roots(), polynome_sigma(), and size_of_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_negate()

void polynome_negate

(

Ppolynome *

ppp

)

pnome-unaires.c

pnome-unaires.c

!usage: polynome_negate(&pp);

Parameters

ppp

pp

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

{
    Ppolynome curpp;
 
    if ( !POLYNOME_UNDEFINED_P(*ppp) && !POLYNOME_NUL_P(*ppp) )
        for(curpp = *ppp; curpp != POLYNOME_NUL; curpp = polynome_succ(curpp))
            monome_coeff(polynome_monome(curpp)) = - monome_coeff(polynome_monome(curpp));
}

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

Referenced by do_computation_intensity(), expression_to_polynome(), make_causal_external(), make_causal_internal(), plc_make_distance(), polynome_roots(), and polynome_sigma().

Here is the caller graph for this function:

polynome_nth_root()

Ppolynome polynome_nth_root	(	Ppolynome	p,
		int	n
	)

computes the n-root of polynomial if possible, that is if all exponents are multiple of n return POLYNOME_UNDEFINED if not possible symbolically

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

                                                {
    Ppolynome pp = polynome_dup(p);
    for(p=pp;!POLYNOME_NUL_P(p);p=polynome_succ(p)) {
        Pmonome m = polynome_monome(p);
        Pvecteur v ;
        monome_coeff(m)=powf(monome_coeff(m),1.f/n);
        for(v = monome_term(m); !VECTEUR_NUL_P(v); v=vecteur_succ(v)) {
            if(vecteur_val(v)%n == 0) {
                vecteur_val(v)/=n; 
            }
            else if(vecteur_var(v)!=(Variable)TCST){
                polynome_rm(&pp);
                return POLYNOME_UNDEFINED;
            }
        }
    }
    return pp;
}

References monome_coeff, monome_term, polynome_dup(), polynome_monome, POLYNOME_NUL_P, polynome_rm(), polynome_succ, POLYNOME_UNDEFINED, TCST, VECTEUR_NUL_P, vecteur_succ, vecteur_val, and vecteur_var.

Referenced by polynome_roots().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_opposed()

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 59 of file pnome-unaires.c.

{
    Ppolynome curpp;
 
    if ( !POLYNOME_UNDEFINED_P(pp) && !POLYNOME_NUL_P(pp) )
        for(curpp = pp; curpp != POLYNOME_NUL; curpp = polynome_succ(curpp))
            monome_coeff(polynome_monome(curpp)) = - monome_coeff(polynome_monome(curpp));
 
    return pp;
}

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

Referenced by complexity_sub().

Here is the caller graph for this function:

polynome_power_n()

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 monomial. LZ 6 Nov. 92

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

Parameters

pp

p

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

{
    if (POLYNOME_UNDEFINED_P(pp)) 
        return (POLYNOME_UNDEFINED);
    else if (POLYNOME_NUL_P(pp)) {
        if(n>0)
            return POLYNOME_NUL;
        else if (n == 0)
            return make_polynome(1.0, TCST, VALUE_ONE);
        else
            return POLYNOME_UNDEFINED;
    }
    else if (n < 0) {
        if ( is_polynome_a_monome(pp) ) {
            int i,m=-n;
            Ppolynome pptemp, ppresult = polynome_dup(pp);
 
            for(i = 1; i < m; i++)      {
                pptemp = polynome_mult(ppresult, pp);
                polynome_rm(&ppresult);
                ppresult = pptemp;
            }
            return(polynome_div(make_polynome(1.0, TCST, VALUE_ONE), 
                                ppresult));
        }
        else
            polynome_error("polynome_power_n",
                           "negative power n=%d"
                           " and polynome is not a monome\n",n);
    }
    else if (n == 0) 
        return(make_polynome(1.0, TCST, VALUE_ONE));
    else if (n == 1) 
        return(polynome_dup(pp));
    else if (n > 1) {
        int i;
        Ppolynome pptemp, ppresult = polynome_dup(pp);
 
        for(i = 1; i < n; i++)  {
            pptemp = polynome_mult(ppresult, pp);
            polynome_rm(&ppresult);
            ppresult = pptemp;
        }
        return(ppresult);
    }
    /* FI: a unique return would be welcome! No enough time for cleaning */
    polynome_error("polynome_power_n", "Cannot happen!\n");
    return POLYNOME_UNDEFINED;
}

References 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().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_rm()

void polynome_rm

(

Ppolynome *

ppp

)

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

correct?

Parameters

ppp

pp

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

{
    Ppolynome pp1 = *ppp, pp2;
 
    if (!POLYNOME_UNDEFINED_P(*ppp)) {
        while (pp1 != POLYNOME_NUL) {
            pp2 = polynome_succ(pp1);
            monome_rm(&polynome_monome(pp1));
            free((char *) pp1);               /* correct? */
            pp1 = pp2;
        }
        *ppp = POLYNOME_NUL;
    }
}

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

Referenced by complexity_float_add(), complexity_sigma(), cutting_conditions(), do_computation_intensity(), do_solve_hardware_constraints_on_volume(), expression_to_polynome(), 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_nth_root(), polynome_power_n(), polynome_roots(), polynome_scalar_mult(), polynome_sigma(), polynome_sum_of_power(), polynome_var_subst(), power_op_handler(), reference_to_polynome(), and simplify_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_roots()

Pvecteur polynome_roots	(	Ppolynome	p,
		Variable	var
	)

pnome-root.c

pnome-root.c

should we verify the other components are equal to zero ?

gather a x var + b information

the root is -b/a

gather a x^2 + b x + c informations

compute determinant

delta =-4 a c

take its square root if possible

the roots are (-b +sqdelta) / 2a and (-b -sqdelta) / 2a

Parameters

var

ar

Definition at line 48 of file pnome-root.c.

                                                   {
    switch(polynome_degree(p,var)) {
        /* should we verify the other components are equal to zero ? */
        case 0: 
            return VECTEUR_UNDEFINED;
        /* gather a x var + b information */
        case 1: {
                    Ppolynome a = POLYNOME_NUL, b = POLYNOME_NUL,pp;
                    for(pp=p ; pp != POLYNOME_NUL; pp = polynome_succ(pp)) {
                        Pmonome m = polynome_monome(pp);
                        Value val ;
                        if((val=vect_coeff(var, monome_term(m)))!=VALUE_ZERO) {
                            Pmonome dup = monome_dup(m);
                            if(vect_size(monome_term(dup))>1)
                                vect_del_var(monome_term(dup),var);
                            else
                                vect_chg_var(&monome_term(dup),var,TCST);
                            polynome_monome_add(&a,dup);
                            monome_rm(&dup);
                        }
                        else {
                            polynome_monome_add(&b,m);
                        }
                    }
                    /* the root is -b/a */
                    polynome_negate(&b);
                    b=polynome_div(b,a);
                    polynome_rm(&a);
                    return vect_new(b,1);
                } 
        /* gather a x^2 + b x + c informations */
        case 2:{
                   Ppolynome a = POLYNOME_NUL, b = POLYNOME_NUL, c = POLYNOME_NUL, pp;
                   for(pp=p ; pp != POLYNOME_NUL; pp = polynome_succ(pp)) {
                       Pmonome m = polynome_monome(pp);
                       Value val =vect_coeff(var, monome_term(m));
                       if(val==2) {
                           Pmonome dup = monome_dup(m);
                           vect_chg_var(&monome_term(dup),var,TCST);
                           polynome_monome_add(&a,dup);
                           monome_rm(&dup);
                       }
                       else if(val == 1 ) {
                           Pmonome dup = monome_dup(m);
                           vect_chg_var(&monome_term(dup),var,TCST);
                           polynome_monome_add(&b,dup);
                           monome_rm(&dup);
                       }
                       else {
                           polynome_monome_add(&c,m);
                       }
                   }
                   /* compute determinant */
                   Ppolynome delta=polynome_mult(a,c),tmp;
                   delta=polynome_scalar_multiply(delta,4);
                   polynome_negate(&delta);/* delta =-4 a c*/
                   tmp=polynome_mult(b,b);
                   polynome_add(&delta,tmp);
                   polynome_rm(&tmp);
 
                   /* take its square root if possible */
                   Ppolynome sqdelta = polynome_nth_root(delta,2);
                   if(POLYNOME_UNDEFINED_P(sqdelta))
                       polynome_error(__FUNCTION__,"cannot solve this degree 2 polynomial symbolically\n");
 
                   /* the roots are (-b +sqdelta) / 2a and (-b -sqdelta) / 2a */
                   Ppolynome r0,r1=polynome_dup(b);
                   r0=polynome_addition(b,sqdelta);
                   polynome_negate(&r0);
                   polynome_scalar_mult(&a,2);// warning: modifies a in place */
                   r0=polynome_div(tmp=r0,a);
                   polynome_rm(&tmp);
 
                   polynome_negate(&b); //warning modifies b in place
                   r1=polynome_addition(b,sqdelta);
                   r1=polynome_div(tmp=r1,a);
                   polynome_rm(&tmp);
                   Pvecteur roots=vect_new(r0,1);
                   vect_add_elem(&roots,r1,1);
                   return roots;
               }
        default:
                polynome_error(__FUNCTION__,"solving polynome not implemented yet in that case\n");
    }
    return VECTEUR_NUL;
 
           
}

References monome_dup(), monome_rm(), monome_term, polynome_add(), polynome_addition(), polynome_degree(), polynome_div(), polynome_dup(), polynome_error(), polynome_monome, polynome_monome_add(), polynome_mult(), polynome_negate(), polynome_nth_root(), POLYNOME_NUL, polynome_rm(), polynome_scalar_mult(), polynome_scalar_multiply(), polynome_succ, POLYNOME_UNDEFINED_P, TCST, VALUE_ZERO, vect_add_elem(), vect_chg_var(), vect_coeff(), vect_del_var(), vect_new(), vect_size(), VECTEUR_NUL, and VECTEUR_UNDEFINED.

Referenced by do_solve_hardware_constraints_on_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_scalar_add()

void polynome_scalar_add	(	Ppolynome *	,
		double
	)

polynome_scalar_addition()

Ppolynome polynome_scalar_addition	(	Ppolynome	,
		double
	)

polynome_scalar_mult()

void polynome_scalar_mult	(	Ppolynome *	,
		double
	)

pnome-scal.c

polynome_scalar_multiply()

Ppolynome polynome_scalar_multiply	(	Ppolynome	,
		double
	)

polynome_sigma()

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 160 of file pnome-unaires.c.

{
    Ppolynome ppacc, pptemp, ppfact, ppresult = POLYNOME_NUL;
    int i;
 
    if (POLYNOME_UNDEFINED_P(pp) || POLYNOME_UNDEFINED_P(ppinf)
        || POLYNOME_UNDEFINED_P(ppsup)) 
        return (POLYNOME_UNDEFINED);
 
    for(i = 0; i <= polynome_degree(pp, var); i++) {
        /* 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)
         */
        ppfact = polynome_factorize(pp, var, i);
 
        if (!POLYNOME_NUL_P(ppfact)) {
            ppacc  = polynome_sum_of_power(ppsup, i);
            /* LZ: if ppinf == 1: no need to compute next sigma (pptemp), 
             * nor ppinf^i (FI: apparently not implemented) */
            pptemp = polynome_sum_of_power(ppinf, i);
 
            polynome_negate(&pptemp);
            polynome_add(&ppacc, pptemp);
            /* ppacc = sigma{1,ppsup} - sigma{1,ppinf} */
            polynome_rm(&pptemp);
 
            /* ppacc == (sigma{k=1,ppsup} k^i) - (sigma{k=1,ppinf} k^i)  */
 
            pptemp = polynome_power_n(ppinf, i);
            polynome_add(&ppacc, pptemp);
            polynome_rm(&pptemp);
 
            pptemp = polynome_mult(ppfact, ppacc);
 
            polynome_add(&ppresult, pptemp);
 
            polynome_rm(&pptemp);
            polynome_rm(&ppacc);
        }
    }
    return(ppresult);
}

References 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().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_sort()

Ppolynome polynome_sort	(	Ppolynome *	,
		int(*)(Pvecteur *, Pvecteur *)
	)

polynome_sprint()

char* polynome_sprint	(	Ppolynome	,
		char *	*)(Variable,
		int(*)(Pvecteur *, Pvecteur *)
	)

polynome_sscanf()

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 359 of file pnome-io.c.

{
    Ppolynome pp = POLYNOME_NUL;
    Pmonome curpm;
    bool constructing_monome = false;
    float coeff = 0.;
    char *varname;
    Value power;
    char *s;
 
    s = (char*) strdup(sp);
    remove_blanks(&s);
 
    while (*s != '\0')
    {
        /*fprintf(stderr, "\ns='%s'\n", s);*/
        power = VALUE_ONE;
        if (!constructing_monome) { coeff = parse_coeff(&s);
                                }
        varname = parse_var_name(&s);
        if (strlen(varname)!=0) {
            if (*s == '^') {
                s++;
                power = float_to_value(parse_coeff(&s));
            }
            else 
                while ((*s == '.') || (*s == '*')) s++;
        }
        else varname = (char*) strdup("TCST");
 
        if (constructing_monome) {
            vect_add_elem(&(monome_term(curpm)), 
                          name_to_variable(varname), 
                          power);
        }
        else {
            curpm = make_monome(coeff, name_to_variable(varname), power);
            constructing_monome = true;
        }
        /*fprintf(stderr, "au milieu: s='%s'\n", s);*/
 
        if ((*s == '+') || (*s == '-'))
        {
            polynome_monome_add(&pp, curpm);
            monome_rm(&curpm);
            constructing_monome = false;
        }
    }
    if (!MONOME_NUL_P(curpm)) {
        polynome_monome_add(&pp, curpm);
        monome_rm(&curpm);
    }
 
    return (pp);
}

References 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(), strdup(), VALUE_ONE, and vect_add_elem().

Here is the call graph for this function:

polynome_sum_of_power()

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 ...

FI: That means, no iteration is executed whatsoever, isn't it?

Also, polynome_error() does stop the execution and we are in trouble for Linear/C3 Library. We should init some exit function towards pips_internal_error().

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 79 of file pnome-unaires.c.

{
    Ppolynome ppresult = NULL, ppacc;
    int i;
 
    if (POLYNOME_UNDEFINED_P(ppsup))
        return (POLYNOME_UNDEFINED);
    if (p < 0)
        polynome_error("polynome_sum_of_power", "negative power: %d\n", p);
    else if (p == 0)
        ppresult = polynome_dup(ppsup);
    else {
        if ( polynome_constant_p(ppsup) ) {    /* if the upper bound is constant ... */
            double factor, result = 0;
            double cste = (double)polynome_TCST(ppsup);
 
            if (cste<1) {
              /* FI: That means, no iteration is executed whatsoever,
                 isn't it?
 
                 Also, polynome_error() does stop the execution and we
                 are in trouble for Linear/C3 Library. We should init some exit
                 function towards pips_internal_error().
              */
              /*
                polynome_error("polynome_sum_of_power",
                               "compute a sum from 1 to %f!\n", (float) cste);
              */
                ppresult = POLYNOME_NUL;
            }
            /*else if (cste==1)
                ppresult = POLYNOME_NUL;*/
            else {
                result = intpower(cste, p) * ((double) (cste / (p+1)) + 0.5);
                factor = ((double) p/2);
 
                for (i=1; 0<p-2*i+1; i++) {
                    result += (intpower(cste, p-2*i+1)
                               * ((double) (Bernouilli(i) * factor)));
                    factor *= - ((double) (p-2*i+1)*(p-2*i)) / ((double) (2*i+1)*(2*i+2));
                }
                ppresult = make_polynome((float) result, TCST, VALUE_ONE);
            }
        }
        else {    /* if the upper bound is a non-constant polynomial ... */
            float factor;
              /*  (ppsup^(p+1)) / (p+1)  */
            ppresult = polynome_power_n(ppsup, p+1);
            polynome_scalar_mult(&ppresult, (float) 1/(p+1));
              /*  1/2 * ppsup^p  */
            ppacc = polynome_power_n(ppsup, p);
            polynome_scalar_mult(&ppacc, (float) 1/2);
            polynome_add(&ppresult, ppacc);
            polynome_rm(&ppacc);
 
            factor = ((float) p / 2);
            /* computes factors p(p-1).../(2i!) incrementally */
 
            for (i=1; 0 < p-2*i+1; i++) {
                /* 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)) */
 
                ppacc = polynome_power_n(ppsup, p-2*i+1);
                polynome_scalar_mult(&ppacc, (float) Bernouilli(i) * factor);
 
                polynome_add(&ppresult, ppacc);
                polynome_rm(&ppacc);
 
                factor *= -((float)(p-2*i+1)*(p-2*i))/((float)(2*i+1)*(2*i+2));
            }
       }
    }
    return(ppresult);
}

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

Referenced by polynome_sigma().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_TCST()

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.

{
    Pmonome pm;
    Pvecteur pvTCST = vect_new((Variable) TCST, VALUE_ONE);
 
    /* polynome_TCST: polynome is undefined */
    assert(!POLYNOME_UNDEFINED_P(pp));
    for( ; pp != POLYNOME_NUL; pp = polynome_succ(pp) ) {
        pm = polynome_monome(pp);
        if (vect_equal(pvTCST, monome_term(pm)))
            return(monome_coeff(pm));
    }
 
    vect_rm(pvTCST);
    return ((float) 0);
 
}

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().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_used_var()

Pbase polynome_used_var	(	Ppolynome	,
		int(*)(Pvecteur *, Pvecteur *)
	)

polynome_var_subst()

Ppolynome polynome_var_subst	(	Ppolynome	pp,
		Variable	var,
		Ppolynome	ppsubst
	)

pnome-reduc.c

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 47 of file pnome-reduc.c.

{
    Ppolynome ppsubst_n, ppmult;
    Ppolynome newpp = POLYNOME_NUL;
    Pmonome curpm, newpm;
    int varpower;
    
    if (POLYNOME_UNDEFINED_P(pp))
        return (POLYNOME_UNDEFINED);
    else {
        for( ; pp != POLYNOME_NUL; pp = polynome_succ(pp)) {
            curpm = polynome_monome(pp);
            if ((varpower = (int) vect_coeff(var, monome_term(curpm))) == 0)
                polynome_monome_add(&newpp, curpm);
            else {
                /* 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. */
                
                if (POLYNOME_UNDEFINED_P(ppsubst))
                    return (POLYNOME_UNDEFINED);
                else {
                    newpm = monome_del_var(curpm, var);
                    ppsubst_n = polynome_power_n(ppsubst, varpower);
                    ppmult = polynome_monome_mult(ppsubst_n, newpm);
                    polynome_add(&newpp, ppmult);
 
                    polynome_rm(&ppmult);
                    polynome_rm(&ppsubst_n);
                    monome_rm(&newpm);
                }
            }
        }
        return(newpp);
    }
}

References monome_del_var(), monome_rm(), monome_term, 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().

Here is the call graph for this function:

Here is the caller graph for this function:

vecteur_to_polynome()

Ppolynome vecteur_to_polynome

(

Pvecteur

pv

)

===========================================================================

Ppolynome vecteur_to_polynome(Pvecteur pv): translates a Pvecteur into a Ppolynome.

Parameters

pv

v

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

{
  Ppolynome pp;
 
  if(VECTEUR_NUL_P(pv))
    pp = POLYNOME_NUL;
  else {
    Pvecteur vec;
 
    pp = NULL;
    for(vec = pv; vec != NULL; vec = vec->succ) {
      Variable var = vecteur_var(vec);
      float val = VALUE_TO_FLOAT(vecteur_val(vec));
      Ppolynome newpp;
 
      newpp = make_polynome(val, var, VALUE_ONE);
      polynome_succ(newpp) = pp;
      pp = newpp;
    }
  }
 
  return(pp);
}

References make_polynome(), POLYNOME_NUL, polynome_succ, Svecteur::succ, VALUE_ONE, VALUE_TO_FLOAT, VECTEUR_NUL_P, vecteur_val, and vecteur_var.

Referenced by include_trans_in_sc(), mapping_on_broadcast(), plc_make_distance(), and vvs_on_polynome().

Here is the call graph for this function:

Here is the caller graph for this function: