pnome-unaires.c File Reference

#include <stdio.h>
#include <boolean.h>
#include "arithmetique.h"
#include "vecteur.h"
#include "polynome.h"

Include dependency graph for pnome-unaires.c:

Go to the source code of this file.

Functions
void	polynome_negate (Ppolynome *ppp)
	void polynome_negate(Ppolynome *ppp); changes sign of polynomial *ppp. More...
Ppolynome	polynome_opposed (Ppolynome pp)
	Ppolynome polynome_opposed(Ppolynome pp); changes sign of polynomial pp. More...
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). More...
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. More...
Ppolynome	polynome_sort (Ppolynome *ppp, int *is_inferior_var)
	Ppolynome polynome_sort((Ppolynome *) ppp, bool (*is_inferior_var)()) Sorts the polynomial *ppp: monomials are sorted by the private routine "is_inferior_monome" based on the user one "is_inferior_var". More...
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 More...

Function Documentation

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

void polynome_negate

(

Ppolynome *

ppp

)

void polynome_negate(Ppolynome *ppp); changes sign of polynomial *ppp.

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_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_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 *	ppp,
		int *	is_inferior_var
	)

Ppolynome polynome_sort((Ppolynome *) ppp, bool (*is_inferior_var)()) Sorts the polynomial *ppp: monomials are sorted by the private routine "is_inferior_monome" based on the user one "is_inferior_var".

!usage: polynome_sort(&pp, is_inferior_var);

pv = vect_tri(pv, is_inferior_var);

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

{
    Ppolynome ppcur;
    Ppolynome ppsearchmin;
    Pmonome pmtemp;
 
    if ((!POLYNOME_NUL_P(*ppp)) && (!POLYNOME_UNDEFINED_P(*ppp))) {
        for (ppcur = *ppp; ppcur != POLYNOME_NUL; ppcur = polynome_succ(ppcur)) {
            Pmonome pm = polynome_monome(ppcur);
            Pvecteur pv = monome_term(pm);
            pv = vect_sort(pv, vect_compare);
            /* pv = vect_tri(pv, is_inferior_var); */
        }
        for (ppcur = *ppp; polynome_succ(ppcur) != POLYNOME_NUL; ppcur = polynome_succ(ppcur)) {
            for(ppsearchmin  = polynome_succ(ppcur);
                ppsearchmin != POLYNOME_NUL;
                ppsearchmin  = polynome_succ(ppsearchmin)) {
 
                if (!is_inferior_monome(polynome_monome(ppsearchmin),
                                        polynome_monome(ppcur), is_inferior_var)) {
                    pmtemp = polynome_monome(ppsearchmin);
                    polynome_monome(ppsearchmin) = polynome_monome(ppcur);
                    polynome_monome(ppcur) = pmtemp;
                }
            }
        }
    }
    return (*ppp);
}

References is_inferior_monome(), is_inferior_var(), monome_term, polynome_monome, POLYNOME_NUL, POLYNOME_NUL_P, polynome_succ, POLYNOME_UNDEFINED_P, vect_compare(), and vect_sort().

Referenced by polynome_equal(), and polynome_sprint().

Here is the call graph for this function:

Here is the caller 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: