pnome-bin.c File Reference

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

Include dependency graph for pnome-bin.c:

Go to the source code of this file.

Functions
void	polynome_monome_add (Ppolynome *ppp, Pmonome pm)
	void polynome_monome_add(Ppolynome* ppp, Pmonome pm) PRIVATE Add monomial pm to polynomial *ppp, in place. More...
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. More...
void	polynome_add (Ppolynome *ppp, Ppolynome pp2)
	void polynome_add(Ppolynome* ppp, Ppolynome pp2) (*ppp) = (*ppp) + pp2. More...
Ppolynome	polynome_addition (Ppolynome pp, Ppolynome pp2)
	Ppolynome polynome_addition(Ppolynome pp, Ppolynome pp2) pp = pp + pp2. More...
static void	monome_monome_mult (Pmonome *ppm, Pmonome pm2)
	void monome_monome_mult(Pmonome *pm, Pmonome pm2) PRIVATE (*pm) = (*pm) * pm2. More...
Ppolynome	polynome_monome_mult (Ppolynome pp, Pmonome pm)
	Ppolynome polynome_monome_mult(Ppolynome pp, Pmonome pm) PRIVATE returns pp * pm. More...
Ppolynome	polynome_mult (Ppolynome pp1, Ppolynome pp2)
	Ppolynome polynome_mult(Ppolynome pp1, Ppolynome pp2) returns pp1 * pp2. More...
Pmonome	monome_monome_div (Pmonome pm1, Pmonome pm2)
	Pmonome monome_monome_div(Pmonome pm1, Pmonome pm2) PRIVATE (pm1) = (pm1) / pm2. More...
Ppolynome	polynome_monome_div (Ppolynome pp, Pmonome pm)
	Ppolynome polynome_monome_div(Ppolynome pp, Pmonome pm) PRIVATE returns p = pp / pm. More...
Ppolynome	polynome_div (Ppolynome pp1, Ppolynome pp2)
	Ppolynome polynome_div(Ppolynome pp1, Ppolynome pp2) returns p = pp1 / pp2. More...
Ppolynome	vecteur_to_polynome (Pvecteur pv)
	=========================================================================== More...

Function Documentation

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

static void monome_monome_mult ( Pmonome *  ppm, Pmonome  pm2  )

static

void monome_monome_mult(Pmonome *pm, Pmonome pm2) PRIVATE (*pm) = (*pm) * pm2.

!usage: monome_monome_mult(&pm, pm2);

returns ppm pointing to MONOME_NUL

M^-1 *M should be 1 . 26/10/92 LZ and the vecteur must be same. 09/11/92

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

{
    Pvecteur produit;
 
    if (MONOME_UNDEFINED_P(*ppm))
        ;
    else if (MONOME_UNDEFINED_P(pm2)) {
        monome_rm(ppm);
        *ppm = MONOME_UNDEFINED;
    }
    else if (!MONOME_NUL_P(*ppm)) {
        if (MONOME_NUL_P(pm2))
            monome_rm(ppm);     /* returns ppm pointing to MONOME_NUL */
        else {
            if (MONOME_CONSTANT_P(pm2))
                produit = vect_dup(monome_term(*ppm));
            else if (MONOME_CONSTANT_P(*ppm))
                produit = vect_dup(monome_term(pm2));           
            else {
                if (var_of(monome_term(*ppm))==var_of(monome_term(pm2)) &&
                    value_zero_p(value_plus(val_of(monome_term(*ppm)),
                                            val_of(monome_term(pm2))))) {
                    /* M^-1 *M should be 1 .   26/10/92    LZ 
                     and the vecteur must be same. 09/11/92 */
                    produit = vect_new(TCST, VALUE_ONE);
                }
                else
                    produit = vect_add(monome_term(*ppm), monome_term(pm2));
            }
            monome_coeff(*ppm) *= monome_coeff(pm2);
            vect_rm(monome_term(*ppm)); 
            monome_term(*ppm) = produit;
        }
    }
}

References monome_coeff, MONOME_CONSTANT_P, MONOME_NUL_P, monome_rm(), monome_term, MONOME_UNDEFINED, MONOME_UNDEFINED_P, TCST, val_of, VALUE_ONE, value_plus, value_zero_p, var_of, vect_add(), vect_dup(), vect_new(), and vect_rm().

Referenced by polynome_monome_mult().

Here is the call graph for this function:

Here is the caller graph for this function:

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_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_monome_add()

void polynome_monome_add	(	Ppolynome *	ppp,
		Pmonome	pm
	)

void polynome_monome_add(Ppolynome* ppp, Pmonome pm) PRIVATE Add monomial pm to polynomial *ppp, in place.

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:

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: