pnome-root.c File Reference

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

Include dependency graph for pnome-root.c:

Go to the source code of this file.

Functions
Pvecteur	polynome_roots (Ppolynome p, Variable var)
	computes the possible roots of a polynomial currently only works for degree 0,1,2) returned value is a vector of polynomial if p is independent of var, returns VECTEUR_UNDEFINED More...

Function Documentation

polynome_roots()

Pvecteur polynome_roots	(	Ppolynome	p,
		Variable	var
	)

computes the possible roots of a polynomial currently only works for degree 0,1,2) returned value is a vector of polynomial if p is independent of var, returns VECTEUR_UNDEFINED

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: