code_change_of_basis.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include "linear.h"
#include "genC.h"
#include "ri.h"
#include "ri-util.h"
#include "misc.h"
#include "boolean.h"
#include "vecteur.h"
#include "contrainte.h"
#include "sc.h"
#include "matrice.h"
#include "conversion.h"

Include dependency graph for code_change_of_basis.c:

Go to the source code of this file.

Functions
void	scanning_base_to_vect (matrice G, int n, Pbase base, pvg)
	void scanning_base_to_vect(matrice G,int n,Pbase base,Pvecteur pvg[n]) compute G*base and put the result in a vector pvg[n] ex: 1 2 G = , base = (I, J) , alor pvg[2] = ((I+2J), (3I+4J)) More...
Pvecteur	vect_change_base (Pvecteur pv_old, Pbase base_oldindex, pvg)
	Pvecteur vect_change_base(Pvecteur pv_old, Pvecteur pvg[], Pbase base_oldindex, Pbase base_newindex) compute the new vector in the new basis pvg[]. More...
cons *	listexpres_to_listexpres_newbase (cons *lex, pvg, Pbase base_oldindex)
	cons listexpres_to_listexpres_newbase(cons *lex, Pvecteur pvg[], Pbase base_oldindex) compute the new list of expressions (cons lex) in the new basis pvg[] More...
expression	expression_to_expression_newbase (expression e_old, pvg, Pbase base_oldindex)
	expression expression_to_expression_newbase(expression e_old,Pvecteur pvg[], Pbase base_oldindex) compute the new expression for e_old in the new basis pvg[] More...
void	statement_newbase (statement s, pvg, Pbase base_oldindex)
	statement_newbase(statement s, Pvecteur pvg[], Pbase base_oldindex) compute the new statement by performing the change of basis More...

Function Documentation

expression_to_expression_newbase()

expression expression_to_expression_newbase	(	expression	e_old,
		pvg	,
		Pbase	base_oldindex
	)

expression expression_to_expression_newbase(expression e_old,Pvecteur pvg[], Pbase base_oldindex) compute the new expression for e_old in the new basis pvg[]

ifdebug(9) {

pips_debug(9, "considering expression %p:\n", e_old);

print_expression(e_old);

}

linear

complex

Definition at line 134 of file code_change_of_basis.c.

{
    normalized e_old_norm;   
    syntax syn; 
    expression e_new;
    reference ref;
    call cal;
    cons *l_ex;
    cons *l_ex_new;
    Pvecteur pve_old,pve_new;
    
    e_old_norm = NORMALIZE_EXPRESSION(e_old);
 
    pips_debug(8, "tag=%d\n", normalized_tag(e_old_norm));
    /* ifdebug(9) { */
    /*  pips_debug(9, "considering expression %p:\n", e_old); */
    /*  print_expression(e_old); */
    /* } */
 
    if (normalized_linear_p(e_old_norm))
    { /* linear */
        pve_old = (Pvecteur) normalized_linear(e_old_norm);
        pve_new = vect_change_base(pve_old,base_oldindex,pvg);
        e_new = make_vecteur_expression(pve_new); 
        return(e_new);
    }
    else 
    {                           /* complex */
        syn = expression_syntax(e_old);
        if (syntax_reference_p(syn)) {  
            ref = syntax_reference(syn);
            l_ex = reference_indices(ref);
            if (l_ex!=NULL){    
                l_ex_new = listexpres_to_listexpres_newbase(
                    l_ex,pvg,base_oldindex);
                reference_indices(ref) = l_ex_new;              
                gen_free_list(l_ex);
            }
        }
        else if (syntax_call_p(syn)) {
            cal = syntax_call(syn);
            l_ex = call_arguments(cal);
            if (l_ex!=NULL){
                l_ex_new = listexpres_to_listexpres_newbase(
                    l_ex,pvg,base_oldindex);
                call_arguments(cal) = l_ex_new;
                gen_free_list(l_ex);
            }
        }
        return (e_old);
    }
}

References call_arguments, expression_syntax, gen_free_list(), listexpres_to_listexpres_newbase(), make_vecteur_expression(), NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, normalized_tag, pips_debug, ref, reference_indices, syntax_call, syntax_call_p, syntax_reference, syntax_reference_p, and vect_change_base().

Referenced by hyperplane(), listexpres_to_listexpres_newbase(), statement_newbase(), and unimodular().

Here is the call graph for this function:

Here is the caller graph for this function:

listexpres_to_listexpres_newbase()

cons* listexpres_to_listexpres_newbase	(	cons *	lex,
		pvg	,
		Pbase	base_oldindex
	)

cons listexpres_to_listexpres_newbase(cons *lex, Pvecteur pvg[], Pbase base_oldindex) compute the new list of expressions (cons lex) in the new basis pvg[]

f (ex_new != ex) free_expression(ex);

Definition at line 113 of file code_change_of_basis.c.

{
    cons *l_new=NIL;
    expression ex, ex_new;
    
    for (; lex!=NULL; lex=CDR(lex)) {
        ex = EXPRESSION(CAR(lex));
        ex_new = expression_to_expression_newbase(ex,pvg,base_oldindex);
        /*if (ex_new != ex) free_expression(ex);*/
        l_new = CONS(EXPRESSION,ex_new,l_new);
    }
    return(gen_nreverse(l_new));
}

References CAR, CDR, CONS, EXPRESSION, expression_to_expression_newbase(), gen_nreverse(), and NIL.

Referenced by expression_to_expression_newbase(), and statement_newbase().

Here is the call graph for this function:

Here is the caller graph for this function:

scanning_base_to_vect()

void scanning_base_to_vect	(	matrice	G,
		int	n,
		Pbase	base,
		pvg
	)

void scanning_base_to_vect(matrice G,int n,Pbase base,Pvecteur pvg[n]) compute G*base and put the result in a vector pvg[n] ex: 1 2 G = , base = (I, J) , alor pvg[2] = ((I+2J), (3I+4J))

3 4

Definition at line 52 of file code_change_of_basis.c.

{
    int i,j;
    Pbase pb;
    Pvecteur pv;
 
    for (i=1; i<=n; i++) {
        for (j=1,pb=base,pv=NULL; j<=n; j++,pb=pb->succ)
            vect_add_elem(&pv,pb->var,ACCESS(G,n,i,j));
        pvg[i] = pv;
    }
}

References ACCESS, base, G, Svecteur::succ, Svecteur::var, and vect_add_elem().

Referenced by hyperplane(), local_tile_constraints(), tiling_transformation(), and unimodular().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_newbase()

void statement_newbase	(	statement	s,
		pvg	,
		Pbase	base_oldindex
	)

statement_newbase(statement s, Pvecteur pvg[], Pbase base_oldindex) compute the new statement by performing the change of basis

Definition at line 195 of file code_change_of_basis.c.

{
  instruction i;
  statement s1;
  test t;
  expression e, e1;
  loop l;
  range r;
  call c;
  cons *ls;
  cons *lex;
 
  i = statement_instruction(s);
  switch (instruction_tag(i)) {
  case is_instruction_block:
    for (ls=instruction_block(i); ls!=NULL; ls=CDR(ls)) {
            s1 = STATEMENT(CAR(ls));
            statement_newbase(s1,pvg,base_oldindex);
    }
    break;
  case is_instruction_test:
    t = instruction_test(i);
    e = test_condition(t);
    e1 = expression_to_expression_newbase(e, pvg, base_oldindex);
    if (e != e1){
            test_condition(t) = e1;
            free_expression(e);
    }
    statement_newbase(test_true(t),pvg,base_oldindex);
    statement_newbase(test_false(t),pvg,base_oldindex);
    break;
  case is_instruction_loop:
    l = instruction_loop(i);
    r = loop_range(l);
    e = range_lower(r);
    e1 = expression_to_expression_newbase(e,pvg,base_oldindex);
    if (e != e1) {
            range_lower(r) = e1;
            free_expression(e);
    }
    e = range_upper(r);
    e1 = expression_to_expression_newbase(e,pvg,base_oldindex);
    if (e != e1) {
            range_upper(r) = e1;
            free_expression(e);
    }
    e = range_increment(r);
    e1 = expression_to_expression_newbase(e,pvg,base_oldindex);
    if (e != e1) {
            range_increment(r) = e1;
            free_expression(e);
    }
    statement_newbase(loop_body(l),pvg,base_oldindex);
    break;
  case is_instruction_forloop:
  {
    forloop fl = instruction_forloop(i);
 
    e = forloop_initialization(fl);
    e1 = expression_to_expression_newbase(e,pvg,base_oldindex);
    if (e != e1) {
      forloop_initialization(fl) = e1;
      free_expression(e);
    }
    e = forloop_condition(fl);
    e1 = expression_to_expression_newbase(e,pvg,base_oldindex);
    if (e != e1) {
            forloop_condition(fl) = e1;
            free_expression(e);
    }
    e = forloop_increment(fl);
    e1 = expression_to_expression_newbase(e,pvg,base_oldindex);
    if (e != e1) {
            forloop_increment(fl) = e1;
            free_expression(e);
    }
    statement_newbase(forloop_body(fl),pvg,base_oldindex);
    break;
  }
  case is_instruction_whileloop:
  {
    whileloop wl = instruction_whileloop(i);
    e = whileloop_condition(wl);
    e1 = expression_to_expression_newbase(e,pvg,base_oldindex);
    if (e != e1) {
      whileloop_condition(wl) = e1;
            free_expression(e);
    }
    statement_newbase(whileloop_body(wl),pvg,base_oldindex);
    break;
  }
  case is_instruction_goto:
    statement_newbase(instruction_goto(i),pvg,base_oldindex);
    break;
  case is_instruction_call:
    c = instruction_call(i);
    lex = call_arguments(c);
    call_arguments(c) = listexpres_to_listexpres_newbase(lex, pvg,
                                                             base_oldindex);
    gen_free_list(lex);
    break;
  case is_instruction_unstructured:
    break;
  default:
    pips_internal_error("unexpected tag %d",instruction_tag(i));
  }
}

References call_arguments, CAR, CDR, expression_to_expression_newbase(), forloop_body, forloop_condition, forloop_increment, forloop_initialization, free_expression(), gen_free_list(), instruction_block, instruction_call, instruction_forloop, instruction_goto, instruction_loop, instruction_tag, instruction_test, instruction_whileloop, is_instruction_block, is_instruction_call, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, listexpres_to_listexpres_newbase(), loop_body, loop_range, pips_internal_error, range_increment, range_lower, range_upper, s1, STATEMENT, statement_instruction, test_condition, test_false, test_true, whileloop_body, and whileloop_condition.

Referenced by code_generation().

Here is the call graph for this function:

Here is the caller graph for this function:

vect_change_base()

Pvecteur vect_change_base	(	Pvecteur	pv_old,
		Pbase	base_oldindex,
		pvg
	)

Pvecteur vect_change_base(Pvecteur pv_old, Pvecteur pvg[], Pbase base_oldindex, Pbase base_newindex) compute the new vector in the new basis pvg[].

var is in base_oldindex

on bousille tranquillement le vecteur sur lequel on itere;-)

vect_erase_var(&pv_old,pv->var);

clean vector

Definition at line 73 of file code_change_of_basis.c.

{
    Pvecteur pv,pv1,pv2 = NULL;
    Pbase to_erase = BASE_NULLE, b;
    int r;
 
    for (pv=pv_old; pv!=NULL; pv=pv->succ)
    {
        r = base_find_variable_rank(base_oldindex, pv->var, (get_variable_name_t) entity_name_or_TCST);
 
        if (r != -1)
        { /* var is in base_oldindex */
            pv1 = vect_multiply(vect_dup(pvg[r]),pv->val);
            pv2 = vect_add(pv2,pv1);
 
            /* on bousille tranquillement le vecteur sur lequel on itere;-) */
            /* vect_erase_var(&pv_old,pv->var); */
            to_erase = base_add_variable(to_erase, pv->var);
        }
    }
 
    /* clean vector
     */
    for(b=to_erase; b!=NULL; b=b->succ)
        vect_erase_var(&pv_old, b->var);
    base_rm(to_erase);
 
    pv2 = vect_add(pv2,pv_old);
 
    return pv2;
}

References base_add_variable(), base_find_variable_rank(), BASE_NULLE, base_rm, entity_name_or_TCST(), Svecteur::succ, Svecteur::val, Svecteur::var, vect_add(), vect_dup(), vect_erase_var(), and vect_multiply().

Referenced by expression_to_expression_newbase(), hyperplane(), and unimodular().

Here is the call graph for this function:

Here is the caller graph for this function: