arithmetique.h File Reference

#include <stdio.h>
#include <limits.h>
#include "boolean.h"
#include "arithmetic_errors.h"

Go to the source code of this file.

Data Structures
struct	frac
struct	col
Defines
#define	LINEAR_VALUE_STRING   "int"
	# #### # # #### # #### # # #### # # # ## # # # # # # ## # # # # # # # # # # # # # # # # # # # # # # # # ### # # # # # # # ### # # # # ## # # # # # # ## # # ###### #### # # #### ###### #### # # ####
#define	VALUE_FMT   "%d"
#define	VALUE_CONST(val)   (val)
#define	VALUE_NAN   INT_MIN
#define	VALUE_MIN   (INT_MIN+1)
#define	VALUE_MAX   INT_MAX
#define	VALUE_ZERO   0
#define	VALUE_ONE   1
#define	VALUE_MONE   -1
#define	VALUE_TO_LONG(val)   ((long)(val))
#define	VALUE_TO_INT(val)   ((int)(val))
#define	VALUE_TO_FLOAT(val)   ((float)(val))
#define	VALUE_TO_DOUBLE(val)   ((double)(val))
#define	int_to_value(i)   ((Value)(i))
	end LINEAR_VALUE_IS_INT
#define	long_to_value(l)   ((Value)(l))
#define	float_to_value(f)   ((Value)(f))
#define	double_to_value(d)   ((Value)(d))
#define	value_eq(v1, v2)   ((v1)==(v2))
	boolean operators on values
#define	value_ne(v1, v2)   ((v1)!=(v2))
#define	value_gt(v1, v2)   ((v1)>(v2))
#define	value_ge(v1, v2)   ((v1)>=(v2))
#define	value_lt(v1, v2)   ((v1)<(v2))
#define	value_le(v1, v2)   ((v1)<=(v2))
#define	value_sign(v)   (value_eq(v,VALUE_ZERO)?0:value_lt(v,VALUE_ZERO)?-1:1)
	trian operators on values
#define	value_compare(v1, v2)   (value_eq(v1,v2)?0:value_lt(v1,v2)?-1:1)
#define	value_plus(v1, v2)   ((v1)+(v2))
	binary operators on values
#define	value_div(v1, v2)   ((v1)/(v2))
#define	value_mod(v1, v2)   ((v1)%(v2))
#define	value_direct_multiply(v1, v2)   ((v1)*(v2))
#define	value_minus(v1, v2)   ((v1)-(v2))
#define	value_pdiv(v1, v2)   (divide(v1,v2))
#define	value_pmod(v1, v2)   (modulo(v1,v2))
#define	value_min(v1, v2)   (value_le(v1,v2)? (v1): (v2))
#define	value_max(v1, v2)   (value_ge(v1,v2)? (v1): (v2))
#define	value_or(v1, v2)   ((v1)|(v2))
#define	value_and(v1, v2)   ((v1)&(v2))
#define	value_lshift(v1, v2)   ((v1)<<(v2))
#define	value_rshift(v1, v2)   ((v1)>>(v2))
#define	value_assign(ref, val)   (ref=(val))
	assigments
#define	value_addto(ref, val)   (ref+=(val))
#define	value_increment(ref)   (ref++)
#define	value_direct_product(ref, val)   (ref*=(val))
#define	value_multiply(ref, val)   value_assign(ref,value_mult(ref,val))
#define	value_substract(ref, val)   (ref-=(val))
#define	value_decrement(ref)   (ref--)
#define	value_division(ref, val)   (ref/=(val))
#define	value_modulus(ref, val)   (ref%=(val))
#define	value_pdivision(ref, val)   value_assign(ref,value_pdiv(ref,val))
#define	value_oppose(ref)   value_assign(ref,value_uminus(ref))
#define	value_absolute(ref)   value_assign(ref,value_abs(ref))
#define	value_minimum(ref, val)   value_assign(ref,value_min(ref,val))
#define	value_maximum(ref, val)   value_assign(ref,value_max(ref,val))
#define	value_orto(ref, val)   (ref |= (val))
#define	value_andto(ref, val)   (ref &= (val))
#define	value_uminus(val)   (-(val))
	unary operators on values
#define	value_not(val)   (~(val))
#define	value_abs(val)
#define	value_pos_p(val)   value_gt(val,VALUE_ZERO)
#define	value_neg_p(val)   value_lt(val,VALUE_ZERO)
#define	value_posz_p(val)   value_ge(val,VALUE_ZERO)
#define	value_negz_p(val)   value_le(val,VALUE_ZERO)
#define	value_zero_p(val)   value_eq(val,VALUE_ZERO)
#define	value_notzero_p(val)   value_ne(val,VALUE_ZERO)
#define	value_one_p(val)   value_eq(val,VALUE_ONE)
#define	value_notone_p(val)   value_ne(val,VALUE_ONE)
#define	value_mone_p(val)   value_eq(val,VALUE_MONE)
#define	value_notmone_p(val)   value_ne(val,VALUE_MONE)
#define	value_min_p(val)   value_eq(val,VALUE_MIN)
#define	value_max_p(val)   value_eq(val,VALUE_MAX)
#define	value_notmin_p(val)   value_ne(val,VALUE_MIN)
#define	value_notmax_p(val)   value_ne(val,VALUE_MAX)
#define	value_protected_hard_idiv_multiply(v, w, throw)
	(|v| < MAX / |w|) => v*w is okay I could check ((v*w)/w)==v but a tmp would be useful
#define	value_protected_multiply(v, w, throw)   value_protected_hard_idiv_multiply(v,w,throw)
	is a software idiv is assumed, quick check performed first
#define	value_protected_mult(v, w)   value_protected_multiply(v,w,THROW(overflow_error))
	protected versions
#define	value_protected_product(v, w)   v=value_protected_mult(v,w)
#define	value_mult(v, w)
	whether the default is protected or not this define makes no sense any more.
#define	value_product(v, w)   v=value_mult(v,w)
#define	SIGN(x)   (((x)>0)? 1 : ((x)==0? 0 : -1))
	was: define value_mult(v,w) value_direct_multiply(v,w) define value_product(v,w) value_direct_product(v,w) could be: protected versions.
#define	DIVIDE(x, y)
	division avec reste toujours positif basee sur les equations: a/(-b) = - (a/b) (-a)/b = - ((a+b-1)/b) ou a et b sont des entiers positifs
#define	POSITIVE_DIVIDE(x, y)   ((x)>0 ? (x)/(y) : - (-(x)+(y)-1)/(y))
	division avec reste toujours positif quand y est positif: assert(y>=0)
#define	MODULO(x, y)   ((y)>0 ? POSITIVE_MODULO(x,y) : POSITIVE_MODULO(-x,-y))
	modulo a resultat toujours positif
#define	POSITIVE_MODULO(x, y)
	modulo par rapport a un nombre positif: assert(y>=0)
#define	pgcd(a, b)   pgcd_slow(a,b)
	Pour la recherche de performance, selection d'une implementation particuliere des fonctions.
#define	divide(a, b)   DIVIDE(a,b)
#define	modulo(a, b)   MODULO(a,b)
Typedefs
typedef int	Value
typedef struct col	tableau
Enumerations
enum	linear_exception_t {   overflow_error = 1, simplex_arithmetic_error = 2, user_exception_error = 4, parser_exception_error = 8,   timeout_error = 16, any_exception_error = ~0, overflow_error = 1, simplex_arithmetic_error = 2,   user_exception_error = 4, parser_exception_error = 8, timeout_error = 16, any_exception_error = ~0 }
	Warning! Do not modify this file that is automatically generated! More...
Functions
Value	abs_ofl_ctrl (Value, int)
	end of arithmetique-local.h
Value	absval_ofl (Value)
	int absval_ofl(int i): absolute value of i (SUN version)
Value	absval (Value)
	int absval(int i): absolute value of i (SUN version)
Value	divide_fast (Value, Value)
	divide.c
Value	divide_slow (Value, Value)
Value	exponentiate (Value, int)
	exp.c
Value	modulo_fast (Value, Value)
	modulo.c
Value	pgcd_slow (Value, Value)
	pgcd.c
Value	pgcd_fast (Value, Value)
	int pgcd_fast(int a, int b): calcul iteratif du pgcd de deux entiers; le pgcd retourne est toujours positif; il n'est pas defini si a et b sont nuls (abort);
Value	pgcd_interne (Value, Value)
	int pgcd_interne(int a, int b): calcul iteratif du pgcd de deux entiers strictement positifs tels que a > b; le pgcd retourne est toujours positif;
Value	gcd_subtract (Value, Value)
	int gcd_subtract(int a, int b): find the gcd (pgcd) of two integers
Value	vecteur_bezout (Value[], Value[], int)
	int vecteur_bezout(int u[], int v[], int l): calcul du vecteur v qui verifie le theoreme de bezout pour le vecteur u; les vecteurs u et v sont de dimension l
Value	bezout (Value, Value, Value *, Value *)
	int bezout(int a, int b, int *x, int *y): calcule x et y, les deux nombres qui verifient le theoreme de Bezout pour a et b; le pgcd de a et b est retourne par valeur
Value	bezout_grl (Value, Value, Value *, Value *)
	int bezout_grl(int a, int b, int *x, int *y): calcule x et y, les deux entiers quelconcs qui verifient le theoreme de Bezout pour a et b; le pgcd de a et b est retourne par valeur
Value	ppcm (Value, Value)
	ppcm.c
void	print_Value (Value)
	io.c
void	fprint_Value (FILE *, Value)
void	fprint_string_Value (FILE *, char *, Value)
void	sprint_Value (char *, Value)
int	fscan_Value (FILE *, Value *)
int	scan_Value (Value *)
int	sscan_Value (char *, Value *)
char *	Value_to_string (Value)
char const *	get_exception_name (const linear_exception_t)
	errors.c
void	set_exception_callbacks (exception_callback_t, exception_callback_t)
void	dump_exception_stack_to_file (FILE *)
void	dump_exception_stack (void)
jmp_buf *	push_exception_on_stack (const int, const char *, const char *, const int)
void	pop_exception_from_stack (const int, const char *, const char *, const int)
void	throw_exception (const int, const char *, const char *, const int)
void	linear_initialize_exception_stack (unsigned int, exception_callback_t, exception_callback_t)
Variables
linear_exception_t	the_last_just_thrown_exception
int	linear_number_of_exception_thrown

---

Define Documentation

#define divide	(	a,
		b		)	DIVIDE(a,b)

Definition at line 514 of file arithmetique.h.

#define DIVIDE	(	x,
		y		)

Value:

((y)>0? POSITIVE_DIVIDE(x,y) : \
                     -POSITIVE_DIVIDE((x),(-(y))))

division avec reste toujours positif basee sur les equations: a/(-b) = - (a/b) (-a)/b = - ((a+b-1)/b) ou a et b sont des entiers positifs

Definition at line 490 of file arithmetique.h.

#define double_to_value

(

d

)

((Value)(d))

Definition at line 263 of file arithmetique.h.

#define float_to_value

(

f

)

((Value)(f))

Definition at line 262 of file arithmetique.h.

#define int_to_value

(

i

)

((Value)(i))

end LINEAR_VALUE_IS_INT

cast to value

Definition at line 260 of file arithmetique.h.

#define LINEAR_VALUE_STRING   "int"

# #### # # #### # #### # # #### # # # ## # # # # # # ## # # # # # # # # # # # # # # # # # # # # # # # # ### # # # # # # # ### # # # # ## # # # # # # ## # # ###### #### # # #### ###### #### # # ####

put there because I cannot have these constants with ansi options.default: LINEAR_VALUE_IS_INT

Definition at line 238 of file arithmetique.h.

#define long_to_value

(

l

)

((Value)(l))

Definition at line 261 of file arithmetique.h.

#define modulo	(	a,
		b		)	MODULO(a,b)

Definition at line 516 of file arithmetique.h.

#define MODULO	(	x,
		y		)	((y)>0 ? POSITIVE_MODULO(x,y) : POSITIVE_MODULO(-x,-y))

modulo a resultat toujours positif

Definition at line 497 of file arithmetique.h.

#define pgcd	(	a,
		b		)	pgcd_slow(a,b)

Pour la recherche de performance, selection d'une implementation particuliere des fonctions.

Definition at line 512 of file arithmetique.h.

#define POSITIVE_DIVIDE	(	x,
		y		)	((x)>0 ? (x)/(y) : - (-(x)+(y)-1)/(y))

division avec reste toujours positif quand y est positif: assert(y>=0)

Definition at line 494 of file arithmetique.h.

#define POSITIVE_MODULO	(	x,
		y		)

Value:

((x) > 0 ? (x)%(y) : \
                              ((x)%(y) == 0 ? 0 : ((y)-(-(x))%(y))))

modulo par rapport a un nombre positif: assert(y>=0)

Ce n'est pas la macro la plus efficace que j'aie jamais ecrite: il faut faire, dans le pire des cas, deux appels a la routine .rem, qui n'est surement pas plus cablee que la division ou la multiplication

Definition at line 505 of file arithmetique.h.

#define SIGN

(

x

)

(((x)>0)? 1 : ((x)==0? 0 : -1))

was: define value_mult(v,w) value_direct_multiply(v,w) define value_product(v,w) value_direct_product(v,w) could be: protected versions.

..LINEAR_VALUE_IS_CHARS is used for type checking. some operations are not allowed on (char*), thus they are switched to some other operation here...valeur absolueminimum et maximum if they are defined somewhere else, they are very likely to be defined the same way. Thus the previous def is not overwritten.signe d'un entier: -1, 0 ou 1

Definition at line 482 of file arithmetique.h.

#define value_abs

(

val

)

Value:

(value_posz_p(val)? \
    (val) :                                \
    (value_ne((val), VALUE_NAN) ?          \
      value_uminus(val) :                  \
      (THROW (overflow_error), VALUE_NAN )))

Definition at line 318 of file arithmetique.h.

#define value_absolute

(

ref

)

value_assign(ref,value_abs(ref))

Definition at line 308 of file arithmetique.h.

#define value_addto	(	ref,
		val		)	(ref+=(val))

Definition at line 298 of file arithmetique.h.

#define value_and	(	v1,
		v2		)	((v1)&(v2))

Definition at line 291 of file arithmetique.h.

#define value_andto	(	ref,
		val		)	(ref &= (val))

Definition at line 312 of file arithmetique.h.

#define value_assign	(	ref,
		val		)	(ref=(val))

assigments

Definition at line 297 of file arithmetique.h.

#define value_compare	(	v1,
		v2		)	(value_eq(v1,v2)?0:value_lt(v1,v2)?-1:1)

Definition at line 277 of file arithmetique.h.

#define VALUE_CONST

(

val

)

(val)

Definition at line 241 of file arithmetique.h.

#define value_decrement

(

ref

)

(ref--)

Definition at line 303 of file arithmetique.h.

#define value_direct_multiply	(	v1,
		v2		)	((v1)*(v2))

Definition at line 284 of file arithmetique.h.

#define value_direct_product	(	ref,
		val		)	(ref*=(val))

Definition at line 300 of file arithmetique.h.

#define value_div	(	v1,
		v2		)	((v1)/(v2))

Definition at line 282 of file arithmetique.h.

#define value_division	(	ref,
		val		)	(ref/=(val))

Definition at line 304 of file arithmetique.h.

#define value_eq	(	v1,
		v2		)	((v1)==(v2))

boolean operators on values

Definition at line 267 of file arithmetique.h.

#define VALUE_FMT   "%d"

Definition at line 240 of file arithmetique.h.

#define value_ge	(	v1,
		v2		)	((v1)>=(v2))

Definition at line 270 of file arithmetique.h.

#define value_gt	(	v1,
		v2		)	((v1)>(v2))

Definition at line 269 of file arithmetique.h.

#define value_increment

(

ref

)

(ref++)

Definition at line 299 of file arithmetique.h.

#define value_le	(	v1,
		v2		)	((v1)<=(v2))

Definition at line 272 of file arithmetique.h.

#define value_lshift	(	v1,
		v2		)	((v1)<<(v2))

Definition at line 292 of file arithmetique.h.

#define value_lt	(	v1,
		v2		)	((v1)<(v2))

Definition at line 271 of file arithmetique.h.

#define value_max	(	v1,
		v2		)	(value_ge(v1,v2)? (v1): (v2))

Definition at line 289 of file arithmetique.h.

#define VALUE_MAX   INT_MAX

Definition at line 244 of file arithmetique.h.

#define value_max_p

(

val

)

value_eq(val,VALUE_MAX)

Definition at line 335 of file arithmetique.h.

#define value_maximum	(	ref,
		val		)	value_assign(ref,value_max(ref,val))

Definition at line 310 of file arithmetique.h.

#define value_min	(	v1,
		v2		)	(value_le(v1,v2)? (v1): (v2))

Definition at line 288 of file arithmetique.h.

#define VALUE_MIN   (INT_MIN+1)

Definition at line 243 of file arithmetique.h.

#define value_min_p

(

val

)

value_eq(val,VALUE_MIN)

Definition at line 334 of file arithmetique.h.

#define value_minimum	(	ref,
		val		)	value_assign(ref,value_min(ref,val))

Definition at line 309 of file arithmetique.h.

#define value_minus	(	v1,
		v2		)	((v1)-(v2))

Definition at line 285 of file arithmetique.h.

#define value_mod	(	v1,
		v2		)	((v1)%(v2))

Definition at line 283 of file arithmetique.h.

#define value_modulus	(	ref,
		val		)	(ref%=(val))

Definition at line 305 of file arithmetique.h.

#define VALUE_MONE   -1

Definition at line 247 of file arithmetique.h.

#define value_mone_p

(

val

)

value_eq(val,VALUE_MONE)

Definition at line 332 of file arithmetique.h.

#define value_mult	(	v,
		w		)

Value:

value_protected_multiply(v,w,                                                 \
    (fprintf(stderr,"[value_mult] value overflow!\n"),THROW(overflow_error)))

whether the default is protected or not this define makes no sense any more.

.. well, doesn't matter. FC.I do enforce the protection whatever requested:-) prints out a message and throws the exception, hoping that some valid CATCH waits for it upwards.

Definition at line 382 of file arithmetique.h.

#define value_multiply	(	ref,
		val		)	value_assign(ref,value_mult(ref,val))

Definition at line 301 of file arithmetique.h.

#define VALUE_NAN   INT_MIN

Definition at line 242 of file arithmetique.h.

#define value_ne	(	v1,
		v2		)	((v1)!=(v2))

Definition at line 268 of file arithmetique.h.

#define value_neg_p

(

val

)

value_lt(val,VALUE_ZERO)

Definition at line 325 of file arithmetique.h.

#define value_negz_p

(

val

)

value_le(val,VALUE_ZERO)

Definition at line 327 of file arithmetique.h.

#define value_not

(

val

)

(~(val))

Definition at line 317 of file arithmetique.h.

#define value_notmax_p

(

val

)

value_ne(val,VALUE_MAX)

Definition at line 337 of file arithmetique.h.

#define value_notmin_p

(

val

)

value_ne(val,VALUE_MIN)

Definition at line 336 of file arithmetique.h.

#define value_notmone_p

(

val

)

value_ne(val,VALUE_MONE)

Definition at line 333 of file arithmetique.h.

#define value_notone_p

(

val

)

value_ne(val,VALUE_ONE)

Definition at line 331 of file arithmetique.h.

#define value_notzero_p

(

val

)

value_ne(val,VALUE_ZERO)

Definition at line 329 of file arithmetique.h.

#define VALUE_ONE   1

Definition at line 246 of file arithmetique.h.

#define value_one_p

(

val

)

value_eq(val,VALUE_ONE)

Definition at line 330 of file arithmetique.h.

#define value_oppose

(

ref

)

value_assign(ref,value_uminus(ref))

Definition at line 307 of file arithmetique.h.

#define value_or	(	v1,
		v2		)	((v1)|(v2))

Definition at line 290 of file arithmetique.h.

#define value_orto	(	ref,
		val		)	(ref |= (val))

Definition at line 311 of file arithmetique.h.

#define value_pdiv	(	v1,
		v2		)	(divide(v1,v2))

Definition at line 286 of file arithmetique.h.

#define value_pdivision	(	ref,
		val		)	value_assign(ref,value_pdiv(ref,val))

Definition at line 306 of file arithmetique.h.

#define value_plus	(	v1,
		v2		)	((v1)+(v2))

binary operators on values

Definition at line 281 of file arithmetique.h.

#define value_pmod	(	v1,
		v2		)	(modulo(v1,v2))

Definition at line 287 of file arithmetique.h.

#define value_pos_p

(

val

)

value_gt(val,VALUE_ZERO)

Definition at line 324 of file arithmetique.h.

#define value_posz_p

(

val

)

value_ge(val,VALUE_ZERO)

Definition at line 326 of file arithmetique.h.

#define value_product	(	v,
		w		)	v=value_mult(v,w)

Definition at line 385 of file arithmetique.h.

#define value_protected_hard_idiv_multiply	(	v,
		w,
		throw		)

Value:

((value_zero_p(w) || value_zero_p(v))? VALUE_ZERO:              \
   value_lt(value_abs(v),value_div(VALUE_MAX,value_abs(w)))?    \
   value_direct_multiply(v,w): (throw, VALUE_NAN))

(|v| < MAX / |w|) => v*w is okay I could check ((v*w)/w)==v but a tmp would be useful

Definition at line 346 of file arithmetique.h.

#define value_protected_mult	(	v,
		w		)	value_protected_multiply(v,w,THROW(overflow_error))

protected versions

Definition at line 365 of file arithmetique.h.

#define value_protected_multiply	(	v,
		w,
		throw		)	value_protected_hard_idiv_multiply(v,w,throw)

is a software idiv is assumed, quick check performed first

Definition at line 359 of file arithmetique.h.

#define value_protected_product	(	v,
		w		)	v=value_protected_mult(v,w)

Definition at line 367 of file arithmetique.h.

#define value_rshift	(	v1,
		v2		)	((v1)>>(v2))

Definition at line 293 of file arithmetique.h.

#define value_sign

(

v

)

(value_eq(v,VALUE_ZERO)?0:value_lt(v,VALUE_ZERO)?-1:1)

trian operators on values

Definition at line 276 of file arithmetique.h.

#define value_substract	(	ref,
		val		)	(ref-=(val))

Definition at line 302 of file arithmetique.h.

#define VALUE_TO_DOUBLE

(

val

)

((double)(val))

Definition at line 251 of file arithmetique.h.

#define VALUE_TO_FLOAT

(

val

)

((float)(val))

Definition at line 250 of file arithmetique.h.

#define VALUE_TO_INT

(

val

)

((int)(val))

Definition at line 249 of file arithmetique.h.

#define VALUE_TO_LONG

(

val

)

((long)(val))

Definition at line 248 of file arithmetique.h.

#define value_uminus

(

val

)

(-(val))

unary operators on values

Definition at line 316 of file arithmetique.h.

#define VALUE_ZERO   0

Definition at line 245 of file arithmetique.h.

#define value_zero_p

(

val

)

value_eq(val,VALUE_ZERO)

Definition at line 328 of file arithmetique.h.

---

Typedef Documentation

typedef struct col tableau

typedef int Value

Definition at line 239 of file arithmetique.h.

---

Enumeration Type Documentation

enum linear_exception_t

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

Modify src/Libs/arithmetique/arithmetique-local.h instead, to add your own modifications. header file built by cprotopackage arithmetique Francois Irigoin, mai 1989

Modifications

• reprise de DIVIDE qui etait faux (Remi Triolet, Francois Irigoin, april 90)
• simplification de POSITIVE_DIVIDE par suppression d'un moduloWe would like linear to be generic about the "integer" type used to represent integer values. Thus Value is defined here. It should be changed to "int" "long" or "long long". In an ideal world, any source modification should be limited to this package.

Indeed, we cannot switch easily to bignums that need constructors dans destructors... That would lead to too many modifications... C++ would make things easier and cleaner...

Fabien COELHOfor FILE *to be included for _MIN and _MAX: include <limits.h>Global constants to designate exceptions. To be used in the type field.

Enumerator:

overflow_error
simplex_arithmetic_error
user_exception_error
parser_exception_error
timeout_error
any_exception_error	catch all
overflow_error
simplex_arithmetic_error
user_exception_error
parser_exception_error
timeout_error
any_exception_error	catch all

Definition at line 66 of file arithmetique.h.

             {
  overflow_error = 1,
  simplex_arithmetic_error = 2,
  user_exception_error = 4,
  parser_exception_error = 8,
  timeout_error = 16,
  /* catch all */
  any_exception_error = ~0
} linear_exception_t;

---

Function Documentation

Value abs_ofl_ctrl	(	Value	i,
		int	ofl_ctrl
	)

end of arithmetique-local.h

abs.c

end of arithmetique-local.h

.. FC.

Parameters:

ofl_ctrl

fl_ctrl

Definition at line 35 of file abs.c.

References assert, overflow_error, THROW, value_eq, VALUE_MIN, value_ne, value_pos_p, and value_uminus.

Referenced by absval(), and absval_ofl().

{
    
    if ((ofl_ctrl == 1) && value_eq(i,VALUE_MIN))
        THROW(overflow_error);
        
    assert(value_ne(i,VALUE_MIN));
    return value_pos_p(i)? i: value_uminus(i);
}

Value absval

(

Value

)

int absval(int i): absolute value of i (SUN version)

Definition at line 55 of file abs.c.

References abs_ofl_ctrl().

{
    return abs_ofl_ctrl(i, 0);
}

Value absval_ofl

(

Value

)

int absval_ofl(int i): absolute value of i (SUN version)

Definition at line 47 of file abs.c.

References abs_ofl_ctrl().

{
    return abs_ofl_ctrl(i, 1);
}

Value bezout	(	Value	a,
		Value	b,
		Value *	x,
		Value *	y
	)

int bezout(int a, int b, int *x, int *y): calcule x et y, les deux nombres qui verifient le theoreme de Bezout pour a et b; le pgcd de a et b est retourne par valeur

a * x + b * y = gcd(a,b) return gcd(a,b)

Definition at line 262 of file pgcd.c.

References c, v, value_div, value_ge, value_minus, value_mod, value_mult, value_notzero_p, VALUE_ONE, VALUE_ZERO, and value_zero_p.

Referenced by vecteur_bezout().

{
    Value u0=VALUE_ONE,u1=VALUE_ZERO,v0=VALUE_ZERO,v1=VALUE_ONE;
    Value a0,a1,u,v,r,q,c;

    if (value_ge(a,b))
    {
        a0 = a;
        a1 = b;
        c = VALUE_ZERO;
    }
    else
    {
        a0 = b;
        a1 = a;
        c = VALUE_ONE;
    }
        
    r = value_mod(a0,a1);
    while (value_notzero_p(r))
    {
        q = value_div(a0,a1);
        u = value_mult(u1,q);
        u = value_minus(u0,u);

        v = value_mult(v1,q);
        v = value_minus(v0,v);
        a0 = a1; a1 = r;
        u0 = u1; u1 = u;
        v0 = v1; v1 = v;

        r = value_mod(a0,a1);
    }
  
    if (value_zero_p(c)) {
        *x = u1;
        *y = v1;
    }
    else {
        *x = v1;
        *y = u1;
    }

       return(a1);
}

Value bezout_grl	(	Value	a,
		Value	b,
		Value *	x,
		Value *	y
	)

int bezout_grl(int a, int b, int *x, int *y): calcule x et y, les deux entiers quelconcs qui verifient le theoreme de Bezout pour a et b; le pgcd de a et b est retourne par valeur

a * x + b * y = gcd(a,b) return gcd(a,b) gcd () >=0 le pre et le post conditions de pgcd sont comme la fonction gcd_subtract(). les situations speciaux sont donnes ci_dessous: si (a==0 et b==0) x=y=0; gcd()=0, si (a==0)(ou b==0) x=1(ou -1) y=0 (ou x=0 y=1(ou -1)) et gcd()=a(ou -a) (ou gcd()=b(ou -b))

les signes de a et b

Definition at line 321 of file pgcd.c.

References c, v, value_div, value_ge, value_minus, value_mod, VALUE_MONE, value_mult, value_neg_p, value_notzero_p, VALUE_ONE, value_uminus, VALUE_ZERO, and value_zero_p.

Referenced by base_G_h1_unnull().

{
    Value u0=VALUE_ONE,u1=VALUE_ZERO,v0=VALUE_ZERO,v1=VALUE_ONE;
    Value a0,a1,u,v,r,q,c;
    Value sa,sb;               /* les signes de a et b */

    sa = sb = VALUE_ONE;
    if (value_neg_p(a)){
        sa = VALUE_MONE;
        a = value_uminus(a);
    }
    if (value_neg_p(b)){
        sb  = VALUE_MONE;
        b = value_uminus(b);
    }
    if (value_zero_p(a) && value_zero_p(b)){
        *x = VALUE_ONE;
        *y = VALUE_ONE;
        return VALUE_ZERO;
    }
    else if(value_zero_p(a) || value_zero_p(b)){
        if (value_zero_p(a)){
            *x = VALUE_ZERO;
            *y = sb;
            return(b);
        }
        else{
            *x = sa;
            *y = VALUE_ZERO;
            return(a);
        }
    }
    else{

        if (value_ge(a,b))
        {
            a0 = a;
            a1 = b;
            c = VALUE_ZERO;
        }
        else
        {
            a0 = b;
            a1 = a;
            c = VALUE_ONE;
        }
        
        r = value_mod(a0,a1);
        while (value_notzero_p(r))
        {
            q = value_div(a0,a1);
            u = value_mult(u1,q);
            u = value_minus(u0,u);

            v = value_mult(v1,q);
            v = value_minus(v0,v);
            a0 = a1; a1 = r;
            u0 = u1; u1 = u;
            v0 = v1; v1 = v;

            r = value_mod(a0,a1);
        }
  
        if (value_zero_p(c)) {
            *x = value_mult(sa,u1);
            *y = value_mult(sb,v1);
        }
        else {
            *x = value_mult(sa,v1);
            *y = value_mult(sb,u1);
        }

        return a1;
    }
}

Value divide_fast	(	Value	a,
		Value	b
	)

divide.c

divide.c

INTLIBRARYint divide(int a, int b): calcul du divide de a par b; le reste (qui n'est pas retourne) est toujours positif; il est fourni par la fonction modulo() Il y a quatre configuration de signe a traiter: 1. a>0 && b>0: a / b 2. a<0 && b>0: (a-b+1) / b 3. a>0 && b<0: cf. 1. apres changement de signe de b, puis changement de signe du resultat 4. a<0 && b<0: cf. 2. apres changement de signe de b, puis changement de signe du resultat 5. a==0: 0

definition d'une look-up table pour les valeurs de a appartenant a [-DIVIDE_MAX_A..DIVIDE_MAX_A] et pour les valeurs de b appartenant a [1..DIVIDE_MAX_B] (en fait [-DIVIDE_MAX_B..DIVIDE_MAX_B] a cause du changement de signe)

Serait-il utile d'ajouter une test b==1 pour supprimer une colonne?

Serait-il utile de tester b > a pour renvoyer 0 ou -1 tout de suite?

b == 1 2 3 4 5 6 7 8

a == - 7

a == - 6

a == - 5

a == - 4

a == - 3

a == - 2

a == - 1

a == 0

a == 1

a == 2

a == 3

a == 4

a == 5

a == 6

a == 7

translation de a pour acces a la look-up table par indice positif: la == a + DIVIDE_MAX_A >= 0

valeur du quotient C

serait-il utile d'optimiser la division de a=0 par b? Ou bien cette routine n'est-elle jamais appelee avec a=0 par le package vecteur?

direct table look up

shift a for the table

this is just divide_slow

Definition at line 49 of file divide.c.

References assert, DIVIDE_MAX_A, DIVIDE_MAX_B, int_to_value, value_ge, value_le, value_notzero_p, value_pdiv, VALUE_TO_INT, and value_uminus.

{
    /* definition d'une look-up table pour les valeurs de a appartenant
       a [-DIVIDE_MAX_A..DIVIDE_MAX_A] et pour les valeurs de b
       appartenant a [1..DIVIDE_MAX_B] (en fait [-DIVIDE_MAX_B..DIVIDE_MAX_B]
       a cause du changement de signe)
       
       Serait-il utile d'ajouter une test b==1 pour supprimer une colonne?

       Serait-il utile de tester b > a pour renvoyer 0 ou -1 tout de suite?
       */

#define DIVIDE_MAX_A 7
#define DIVIDE_MAX_B 8

    static Value
        divide_look_up[2*DIVIDE_MAX_A+1][DIVIDE_MAX_B]={
        /* b ==         1   2   3   4   5   6   7   8 */
        {/* a == - 7 */ -7, -4, -3, -2, -2, -2, -1, -1},
        {/* a == - 6 */ -6, -3, -2, -2, -2, -1, -1, -1},
        {/* a == - 5 */ -5, -3, -2, -2, -1, -1, -1, -1},
        {/* a == - 4 */ -4, -2, -2, -2, -1, -1, -1, -1},
        {/* a == - 3 */ -3, -2, -1, -1, -1, -1, -1, -1},
        {/* a == - 2 */ -2, -1, -1, -1, -1, -1, -1, -1},
        {/* a == - 1 */ -1, -1, -1, -1, -1, -1, -1, -1},
        {/* a ==   0 */  0,  0,  0,  0,  0,  0,  0,  0},
        {/* a ==   1 */  1,  0,  0,  0,  0,  0,  0,  0},
        {/* a ==   2 */  2,  1,  0,  0,  0,  0,  0,  0},
        {/* a ==   3 */  3,  1,  1,  0,  0,  0,  0,  0},
        {/* a ==   4 */  4,  2,  1,  1,  0,  0,  0,  0},
        {/* a ==   5 */  5,  2,  1,  1,  1,  0,  0,  0},
        {/* a ==   6 */  6,  3,  2,  1,  1,  1,  0,  0},
        {/* a ==   7 */  7,  3,  2,  1,  1,  1,  1,  0}
    };
    /* translation de a pour acces a la look-up table par indice positif:
       la == a + DIVIDE_MAX_A >= 0 */

    Value quotient;     /* valeur du quotient C */

    assert(value_notzero_p(b));

    /* serait-il utile d'optimiser la division de a=0 par b? Ou bien
       cette routine n'est-elle jamais appelee avec a=0 par le package vecteur?
       */

    if (value_le(a, int_to_value(DIVIDE_MAX_A)) && 
        value_ge(a, int_to_value(-DIVIDE_MAX_A)) &&
        value_le(b, int_to_value(DIVIDE_MAX_B)) &&
        value_ge(b, int_to_value(-DIVIDE_MAX_B)))
    {
        /* direct table look up */
        int bint = VALUE_TO_INT(b),
            la = VALUE_TO_INT(a)+DIVIDE_MAX_A; /* shift a for the table */
        quotient = (bint>0)?
            divide_look_up[la][bint-1]:
                value_uminus(divide_look_up[la][(-bint)-1]);
    }
    else 
        quotient = value_pdiv(a,b); /* this is just divide_slow */

    return quotient;
}

Value divide_slow	(	Value	,
		Value
	)

Definition at line 112 of file divide.c.

References value_pdiv.

{
    return value_pdiv(a, b);
}

void dump_exception_stack

(

void

)

void dump_exception_stack_to_file

(

FILE *

)

Value exponentiate	(	Value	x,
		int	n
	)

exp.c

exp.c

INTLIBRARYno overflow is checked int exponentiate(x,n): raise x to the power n Precondition: n => 0

validation - n is positive

FI: la complexite pourrait etre reduite de O(n) a O(log n)

Definition at line 42 of file exp.c.

References assert, VALUE_ONE, and value_product.

{
    Value y;

    /* validation - n is positive 
     */
    assert(n >= 0);
    if (n == 0) return VALUE_ONE;

    /* FI: la complexite pourrait etre reduite de O(n) a O(log n) 
     */
    for(y=VALUE_ONE; n>0; n--)
        value_product(y,x);

    return y;
}

void fprint_string_Value	(	FILE *	,
		char *	,
		Value
	)

Definition at line 44 of file linear/src/arithmetique/io.c.

References fprint_Value(), and fprintf().

Referenced by build_sc_machine(), calculate_delay(), evaluate_var_to_complexity(), make_movements_loop_body_wp65(), print_dependence_cone(), print_vect_in_vertice_val(), region_translation_init(), and TestDiVariables().

{
    fprintf(f, blah);
    fprint_Value(f, v);
}

void fprint_Value	(	FILE *	,
		Value
	)

Definition at line 39 of file linear/src/arithmetique/io.c.

References fprintf(), and VALUE_FMT.

Referenced by adg_contrainte_fprint(), build1(), choose(), computebounds(), contrainte_fprint(), coupe(), evaluate_var_to_complexity(), fast(), fastplus(), findandmod(), fourier1(), fprint_contrainte_vecteur(), fprint_string_Value(), gcdtest(), igvoir3(), inequaldivision(), ipivotage2(), iprimal(), iprimalplus(), is2(), lowbound(), majlowbounds(), majuu(), matrice_fprint(), matrix_fprint(), matrix_pr_quot(), pr_quot(), pu_contrainte_fprint(), pu_vect_fprint(), sc_minmax_of_variable2(), sommet_fprint(), sommet_fprint_as_dense(), splitpb(), tableau_janus(), term(), upperbound(), vect_fprint(), vect_fprint_as_dense(), vect_gen_write(), voirbornes(), vzcut(), and wvoir().

{
    (void) fprintf(f, VALUE_FMT, v);
}

int fscan_Value	(	FILE *	,
		Value *
	)

Definition at line 55 of file linear/src/arithmetique/io.c.

References VALUE_FMT.

Referenced by matrice_fscan(), and matrix_fscan().

{
    return fscanf(f, VALUE_FMT, pv);
}

Value gcd_subtract	(	Value	a,
		Value	b
	)

int gcd_subtract(int a, int b): find the gcd (pgcd) of two integers

There is no precondition on the input. Negative input is handled in the same way as positive ones. If one input is zero the output is equal to the other input - thus an input of two zeros is the only way an output of zero is created.

Postcondition: gcd(a,b) > 0 ; gcd(a,b)==0 iff a==0 and b==0 whereas it should be undefined (F. Irigoin)

Exception: gcd(0,0) aborts

Implementation: by subtractions

Note: the signs of a and b do not matter because they can be exactly divided by the gcd

b == 0

Definition at line 186 of file pgcd.c.

References assert, value_abs, value_ge, value_minus, value_notzero_p, and value_zero_p.

{
    a = value_abs(a);
    b = value_abs(b);

    while (value_notzero_p(a) && value_notzero_p(b)) {
        if (value_ge(a,b)) 
            a = value_minus(a,b);
        else
            b = value_minus(b,a);
    }

    if (value_zero_p(a)) {
        assert(value_notzero_p(b));
        return b;
    }
    else {
        /* b == 0 */
        assert(value_notzero_p(a));
        return a; 
    }
}

char const* get_exception_name

(

const

linear_exception_t

)

errors.c

Parameters:

linear_exception_t

xception

void linear_initialize_exception_stack	(	unsigned	int,
		exception_callback_t	,
		exception_callback_t
	)

Parameters:

int

erbose_exceptions

Value modulo_fast	(	Value	a,
		Value	b
	)

modulo.c

modulo.c

INTLIBRARYint modulo_fast(int a, int b): calcul du modulo de a par b; le modulo retourne est toujours positif Il y a quatre configuration de signe a traiter: 1. a>0 && b>0: a % b 2. a<0 && b>0: a % b == 0 ? 0 : b - (-a)b 3. a>0 && b<0: cf. 1. apres changement de signe de b 4. a<0 && b<0: cf. 2. apres changement de signe de b

definition d'une look-up table pour les valeurs de a appartenant a [-MODULO_MAX_A..MODULO_MAX_A] et pour les valeurs de b appartenant a [1..MODULO_MAX_B] (en fait [-MODULO_MAX_B..MODULO_MAX_B] a cause du changement de signe)

Serait-il utile d'ajouter une test b==1 pour supprimer une colonne?

should be generated automatically

b == 1 2 3 4 5

a == - 5

a == - 4

a == - 3

a == - 2

a == - 1

a == 0

a == 1

a == 2

a == 3

a == 4

a == 5

translation de a pour acces a la look-up table

valeur du modulo C

premier changement de signe, ne changeant pas le resultat

traitement des cas particuliers

supprime pour cause de look-up table if(a==1 || a== 0) return(a);

if(b==1) return(0);

acceleration par une look-up table

calcul effectif du modulo: attention, portabilite douteuse

Definition at line 45 of file modulo.c.

References assert, int_to_value, MODULO_MAX_A, MODULO_MAX_B, value_abs, value_ge, value_le, value_minus, value_mod, value_neg_p, value_notzero_p, and VALUE_TO_INT.

{
    /* definition d'une look-up table pour les valeurs de a appartenant
       a [-MODULO_MAX_A..MODULO_MAX_A] et pour les valeurs de b
       appartenant a [1..MODULO_MAX_B] (en fait [-MODULO_MAX_B..MODULO_MAX_B]
       a cause du changement de signe)
       
       Serait-il utile d'ajouter une test b==1 pour supprimer une colonne?
       */
#define MODULO_MAX_A 5
#define MODULO_MAX_B 5
    static Value /* should be generated automatically */
        modulo_look_up[2*MODULO_MAX_A+1][MODULO_MAX_B]= {
        /*  b ==        1  2  3  4  5 */
        {/* a == - 5 */ 0, 1, 1, 3, 0},
        {/* a == - 4 */ 0, 0, 2, 0, 1},
        {/* a == - 3 */ 0, 1, 0, 1, 2},
        {/* a == - 2 */ 0, 0, 1, 2, 3},
        {/* a == - 1 */ 0, 1, 2, 3, 4},
        {/* a ==   0 */ 0, 0, 0, 0, 0},
        {/* a ==   1 */ 0, 1, 1, 1, 1},
        {/* a ==   2 */ 0, 0, 2, 2, 2},
        {/* a ==   3 */ 0, 1, 0, 3, 3},
        {/* a ==   4 */ 0, 0, 1, 0, 4},
        {/* a ==   5 */ 0, 1, 2, 1, 0}
        };
    /* translation de a pour acces a la look-up table */

    Value mod;    /* valeur du modulo C */
    assert(value_notzero_p(b));

    /* premier changement de signe, ne changeant pas le resultat */
    b = value_abs(b);

    /* traitement des cas particuliers */
    /* supprime pour cause de look-up table
     * if(a==1 || a== 0)
     *     return(a);
     *
     * if(b==1) 
     *     return(0);
     */

    if (value_le(a, int_to_value( MODULO_MAX_A)) &&
        value_ge(a, int_to_value(-MODULO_MAX_A)) &&
        value_le(b, int_to_value( MODULO_MAX_B)))
    {
        /* acceleration par une look-up table 
         */
        mod = modulo_look_up[VALUE_TO_INT(a)+MODULO_MAX_A][VALUE_TO_INT(b)-1];
    }
    else {
        /* calcul effectif du modulo: attention, portabilite douteuse */
        mod = value_mod(a,b);
        mod = value_neg_p(mod)? value_minus(b,mod): mod;
    }

    return mod;
}

Value pgcd_fast	(	Value	,
		Value
	)

int pgcd_fast(int a, int b): calcul iteratif du pgcd de deux entiers; le pgcd retourne est toujours positif; il n'est pas defini si a et b sont nuls (abort);

si cette routine n'est JAMAIS appelee avec des arguments nuls, il faudrait supprimer les deux tests d'egalite a 0; ca devrait etre le cas avec les vecteurs creux

Definition at line 79 of file pgcd.c.

References assert, pgcd_interne(), value_abs, value_gt, value_notzero_p, and value_zero_p.

{
    Value gcd;
   
    assert(value_notzero_p(b)||value_notzero_p(a));

    a = value_abs(a);
    b = value_abs(b);

    /* si cette routine n'est JAMAIS appelee avec des arguments nuls,
       il faudrait supprimer les deux tests d'egalite a 0; ca devrait
       etre le cas avec les vecteurs creux */
    if(value_gt(a,b))
        gcd = value_zero_p(b)? a : pgcd_interne(a,b);
    else
        gcd = value_zero_p(a)? b : pgcd_interne(b,a);

    return gcd;
}

Value pgcd_interne	(	Value	,
		Value
	)

int pgcd_interne(int a, int b): calcul iteratif du pgcd de deux entiers strictement positifs tels que a > b; le pgcd retourne est toujours positif;

Definition d'une look-up table pour les valeurs de a appartenant a [0..GCD_MAX_A] (en fait [-GCD_MAX_A..GCD_MAX_A]) et pour les valeurs de b appartenant a [1..GCD_MAX_B] (en fait [-GCD_MAX_B..GCD_MAX_B] a cause du changement de signe)

Serait-il utile d'ajouter une test b==1 pour supprimer une colonne?

la commutativite du pgcd n'est pas utilisee pour reduire la taille de la table

b == 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

a == 0

a == 1

a == 2

a == 3

a == 4

a == 5

a == 6

a == 7

a == 8

a == 9

a == 10

a == 11

a == 12

a == 13

a == 14

a == 15

on pourrait aussi utiliser une table des nombres premiers pour diminuer le nombre de boucles

on utilise la valeur particuliere -1 pour iterer

compute modulo(a,b) en utilisant la routine C puisque a et b sont strictement positifs (vaudrait-il mieux utiliser la soustraction?)

Definition at line 103 of file pgcd.c.

References assert, GCD_MAX_A, GCD_MAX_B, int_to_value, value_gt, value_le, value_mod, VALUE_MONE, value_neg_p, value_pos_p, VALUE_TO_INT, and value_zero_p.

Referenced by pgcd_fast().

{
    /* Definition d'une look-up table pour les valeurs de a appartenant
       a [0..GCD_MAX_A] (en fait [-GCD_MAX_A..GCD_MAX_A])
       et pour les valeurs de b appartenant a [1..GCD_MAX_B]
       (en fait [-GCD_MAX_B..GCD_MAX_B] a cause du changement de signe)
       
       Serait-il utile d'ajouter une test b==1 pour supprimer une colonne?
       */
#define GCD_MAX_A 15
#define GCD_MAX_B 15
    /* la commutativite du pgcd n'est pas utilisee pour reduire la
       taille de la table */
    static Value 
        gcd_look_up[GCD_MAX_A+1][GCD_MAX_B+1]= {
        /*  b ==        0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 */
        {/* a ==   0 */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15},
        {/* a ==   1 */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
        {/* a ==   2 */ 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1}, 
        {/* a ==   3 */ 3, 1, 1, 3, 1, 1, 3, 1, 1, 3, 1, 1, 3, 1, 1, 3},
        {/* a ==   4 */ 4, 1, 2, 1, 4, 1, 2, 1, 4, 1, 2, 1, 4, 1, 2, 1},
        {/* a ==   5 */ 5, 1, 1, 1, 1, 5, 1, 1, 1, 1, 5, 1, 1, 1, 1, 5},
        {/* a ==   6 */ 6, 1, 2, 3, 2, 1, 6, 1, 2, 3, 2, 1, 6, 1, 2, 3},
        {/* a ==   7 */ 7, 1, 1, 1, 1, 1, 1, 7, 1, 1, 1, 1, 1, 1, 7, 1},
        {/* a ==   8 */ 8, 1, 2, 1, 4, 1, 2, 1, 8, 1, 2, 1, 4, 1, 2, 1},
        {/* a ==   9 */ 9, 1, 1, 3, 1, 1, 3, 1, 1, 9, 1, 1, 3, 1, 1, 3},
        {/* a ==  10 */10, 1, 2, 1, 2, 5, 2, 1, 2, 1,10, 1, 2, 1, 2, 5},
        {/* a ==  11 */11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,11, 1, 1, 1, 1},
        {/* a ==  12 */12, 1, 2, 3, 4, 1, 6, 1, 4, 3, 2, 1,12, 1, 2, 3},
        {/* a ==  13 */13, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,13, 1, 1},
        {/* a ==  14 */14, 1, 2, 1, 2, 1, 2, 7, 2, 1, 2, 1, 2, 1,14, 1},
        {/* a ==  15 */15, 1, 1, 3, 1, 5, 3, 1, 1, 3, 5, 1, 3, 1, 1, 15}
    };
    /* on pourrait aussi utiliser une table des nombres premiers
       pour diminuer le nombre de boucles */

    /* on utilise la valeur particuliere -1 pour iterer */
    Value gcd = VALUE_MONE;
    Value mod;

    assert(value_gt(a,b) && value_pos_p(b));

    do{
        if(value_le(b,int_to_value(GCD_MAX_B)) && 
           value_le(a,int_to_value(GCD_MAX_A))) {
            gcd = gcd_look_up[VALUE_TO_INT(a)][VALUE_TO_INT(b)];
            break;
        }
        else {
            /* compute modulo(a,b) en utilisant la routine C puisque a et b
               sont strictement positifs (vaudrait-il mieux utiliser la
               soustraction?) */
            mod = value_mod(a,b);
            if(value_zero_p(mod)) {
                gcd = b;
            }
            else {
                a = b;
                b = mod;
            }
        }
    } while(value_neg_p(gcd));

    return gcd;
}

Value pgcd_slow	(	Value	a,
		Value	b
	)

pgcd.c

pgcd.c

INTLIBRARYValue pgcd_slow(Value a, Value b) computation of the gcd of a and b. the result is always positive. standard algorithm in log(max(a,b)). pgcd_slow(0,0)==1 (maybe should we abort?). I changed from a recursive for a simple iterative version, FC 07/96.

a==0, b==0

a==0, b!=0

a!=0, b==0

a==b

swap

on entry in this loop, a > b > 0 is insured

Definition at line 41 of file pgcd.c.

References value_abs, value_absolute, value_eq, value_gt, value_mod, value_notzero_p, VALUE_ONE, and value_zero_p.

Referenced by matrice_determinant(), matrice_diagonale_inversion(), matrice_triangulaire_inversion(), matrix_determinant(), and substitute_var_with_vec().

{
    Value m;

    if (value_zero_p(a))
    {
        if (value_zero_p(b))
            return VALUE_ONE;    /* a==0, b==0 */
        else
            return value_abs(b); /* a==0, b!=0 */
    }
    else
        if (value_zero_p(b))
            return value_abs(a); /* a!=0, b==0 */

    value_absolute(a);
    value_absolute(b);

    if (value_eq(a,b)) /* a==b */
        return a;

    if (value_gt(b,a))
        m = a, a = b, b = m; /* swap */

    /* on entry in this loop, a > b > 0 is insured */
    do {
        m = value_mod(a,b);
        a = b;
        b = m;
    } while(value_notzero_p(b));

    return a;
}

void pop_exception_from_stack	(	const	int,
		const char *	,
		const char *	,
		const	int
	)

Parameters:

	int	hat
	int	ine

Value ppcm	(	Value	i,
		Value	j
	)

ppcm.c

ppcm.c

INTLIBRARYint ppcm(int i, int j): plus petit entier positif divisible par i et j Ancien nom et ancien type: void lcm(int i, int j, int *pk)

Definition at line 39 of file ppcm.c.

References pgcd, value_div, value_mult, value_neg_p, value_uminus, VALUE_ZERO, and value_zero_p.

Referenced by bounds_equal_p(), build_contraction_matrices(), compose_vvs(), include_trans_on_LC_in_ref(), matrice_diagonale_inversion(), matrice_substract(), matrix_add(), matrix_diagonal_inversion(), matrix_substract(), my_matrices_to_constraints_with_sym_cst(), my_matrices_to_constraints_with_sym_cst_2(), simplify_dimension(), simplify_predicate(), and vvs_on_vvs().

{
    if (value_neg_p(i)) i = value_uminus(i);
    if (value_neg_p(j)) j = value_uminus(j);

    if (value_zero_p(i) || value_zero_p(j)) 
        return VALUE_ZERO;
    else {
        Value d = pgcd(i,j);
        d = value_div(i,d);
        return value_mult(d,j);
    }
}

void print_Value

(

Value

v

)

io.c

io.c

IO on a Value

Definition at line 34 of file linear/src/arithmetique/io.c.

References printf(), and VALUE_FMT.

Referenced by add_var_sup(), eq_in_ineq(), lignes_entrant(), printfrac(), and var_ecart_sup().

{
    (void) printf(VALUE_FMT, v);
}

jmp_buf* push_exception_on_stack	(	const	int,
		const char *	,
		const char *	,
		const	int
	)

Parameters:

	int	hat
	int	ine

int scan_Value

(

Value *

)

Definition at line 60 of file linear/src/arithmetique/io.c.

References VALUE_FMT.

Referenced by fonct_read(), and vect_read().

{
    return scanf(VALUE_FMT, pv);
}

void set_exception_callbacks	(	exception_callback_t	,
		exception_callback_t
	)

Referenced by __attribute__(), atinit(), gpips_main(), pips_main(), tpips_main(), and wpips_main().

void sprint_Value	(	char *	,
		Value
	)

Definition at line 50 of file linear/src/arithmetique/io.c.

References VALUE_FMT.

Referenced by heuristique_1(), heuristique_3(), and vect_sprint_as_monome().

{
    (void) sprintf(s, VALUE_FMT, v);
}

int sscan_Value	(	char *	,
		Value *
	)

Definition at line 65 of file linear/src/arithmetique/io.c.

References VALUE_FMT.

Referenced by slx_parse(), and vect_gen_read().

{
    return sscanf(s, VALUE_FMT, pv);
}

void throw_exception	(	const	int,
		const char *	,
		const char *	,
		const	int
	)

Parameters:

	int	hat
	int	ine

char* Value_to_string

(

Value

)

Definition at line 73 of file linear/src/arithmetique/io.c.

References buf, BUFFER_SIZE, and VALUE_FMT.

Referenced by add_Value_to_current_line().

{
    static char buf[BUFFER_SIZE];
    sprintf(buf, VALUE_FMT, v);
    return buf;
}

Value vecteur_bezout	(	Value	u[],
		Value	v[],
		int	l
	)

int vecteur_bezout(int u[], int v[], int l): calcul du vecteur v qui verifie le theoreme de bezout pour le vecteur u; les vecteurs u et v sont de dimension l

-> -> -> < u . v > = gcd(u ) i

printf("gcd = %d \n",gcd);

sum u * v = gcd(u ) k<l k k k<l k

a1 = gcd (u ) k<l-1 k

printf("gcd = %d\n",gcd);

Definition at line 217 of file pgcd.c.

References assert, bezout(), i, VALUE_ONE, value_product, and x.

{
    Value gcd, a1, x;
    Value *p1, *p2;
    int i, j;

    assert(l>0);

    if (l==1) {
        v[0] = VALUE_ONE;
        gcd = u[0];
    }
    else {
        p1 = &v[0]; p2 = &v[1];
        a1 = u[0]; gcd = u[1];
        gcd = bezout(a1,gcd,p1,p2);

        /* printf("gcd = %d \n",gcd); */

        for (i=2;i<l;i++){ 
            /* sum u * v = gcd(u ) 
             * k<l  k   k  k<l  k
             *
             * a1 = gcd  (u )
             *      k<l-1  k
             */
            a1 = u[i];
            p1 = &v[i];
            gcd = bezout(a1,gcd,p1,&x);
            /* printf("gcd = %d\n",gcd); */
            for (j=0;j<i;j++)
                value_product(v[j],x);
        } 
    }

    return gcd;
}

---

Variable Documentation

int linear_number_of_exception_thrown

Referenced by build_sc_nredund_1pass_ofl_ctrl(), efficient_sc_check_inequality_feasibility(), internal_sc_feasibility(), sc_cute_convex_hull(), sc_feasibility_ofl_ctrl(), sc_fourier_motzkin_feasibility_ofl_ctrl_timeout_ctrl(), sc_janus_feasibility_ofl_ctrl_timeout_ctrl(), and sc_simplexe_feasibility_ofl_ctrl_timeout_ctrl().

linear_exception_t the_last_just_thrown_exception