25 #include "pips_config.h"
60 #include "resources.h"
64 #include "constants.h"
126 else (
void)
fprintf(stderr,
"non linear loop bounds-cannot be reduced\n");
206 "instruction_to_wp65_code-instruction- begin\n");
212 proc_id, proc_id_mm, bank_indices,
214 compute_module, computational,
215 memory_module, emulator,
216 fetch_map,store_map);
221 "instruction_to_wp65_code-Sorry:test not implemented\n");
225 "instruction_to_wp65_cod -Sorry:goto implemented\n");
229 proc_id, proc_id_mm, bank_indices,
231 compute_module, computational,
232 memory_module, emulator,
241 computational,emulator, fetch_map,
251 " instruction_to_wp65_code- bad instruction tag \n");
256 "instruction_to_wp65_code-instruction_end \n");
274 bool load_code =
true;
293 "Vars having to be loaded for stat %"PRIdPTR
":\n",
297 load_code,computational,
313 "Vars having to be stored for stat %"PRIdPTR
":\n",
317 load_code,computational,proc_id);
319 !load_code,emulator,bank_id);
337 "IMPLIED-DO") == 0)) ?
348 pips_assert(
"true", loop_or_call_print==loop_or_call_print);
350 bool iolist_reached =
false;
357 while (!
ENDP(pio) && (!iolist_reached)) {
373 iolist_reached =
true;
383 "IMPLIED-DO") == 0)) {
436 if (loop_or_call_print)
437 for (i=1; i<=nb_dim; i++) {
507 Pbase tile_basis_in_tile_basis,
508 Pbase tile_basis_in_tile_basis2,
509 Pbase loop_body_indices,
515 int first_parallel_level,
516 int last_parallel_level,
523 && proc_id_mm==proc_id_mm
525 && emulator==emulator
527 && r_to_llv==r_to_llv
528 && computational==computational);
532 list fetch_reference_list =
NIL;
533 list store_reference_list =
NIL;
539 loop_nest,fetch_map,fully_parallel);
541 loop_nest,store_map,fully_parallel);
545 module,compute_module,memory_module,
546 rv,fetch_reference_list,
547 llv_to_lcr, v_to_lllv,r_to_ud, v_to_esv,
549 sc_tile, initial_basis, local_basis,
550 proc_id, bank_indices,loop_body_indices,
552 last_parallel_level);
564 rv,store_reference_list ,
565 llv_to_lcr, v_to_lllv, r_to_ud, v_to_esv,
567 sc_tile, initial_basis, local_basis,
568 proc_id, bank_indices, loop_body_indices,
570 first_parallel_level,
571 last_parallel_level);
639 list store_reference_list =
NIL;
649 int i1,lpl, loop_nest_dimt;
650 int first_parallel_level=1;
651 int last_parallel_level, perfect_nested_loop_size;
652 bool loop_carried_dep[11];
654 bool fully_sequential=
true;
655 int nested_level2,nested_level=0;
657 list list_statement_block2=
NIL;
661 bool io_statementp=
false;
664 debug(5,
"loop_nest_to_wp65_code",
"begin\n");
666 for (i1=1;i1<=10;i1++) loop_carried_dep[i1] =
false;
675 &nested_level,&list_statement_block, &binst);
676 full_initial_basis =
base_dup(initial_basis);
677 perfect_nested_loop_size=
vect_size(initial_basis);
685 for (i1=perfect_nested_loop_size+1;i1<=10;i1++)
686 loop_carried_dep[i1] =
true;
687 assert(perfect_nested_loop_size <=10);
689 last_parallel_level =perfect_nested_loop_size+1;
690 if (!fully_parallel) {
691 for (i1=1; i1<=loop_nest_dimt && (loop_carried_dep[i1] ==
true);
693 first_parallel_level = i1;
694 for (i1=first_parallel_level;
695 i1<=loop_nest_dimt && (loop_carried_dep[i1] ==
false);i1++);
696 last_parallel_level = i1-1;
697 for (it=1, pv=initial_basis;
698 it <perfect_nested_loop_size && it<last_parallel_level;
700 loop_body_indices =
base_dup(pv->succ);
702 (void)
fprintf(stderr,
"first_parallel_level :%d, last_parallel_level %d\n",
703 first_parallel_level,last_parallel_level);
704 (void)
fprintf(stderr,
"\nLoop body basis - loop_nest:");
706 (void)
fprintf(stderr,
"\nInitial basis - loop_nest:");
713 &tile_basis_in_initial_basis,
714 &tile_basis_in_tile_basis,
716 &tile_basis_in_tile_basis2,
718 lpl = (fully_parallel) ? last_parallel_level-1:last_parallel_level;
720 initial_basis, first_parallel_level,lpl,
721 perfect_nested_loop_size);
725 tile_basis_in_tile_basis,
729 fprintf(stderr,
"loop body \n");
731 list_statement_block);
738 io_statementp =
true;}
744 llv_to_lcr, r_to_llv, v_to_lllv,
745 r_to_ud, v_to_esv, v_to_nlv,
746 lpv, body, initial_basis,
dg,
753 bank_indices,v_to_esv,v_to_nlv,compute_module,
754 computational, memory_module,emulator,fetch_map,
755 store_map,
mod_stat,fully_parallel,sc_tile,
756 full_initial_basis,local_basis, local_basis2,
757 tile_basis_in_tile_basis, tile_basis_in_tile_basis2,
758 loop_body_indices,lpv,&lb,&blb,&
sb,
759 &bsb,first_parallel_level, last_parallel_level,
760 llv_to_lcr, r_to_llv, v_to_lllv,r_to_ud );
783 fprintf(stderr,
"generation des transferts pour \n");
788 &initial_basis2,&nested_level2,
789 &list_statement_block2,&binst2);
790 if (loop_nest_dimt > perfect_nested_loop_size) {
791 loop_body_indices =
vect_dup(initial_basis2);
792 for ( pv=initial_basis; pv!= NULL;
800 (void)
fprintf(stderr,
"full basis\n");
803 (void)
fprintf(stderr,
"full iteration domain\n");
808 &tbib2, &tbtl3, &lba3, &tbtl4, &lba4);
816 first_parallel_level,lpl,
817 perfect_nested_loop_size);
819 tile2, tile_delay,tbtl5,lba5);
822 llv_to_lcr, r_to_llv, v_to_lllv,
823 r_to_ud, v_to_esv, v_to_nlv,
824 lpv, body, initial_basis2,
dg,
830 module,stmp,pn,bn, ls, pd,proc_id,
831 proc_id_mm, bank_indices,v_to_esv,
832 v_to_nlv,compute_module, computational,
833 memory_module,emulator,fetch_map,
835 sc_tile2,initial_basis2,lba5,lba6,tbtl5,
836 tbtl6,loop_body_indices,lpv,&lb,&blb,&
sb,
837 &bsb,first_parallel_level,
838 last_parallel_level, llv_to_lcr,
839 r_to_llv, v_to_lllv,r_to_ud );
844 list_statement_block);
846 fully_sequential = (first_parallel_level >last_parallel_level);
854 bank_indices,bn,ls,proc_id,
855 list_statement_block,fetch_map,
856 store_map,&new_compute_lst,
857 &new_bank_lst,v_to_esv,
859 initial_basis,tile, tile_delay,
860 tile_basis_in_tile_basis,
866 fprintf(stderr,
"loop body \n");
868 fprintf(stderr,
"base_initiale 1\n");
877 initial_basis, local_basis2,
878 tile_basis_in_tile_basis2,
879 tile_basis_in_initial_basis,
880 iteration_domain,first_parallel_level,
881 last_parallel_level);
884 if (new_bank_lst !=
NIL) {
887 tile, initial_basis, local_basis,
888 tile_basis_in_tile_basis,
889 tile_basis_in_initial_basis,
891 first_parallel_level,
892 last_parallel_level);
904 tile_basis_in_tile_basis2,
905 tile_basis_in_initial_basis,
906 iteration_domain,first_parallel_level,
907 last_parallel_level);
909 pn, tile, initial_basis,
910 tile_basis_in_tile_basis,
911 tile_basis_in_initial_basis,
912 iteration_domain,first_parallel_level,
913 last_parallel_level);
915 if (fully_sequential) {
941 "Vars having to be stored into global memory:\n");
951 false,computational,proc_id);
953 true,emulator,(
entity)bank_indices->
var);
962 debug(5,
"loop_nest_to_wp65_code",
"end\n");
973 llv_to_lcr, v_to_lllv,r_to_ud, v_to_esv,
975 iteration_domain, initial_basis, local_basis,
976 proc_id, bank_indices, loop_body_indices,
978 use_def,first_parallel_level,last_parallel_level)
996 Pbase loop_body_indices;
1000 int first_parallel_level,last_parallel_level;
1005 debug(8,
"make_all_movement_blocks",
"begin\n");
1006 for(; !
ENDP(lllv);
POP(lllv)) {
1012 bool proper_tag =
false;
1014 for(; !
ENDP(lr) && !proper_tag ;
POP(lr)) {
1025 memory_module, v, esv, lv,
1026 lr, r_to_ud, iteration_domain,
1027 initial_basis, bank_indices,
1028 local_basis, loop_body_indices,
1030 &mbs, &bmbs,first_parallel_level,
1031 last_parallel_level);
1036 memory_module, v, esv, lv,
1037 lr, r_to_ud, iteration_domain,
1039 bank_indices,local_basis,
1042 &mbs, &bmbs,first_parallel_level,
1043 last_parallel_level);
1062 debug(8,
"make_all_movement_blocks",
"end\n");
1072 bool loop_carried_dep[11];
1074 cons *pv1, *ps, *pc;
1102 if ((
level <= nbrcomloops)
1108 { loop_carried_dep[
INT(
CAR(
pl))] =
true;
1120 int nest_dim,
graph dg,
bool *loop_carried_dep)
1124 for (i=1; i<= nest_dim && loop_carried_dep[i]==
false; i++);
1125 return( (i>nest_dim) ?
true :
false);
execution make_execution(enum execution_utype tag, void *val)
loop make_loop(entity a1, range a2, statement a3, entity a4, execution a5, list a6)
expression copy_expression(expression p)
EXPRESSION.
statement copy_statement(statement p)
STATEMENT.
reference make_reference(entity a1, list a2)
syntax make_syntax(enum syntax_utype tag, void *val)
range make_range(expression a1, expression a2, expression a3)
tiling loop_nest_to_tile(Psysteme sc, int ls, Pbase base_index, int first_parallel_level, int last_parallel_level, int perfect_nested_level)
Code Generation for Distributed Memory Machines.
struct _newgen_struct_entity_ * entity
bool entity_is_argument_p(entity e, cons *args)
Pbase base_reversal(Pbase b_in)
Pbase base_reversal(Pbase b_in): produces a basis b_out, having the same basis vectors as b_in,...
void create_tile_basis(entity initial_module, entity compute_module, entity memory_module, Pbase initial_basis, Pbase *tile_basis_in_initial_basis, Pbase *tile_basis_in_tile_basis, Pbase *local_tile_basis, Pbase *tile_basis_in_tile_basis2, Pbase *local_tile_basis2)
Psysteme loop_bounds_to_tile_bounds(Psysteme loop_bounds, Pbase loop_indices, tiling t, Pvecteur tile_delay, Pvecteur tile_indices, Pvecteur tile_local_indices)
this function returns the system of constraints
static graph dg
dg is the dependency graph ; FIXME : should not be static global ?
void make_store_blocks(entity initial_module, entity compute_module, entity memory_module, entity var, entity shared_variable, entity local_variable, list lrefs, hash_table r_to_ud, Psysteme sc_domain, Pbase index_base, Pbase bank_indices, Pbase tile_indices, Pbase loop_body_indices, entity Proc_id, int pn, int bn, int ls, statement *store_block, statement *bank_store_block, int first_parallel_level, int last_parallel_level)
statement make_scanning_over_tiles(entity module, list body, entity proc_id, int pn, tiling tile, Pbase initial_basis, Pbase tile_basis_in_tile_basis, Pbase tile_basis_in_initial_basis, Psysteme iteration_domain, int first_parallel_level, int last_parallel_level)
make_scanning_over_tiles()
void make_load_blocks(entity initial_module, entity compute_module, entity memory_module, entity var, entity shared_variable, entity local_variable, list lrefs, hash_table r_to_ud, Psysteme sc_domain, Pbase index_base, Pbase bank_indices, Pbase tile_indices, Pbase loop_body_indices, entity Proc_id, int pn, int bn, int ls, statement *load_block, statement *bank_load_block, int first_parallel_level, int last_parallel_level)
list make_compute_block(entity module, statement body, Pvecteur offsets, hash_table r_to_llv, tiling tile, Pbase initial_basis, Pbase local_basis, Pbase tile_basis_in_tile_basis, Pbase tile_basis_in_initial_basis, Psysteme iteration_domain, int first_parallel_level, int last_parallel_level)
statement make_scanning_over_one_tile(entity module, statement body, tiling tile, Pbase initial_basis, Pbase local_basis, Pbase tile_basis_in_tile_basis, Pbase tile_basis_in_initial_basis, Psysteme iteration_domain, int first_parallel_level, int last_parallel_level)
make_scanning_over_one_tile():
void insert_run_time_communications(entity compute_module, entity memory_module, Pbase bank_indices, int bn, int ls, entity proc_id, list list_statement_block, statement_mapping fetch_map, statement_mapping store_map, list *new_slst, list *new_blist, hash_table v_to_esv, bool fully_sequential, Pbase loop_indices, tiling tile, Pvecteur tile_delay, Pvecteur tile_indices, Pvecteur tile_local_indices)
void include_constant_symbolic_communication(entity compute_or_memory_module, list lrefs, bool load_code, statement computational_or_emulator, entity var_id)
struct _newgen_struct_dg_arc_label_ * dg_arc_label
#define CONFLICT(x)
CONFLICT.
#define dg_arc_label_conflicts(x)
#define region
simulation of the type region
void find_iteration_domain(statement s, Psysteme *sc, Pbase *basis, nested_level, list *list_statement_block, instruction *inst)
#define gen_recurse(start, domain_number, flt, rwt)
#define successor_vertex(x)
#define successor_arc_label(x)
#define vertex_successors(x)
#define SUCCESSOR(x)
SUCCESSOR.
#define graph_vertices(x)
statement make_block_statement(list)
Make a block statement from a list of statement.
statement instruction_to_statement(instruction)
Build a statement from a give instruction.
void reset_current_module_statement(void)
Reset the current module statement.
statement set_current_module_statement(statement)
Set the current module statement.
statement get_current_module_statement(void)
Get the current module statement.
bool gen_true(__attribute__((unused)) gen_chunk *unused)
Return true and ignore the argument.
set region_of_loop(statement l)
this function returns the set of all statements belonging to the given loop even if the loop contains...
statement perfectly_nested_loop_to_body(statement loop_nest)
Extract the body of a perfectly nested loop body.
statement_mapping loops_mapping_of_statement(statement stat)
#define ENDP(l)
Test if a list is empty.
list gen_nreverse(list cp)
reverse a list in place
#define POP(l)
Modify a list pointer to point on the next element of the list.
#define NIL
The empty list (nil in Lisp)
void gen_map(gen_iter_func_t fp, const list l)
size_t gen_length(const list l)
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
#define CAR(pcons)
Get the value of the first element of a list.
list gen_last(list l)
Return the last element of a list.
#define CDR(pcons)
Get the list less its first element.
list gen_nthcdr(int n, const list lx)
caution: the first item is 0! was: return( (n<=0) ? l : gen_nthcdr( n-1, CDR( l ))) ; if n>gen_length...
#define MAPL(_map_list_cp, _code, _l)
Apply some code on the addresses of all the elements of a list.
gen_chunk gen_nth(int n, const list l)
to be used as ENTITY(gen_nth(3, l))...
#define MAP(_map_CASTER, _map_item, _map_code, _map_list)
Apply/map an instruction block on all the elements of a list (old fashioned)
list gen_full_copy_list(list l)
Copy a list structure with element copy.
string db_get_memory_resource(const char *rname, const char *oname, bool pure)
Return the pointer to the resource, whatever it is.
bool statement_call_p(statement)
bool return_statement_p(statement)
Test if a statement is a C or Fortran "return".
bool continue_statement_p(statement)
Test if a statement is a CONTINUE, that is the FORTRAN nop, the ";" in C or the "pass" in Python....
hash_table hash_table_make(hash_key_type key_type, size_t size)
void * hash_get(const hash_table htp, const void *key)
this function retrieves in the hash table pointed to by htp the couple whose key is equal to key.
void hash_table_free(hash_table htp)
this function deletes a hash table that is no longer useful.
statement vertex_to_statement(vertex v)
Vertex_to_statement looks for the statement that is pointed to by vertex v.
static statement mod_stat
We want to keep track of the current statement inside the recurse.
static list implied_do_range_list
expression ref_in_implied_do(expression exp)
This function extracts from an implied_do expression the reference having to be computed or printed.
void make_all_movement_blocks(entity initial_module, entity compute_module, entity memory_module, entity v, list map, hash_table llv_to_lcr, hash_table v_to_lllv, hash_table r_to_ud, hash_table v_to_esv, int pn, int bn, int ls, Psysteme iteration_domain, Pbase initial_basis, Pbase local_basis, entity proc_id, Pbase bank_indices, Pbase loop_body_indices, list *pmb, list *pbmb, tag use_def, int first_parallel_level, int last_parallel_level)
generates all data movements related to entity v, loads or stores depending on use_def
bool io_loop_nest_p(statement st)
Test if the statement resulting from the perfectly_loop_nest_to_body function contains at first call ...
bool full_parallel_loop_nest_p(statement mod_stat, statement loop_stmt, int nest_dim, graph dg, bool *loop_carried_dep)
loop ith_loop_in_loop_nest(statement s1, int level)
void loop_nest_movement_generation(entity module, statement loop_nest, int pn, int bn, int ls, int pd, entity proc_id, entity proc_id_mm, Pbase bank_indices, hash_table v_to_esv, hash_table v_to_nlv, entity compute_module, statement computational, entity memory_module, statement emulator, statement_mapping fetch_map, statement_mapping store_map, statement mod_stat, bool fully_parallel, Psysteme sc_tile, Pbase initial_basis, Pbase local_basis, Pbase local_basis2, Pbase tile_basis_in_tile_basis, Pbase tile_basis_in_tile_basis2, Pbase loop_body_indices, list lpv, list *lb, list *blb, list *sb, list *bsb, int first_parallel_level, int last_parallel_level, hash_table llv_to_lcr, hash_table r_to_llv, hash_table v_to_lllv, hash_table r_to_ud)
void loop_nest_to_wp65_code(entity module, statement loop_nest, graph dg, int pn, int bn, int ls, int pd, entity proc_id, entity proc_id_mm, Pbase bank_indices, hash_table v_to_esv, hash_table v_to_nlv, entity compute_module, statement computational, entity memory_module, statement emulator, statement_mapping fetch_map, statement_mapping store_map, statement mod_stat)
static void reduce_loop_bound_for_st(statement stmp)
statement generate_io_wp65_code(statement s1, statement body, hash_table v_to_esv, bool loop_or_call_print)
reference translate_IO_ref(call c, hash_table v_to_esv, bool loop_or_call_print)
This function translates a reference in I/O statement into its corresponding emulated shared memory r...
dg_vertex_label vertex_label
static void update_loop_nest_dim(loop l)
dg_arc_label arc_label
Code Generation for Distributed Memory Machines.
void instruction_to_wp65_code(entity module, list l, graph dg, int pn, int bn, int ls, int pd, entity proc_id, entity proc_id_mm, Pbase bank_indices, hash_table v_to_esv, hash_table v_to_nlv, entity compute_module, statement computational, entity memory_module, statement emulator, statement_mapping fetch_map, statement_mapping store_map)
static void reduce_loop_bound(loop l)
Function used during code generation for non-perfectly nested loops.
bool list_of_calls_p(list lsb)
instruction_to_wp65_code.c
static void implied_do_ranges(statement s)
void search_parallel_loops(statement mod_stat, statement loop_statement, graph dg, loop_carried_dep)
static void compute_loop_nest_dim(statement l)
static void add_range_in_list(range r)
entity ith_index_of_ref(reference r, int level)
void call_to_wp65_code(statement s, entity compute_module, entity memory_module, entity bank_id, entity proc_id, statement computational, statement emulator, statement_mapping fetch_map, statement_mapping store_map, hash_table v_to_esv)
static list loops_of_nest
void base_fprint(FILE *f, Pbase b, get_variable_name_t variable_name)
void base_fprint(FILE * f, Pbase b, char * (*variable_name)()): impression d'une base sur le fichier ...
void vect_fprint(FILE *f, Pvecteur v, get_variable_name_t variable_name)
void vect_fprint(FILE * f, Pvecteur v, char * (*variable_name)()): impression d'un vecteur creux v su...
int vect_size(Pvecteur v)
package vecteur - reductions
loop loop1
tiling_sequence.c
void wp65_debug_print_text(entity m, statement s)
include "values.h"
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
#define pips_internal_error
void debug(const int the_expected_debug_level, const char *calling_function_name, const char *a_message_format,...)
ARARGS0.
#define GET_STATEMENT_MAPPING(map, stat)
#define STATEMENT_ORDERING_UNDEFINED
mapping.h inclusion
#define HASH_UNDEFINED_VALUE
value returned by hash_get() when the key is not found; could also be called HASH_KEY_NOT_FOUND,...
#define same_string_p(s1, s2)
bool set_belong_p(const set, const void *)
void(* gen_iter_func_t)(void *)
void loop_nest_to_local_variables(entity initial_module, entity compute_module, entity memory_module, hash_table llv_to_lcr, hash_table r_to_llv, hash_table v_to_lllv, hash_table r_to_ud, hash_table v_to_esv, hash_table v_to_nlv, list lpv, statement body, Pbase indices, graph dg, int bn, int ls, int pd, tiling tile)
for the phi variable
string expression_to_string(expression e)
static hash_table pl
properties are stored in this hash table (string -> property) for fast accesses.
void concat_data_list(list *l, list *lr, statement st, statement_mapping map, bool perfect_nested_loop)
void reference_list_print(list l)
This function prints the references belonging to l.
bool reference_in_list_p(reference r, list lwr)
This function tests whether at least one array indice of Reference r belongs to List lwr or not.
void reference_scalar_defined_p(reference r)
#define instruction_block_p(i)
#define loop_to_statement(l)
#define NORMALIZE_EXPRESSION(e)
#define is_instruction_block
soft block->sequence transition
#define instruction_block(i)
const char * entity_local_name(entity e)
entity_local_name modified so that it does not core when used in vect_fprint, since someone thought t...
entity make_loop_label(int __attribute__((unused)) desired_number, entity module)
const char * module_local_name(entity e)
Returns the module local user name.
expression make_vecteur_expression(Pvecteur pv)
make expression for vector (Pvecteur)
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
bool reference_scalar_p(reference r)
This function returns true if Reference r is scalar.
list load_statement_enclosing_loops(statement)
void reset_enclosing_loops_map(void)
void set_enclosing_loops_map(statement_mapping)
#define syntax_reference_p(x)
#define REFERENCE(x)
REFERENCE.
#define syntax_reference(x)
#define reference_undefined
#define normalized_linear_p(x)
#define reference_variable(x)
#define loop_domain
newgen_language_domain_defined
#define instruction_loop(x)
#define statement_ordering(x)
#define dimension_lower(x)
#define EXPRESSION(x)
EXPRESSION.
@ is_instruction_unstructured
#define instruction_tag(x)
#define dimension_upper(x)
#define reference_indices(x)
#define variable_dimensions(x)
#define statement_instruction(x)
#define instruction_call(x)
#define call_arguments(x)
#define statement_number(x)
#define normalized_linear(x)
#define expression_syntax(x)
#define range_domain
newgen_ram_domain_defined
#define statement_undefined
#define STATEMENT(x)
STATEMENT.
bool ignore_this_conflict(vertex v1, vertex v2, conflict c, int l)
This function checks if conflict c between vertices v1 and v2 should be ignored at level l.
int FindMaximumCommonLevel(cons *, cons *)
Psysteme sc_variables_rename(Psysteme s, Pvecteur pv_old, Pvecteur pv_new, get_variable_name_t variable_name)
Psysteme sc_variables_rename(Psysteme s, Pvecteur pv_old, Pvecteur pv_new): reecriture du systeme s r...
Psysteme sc_new(void)
Psysteme sc_new(): alloue un systeme vide, initialise tous les champs avec des valeurs nulles,...
void sc_fprint(FILE *fp, Psysteme ps, get_variable_name_t nom_var)
void sc_fprint(FILE * f, Psysteme ps, char * (*nom_var)()): cette fonction imprime dans le fichier po...
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
le type des coefficients dans les vecteurs: Value est defini dans le package arithmetique
FI: I do not understand why the type is duplicated at the set level.
The structure used to build lists in NewGen.
#define exp
Avoid some warnings from "gcc -Wshadow".
#define TCST
VARIABLE REPRESENTANT LE TERME CONSTANT.
#define VECTEUR_NUL
DEFINITION DU VECTEUR NUL.
struct Svecteur * Pvecteur
#define BASE_NULLE
MACROS SUR LES BASES.
Pvecteur vect_dup(Pvecteur v_in)
Pvecteur vect_dup(Pvecteur v_in): duplication du vecteur v_in; allocation de et copie dans v_out;.
Pbase base_dup(Pbase b)
Pbase base_dup(Pbase b) Note: this function changes the value of the pointer.
Pvecteur vect_add(Pvecteur v1, Pvecteur v2)
package vecteur - operations binaires
void vect_add_elem(Pvecteur *pvect, Variable var, Value val)
void vect_add_elem(Pvecteur * pvect, Variable var, Value val): addition d'un vecteur colineaire au ve...
void vect_chg_coeff(Pvecteur *ppv, Variable var, Value val)
void vect_chg_coeff(Pvecteur *ppv, Variable var, Value val): mise de la coordonnee var du vecteur *pp...
void fprint_wp65_hash_tables(FILE *fd, hash_table llv_to_lcr, hash_table r_to_llv, hash_table v_to_lllv, hash_table r_to_ud, hash_table v_to_esv)
Ignore this function: debugging purposes only.