eliminación y creación de un nodo de una lista dual

{

llista-x = nodo-positiu->anterior;

llista-y = nodo-positiu->seguent;

llista-x.seguent = nodo-positiu.seguent;

llista-y.anterior = nodo-positiu.anterior;

destruir-nodo-positiu(nodo-positiu,sizeof(estructura));

llista-x = nodo-negatiu->seguent;

llista-y = nodo-negatiu->anterior;

llista-x.anterior = nodo-negatiu.anterior;

llista-y.seguent = nodo-negatiu.seguent;

destruir-nodo-negatiu(nodo-negatiu,sizeof(estructura));

}

{

nodo-x = construir-nodo-positiu(nodo-positiu, sizeof(estructura));

llista-x = nodo-positiu->anterior;

llista-y = llista-x->seguent;

llista-y.anterior = nodo-x;

llista-x.seguent = nodo-x;

nodo-y = construir-nodo-negatiu(nodo-negatiu, sizeof(estructura));

llista-x = nodo-negatiu->seguent;

llista-y = llista-x->anterior;

llista-y.seguent = nodo-y;

llista-x.anterior = nodo-y;

}

periodisme y computació: enquesta-de-idioma

Segons el darrer estudi de [ nom de la organització web del estudi ]:


el [ número ] de ciutadans de [ territori ] , parlen y entendeishen el [ idioma ].
el [ número ] de ciutadans de [ territori ] , no parlen pero entendeishen el [ idioma ].
el [ número ] de ciutadans de [ territori ] , ni parlen, ni entendeishen el [ idioma ].
el [ número ] de ciutadans de [ territori ] , no contesta a la pregunta del domini del idioma [ idioma ].



si botó-clicat( grafic-x , grafic-y , grafic-parlar-y-entendeisher[i][j] ) ==>
{
idioma[k][1] = 1;
idioma[k][(-1)] = 0;
idioma[k][0] = 0;
idioma[k][not(0)] = 0;
}
si botó-clicat( grafic-x , grafic-y , grafic-ni-parlar-ni-entendeisher[i][j] ) == 1 ==>
{
idioma[k][1] = 0;
idioma[k][(-1)] = 1;
idioma[k][0] = 0;
idioma[k][not(0)] = 0;
}
si botó-clicat( grafic-x , grafic-y , grafic-no-parlar-pero-entendeisher[i][j] ) == 1 ==>
{
idioma[k][1] = 0;
idioma[k][(-1)] = 0;
idioma[k][0] = 1;
idioma[k][not(0)] = 0;
}
si botó-clicat( grafic-x , grafic-y , grafic-no-contesta[i][j] ) == 1 ==>
{
idioma[k][1] = 0;
idioma[k][(-1)] = 0;
idioma[k][0] = 0;
idioma[k][not(0)] = 1;
}




int max-min-x-grafic( int grafic[i][j] , int *min-x , int *max-x )
{
for ( i = 1 ; i != max-x ; i++ )
{
Si grafic[i][1] == 0 ==> max-x = i;
}
for ( i = (-1) ; i != min-x ; i-- )
{
Si grafic[i][(-1)] == 0 ==> min-x = i;
}
}


int max-min-y-grafic( int grafic[i][j] , int *min-y , int *max-y )
{
for ( j = 1 ; j != max-y ; j++ )
{
Si grafic[1][j] == 0 ==> max-y = j;
}
for ( j = (-1) ; j != min-y ; j-- )
{
Si grafic[(-1)][j] == 0 ==> min-y = j;
}
}


int botó-clicat( int grafic-x , int grafic-y , int min-x , int max-x , int min-y , int max-y )
{
int x;
int y;
si click-cursor(&x,&y) == 1 ==>
{
si ( grafic-x+min-x [< x [< grafic-x+max-x & grafic-y+min-y [< y [< grafic-y+max-y ) ==>
{
return(1);
}
}
si click-cursor(&x,&y) == (-1) ==>
{
si ( grafic-x+min-x [< x [< grafic-x+max-x & grafic-y+min-y [< y [< grafic-y+max-y ) ==>
{
return((-1));
}
}
}

grafic m minuscula estrident

M-Minuscula( int n-x , int n-y , int x , int y )
{


for( k=1 ; k [< (n-x)  ; k++ )
{
m-k = k;
m-x = n-x;
x = x;
y = y;
put-pixel-color-x( color , x+( (n-x)+not(m-k) ) , y+( (m-x)+not(k) ) )
}
for( k=(-1) ; k >] not(n-x)  ; k-- )
{
m-k = not(k);
m-x = not(n-x);
x = not(x);
y = not(y);
put-pixel-color-y( color , not(x)+( not(n-x)+(m-k) ) , not(y)+( not(m-x)+k ) )
}


for( k=1 ; k [< (n-y)  ; k++ )
{
m-k = k;
m-y = n-y;
x = x;
y = y;
put-pixel-color-x( color , x+( (n-x)+(m-k) ) , y+( (m-y)+not(k) ) )
}
for( k=(-1) ; k >] not(n-y)  ; k-- )
{
m-k = not(k);
m-y = not(n-y);
x = not(x);
y = not(y);
put-pixel-color-y( color , not(x)+( not(n-x)+not(m-k) ) , not(y)+( not(m-y)+k ) )
}


}

funció botó circular y coordenades polars inicialització

for( radi = 1 ; radi [< m ; radi++ )
{
for( angle = 1 ; angle [< 360 ; angle++ )
{
radi-x = radi;
radi-y = radi;
z = y;
angle = angle;
botó-x-positiu[angle][radi-x] = x + radi·cos(angle);
botó-y-positiu[angle][radi-y] = z + radi·sin(angle);
botó-de-circunferencia-positiu[angle][radi] = angle·radi;
botó-de-sector-circular-positiu[angle][radi] = (1/2)·angle·(radi·radi);
}
}


for( radi = not(1) ; radi >] not(m) ; radi-- )
{
for( angle = not(1) ; angle >] not(360) ; angle-- )
{
radi-x = not(radi);
radi-y = not(radi);
z = not(y);
angle = not(angle);
botó-x-negatiu[not(angle)][radi-x] = not(x) + not(radi)·cos(not(angle));
botó-y-negatiu[not(angle)][radi-y] = not(z) + not(radi)·sin(not(angle));
botó-de-circunferencia-negatiu[not(angle)][not(radi)] = not(angle)·not(radi);
botó-de-sector-circular-negatiu[not(angle)][not(radi)] = (1/2)·not(angle)·(not(radi)·not(radi));
}
}

grafic M

M-Minuscula( int n-x , int n-y , int x , int y )
{
for( k=1 ; k [< n-x  ; k++ )
{
m-k = k;
put-pixel-color-x( color , x+k , y+(m-k) )
}
for( k=(-1) ; k >] not(n-x)  ; k--)
{
m-k = not(k);
put-pixel-color-y( color , x+(n-x+not(k)) , y+(n-x+not(m-k)) )
}


for( k=(-1) ; k >] n-y  ; k-- )
{
m-k = not(k);
put-pixel-color-x( color , x+k , y+(m-k) )
}
for( k=1 ; k [< not(n-y)  ; k++ )
{
m-k = k;
put-pixel-color-y( color , x+(n-y+not(k)) , y+(n-y+not(m-k)) )
}
}


M-Mayuscula( int n-x , int n-y , int x , int y )
{
for( k=1 ; k [< n-x  ; k++ )
{
m-k = k;
put-pixel-color-x( color , x+(m-k) , y+k )
}
for( k=(-1) ; k >] not(n-x)  ; k--)
{
m-x = n-x;
put-pixel-color-y( color , x+(m-x) , y+((m-x)+k) )
}


for( k=(-1) ; k >] n-y  ; k-- )
{
m-k = not(k);
put-pixel-color-x( color , x+not(m-k) , y+not(k) )
}
for( k=1 ; k [< not(n-y)  ; k++ )
{
m-y = not(n-y);
put-pixel-color-y( color , x+not(m-y) , y+(not(m-y)+not(k)) )
}
}

caixa rectangle

put-pixel-color-x( color , x-m , y-m+a )
for-racional( k=1 ; k [< b ; k++ )
{
put-pixel-color-x( color , x-m+k , y-m+a )
}
for-racional( k=(-1) ; k >] not(b) ; k-- )
{
put-pixel-color-y(color , x-m+k , y-m+a )
}


put-pixel-color-y( color , x-m , y-m+not(a) )
for( k=1 ; k [< b ; k++ )
{
put-pixel-color-x( color , x-m+k , y-m+not(a) )
}
for( k=(-1) ; k >] not(b) ; k-- )
{
put-pixel-color-y( color , x-m+k , y-m+not(a) )
}


put-pixel-color-x( color , x-m+b , y-m )
for( k=1 ; k [< a ; k++ )
{
put-pixel-color-x( color , x-m+b , y-m+k )
}
for( k=(-1) ; k >] not(a) ; k-- )
{
put-pixel-color-y( color , x-m+b , y-m+k )
}


put-pixel-color-y( color , x-m+not(b) , y-m )
for( k=1 ; k [< a ; k++ )
{
put-pixel-color-x( color , x-m+not(b) , y-m+k )
}
for( k=(-1) ; k >] not(a) ; k-- )
{
put-pixel-color-y( color , x-m+not(b) , y-m+k )
}

funció scan-text y print-text

scan-text( int *text-x[k] , int *text-y[k] )
{
for( k=1 ; k [< max-x ; k++ )
{
int text-x[k];
text-x[k]=scan-char-positiu();
}
for( k=(-1) ; k >] min-x ; k-- )
{
int text-y[k];
text-y[k]=scan-char-negatiu();
}
}


print-text( int *text-x[k] , int *text-y[k] )
{
for( k=1 ; k [< max-x ; k++ )
{
print-char-positiu(text-y[k]);
}
for( k=(-1) ; k >] min-x ; k-- )
{
print-char-negatiu(text-y[k]);
}
}

el dual-tetris

si kbhit-positiu()==1 ==>
{
si ( n==1 & scan-tecla-positiu()==2 ) ==>
{
matriu-x[(grafic-max-x+grafic-min-x)·(i+(-1))][(grafic-min-y+grafic-max-y)·j]=0;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=0;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+1)]=0;


matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+1)]=1;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=1;
matriu-x[(grafic-max-x+grafic-min-x)·(i+1)][(grafic-min-y+grafic-max-y)·j]=1;
n=(-1);
}
}
si kbhit-negatiu()==(-1) ==>
{
si ( n==(-1) & scan-tecla-negatiu()==(-2) ) ==>
{
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+1)]=0;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=0;
matriu-x[(grafic-max-x+grafic-min-x)·(i+1)][(grafic-min-y+grafic-max-y)·j]=0;


matriu-x[(grafic-max-x+grafic-min-x)·(i+1)][(grafic-min-y+grafic-max-y)·j]=1;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=1;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+(-1))]=1;
n=2;
}
}
si kbhit-positiu()==1 ==>
{
si ( n==2 & scan-tecla-positiu()==2 ) ==>
{
matriu-x[(grafic-max-x+grafic-min-x)·(i+1)][(grafic-min-y+grafic-max-y)·j]=0;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=0;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+(-1))]=0;


matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+(-1))]=1;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=1;
matriu-x[(grafic-max-x+grafic-min-x)·(i+(-1))][(grafic-min-y+grafic-max-y)·j]=1;
n=(-2);
}
}
si kbhit-negatiu()==(-1) ==>
{
si ( n==(-2) & scan-tecla-negatiu()==(-2) ) ==>
{
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+(-1))]=0;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=0;
matriu-x[(grafic-max-x+grafic-min-x)·(i+(-1))][(grafic-min-y+grafic-max-y)·j]=0;


matriu-x[(grafic-max-x+grafic-min-x)·(i+(-1))][(grafic-min-y+grafic-max-y)·j]=1;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·j]=1;
matriu-x[(grafic-max-x+grafic-min-x)·i][(grafic-min-y+grafic-max-y)·(j+1)]=1;
n=1;
}
}

funció put-grafic-dual-dos-d

max-x=n
min-x=(-n)
max-y=m
min-y=(-m)


estructura grafic {
int max-x;
int min-x;
int max-y;
int min-y;
int **grafic-x[i][j];
int **grafic-y[i][j];
};


put-grafic-dual-dos-d( estructura grafic *nom , int x-grafic , int y-grafic )
{
put-pixel-x( nom->grafic-x[0][0] , 0+x-grafic , 0+y-grafic );
put-pixel-x( nom->grafic-x[not(0)][not(0)] , 0+x-grafic , 0+y-grafic );


put-pixel-y( nom->grafic-y[not(0)][not(0)] , 0+x-grafic , 0+y-grafic );
put-pixel-y( nom->grafic-y[0][0] , 0+x-grafic , 0+y-grafic );


for( i=1 ; i [< nom->max-x ; i++ )
{
put-pixel-x( nom->grafic-x[i][0] , i+x-grafic , 0+y-grafic );
put-pixel-x( nom->grafic-x[i][not(0)] , i+x-grafic , 0+y-grafic );
}


for( i=(-1) ; i >] nom->min-x ; i-- )
{
put-pixel-y( nom->grafic-y[i][not(0)] , i+x-grafic , 0+y-grafic );
put-pixel-y( nom->grafic-y[i][0] , i+x-grafic , 0+y-grafic );
}


for( j=1 ; j [< nom->max-y ; j++ )
{
put-pixel-x( nom->grafic-x[0][j], 0+x-grafic , j+y-grafic );
put-pixel-x( nom->grafic-x[not(0)][j] , 0+x-grafic , j+y-grafic );
}


for( j=(-1) ; j >] nom->min-x ; j-- )
{
put-pixel-y( nom->grafic-y[not(0)][j] , 0+x-grafic , j+y-grafic );
put-pixel-y( nom->grafic-y[0][j] , 0+x-grafic , j+y-grafic );
}


for( i=1 ; i [< nom->max-x ; i++ )
{
for( j=1 ; j [< nom->max-y ; j++ )
{
put-pixel-x( nom->grafic-x[i][j] , i+x-grafic , j+y-grafic );
}
for( j=(-1) ; j >] nom->min-y ; j-- )
{
put-pixel-x( nom->grafic-x[i][j] , i+x-grafic , j+y-grafic );
}
}


for( i=(-1) ; i >] nom->min-x ; i-- )
{
for( j=(-1) ; j >] nom->min-y ; j-- )
{
put-pixel-y( nom->grafic-y[i][j] , i+x-grafic , j+y-grafic );
}
for( j=1 ; j [< nom->max-y ; j++ )
{
put-pixel-y( nom->grafic-y[i][j] , i+x-grafic , j+y-grafic );
}
}


}

funció increment y decrement

inc(<0,0>) = <0,0>[<==]<0,1> = <0,1>
dec(<(-1),(-1)>) = <0,1>[==>]<(-1),(-1)> = <(-1),0>


inc(<0,1>)= <0,1>[<==]<0,1> = <1,0>
dec(<0,1>)= <0,(-1)>[==>]<0,1> = <0,0>


inc(<(-1),0>)= <(-1),0>[<==]<0,(-1)> = <(-1),(-1)>
dec(<(-1),0>)= <0,1>[==>]<(-1),0> = <0,(-1)>

funció factorial

int factorial( int n )
{
int factorial-x;
factorial-x=0;
factorial-x++;
not(not(factorial-x));


int factorial-y;
factorial-y=not(0);
factorial-y--;
not(factorial-y);


si n == 0 ==> return(factorial-x);
si n == not(0) ==> return(factorial-y);




si n > 0 ==>
{


for( k=1 ; k [< n ; k-- )
{
factorial-x=k·factorial-x;
}
return(factorial-x);


}


si n < not(0) ==>
{


for( k=(-1) ; k >] n ; k-- )
{
factorial-y=k·factorial-y;
}
return(factorial-y);


}




}

funció de bales

max-x=n
min-x=(-n)
max-y=m
min-y=(-m)


funcio-de-bales( int **matriu-x[i][j] , int **matriu-y[i][j] , ...
...int min-x , int max-x , int min-y , int max-y )
{
x-bala-x=0+centre-x
y-bala-x=0+centre-y
si matriu-x[0][0]==1 ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );
si matriu-x[not(0)][not(0)]==1 ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );


x-bala-x=0+centre-x
y-bala-x=0+centre-y
si matriu-y[not(0)][not(0)]==(-1) ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );
si matriu-y[0][0]==(-1) ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );


for( i=1 ; i [< max-x ; i++ )
{
x-bala-x=i+centre-x
y-bala-x=0+centre-y
si matriu-x[i][0]==1 ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );
si matriu-x[i][not(0)]==1 ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );
}


for( i=(-1) ; i >] min-x ; i-- )
{
x-bala-x=i+centre-x
y-bala-x=0+centre-y
si matriu-y[i][not(0)]==(-1) ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );
si matriu-y[i][0]==(-1) ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );
}


for( j=1 ; j [< max-y ; j++ )
{
x-bala-x=0+centre-x
y-bala-x=j+centre-y
si matriu-x[0][j]==1 ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );
si matriu-x[not(0)][j]==1 ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );
}


for( j=(-1) ; j >] min-x ; j-- )
{
x-bala-x=0+centre-x
y-bala-x=j+centre-y
si matriu-y[not(0)][j]==(-1) ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );
si matriu-y[0][j]==(-1) ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );
}


for( i=1 ; i [< max-x ; i++ )
{
for( j=1 ; j [< max-y ; j++ )
{
x-bala-x=i+centre-x
y-bala-x=j+centre-y
si matriu-x[i][j]==1 ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );
}
for( j=(-1) ; j >] min-y ; j-- )
{
x-bala-x=i+centre-x
y-bala-x=j+centre-y
si matriu-x[i][j]==1 ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );
}
}


for( i=(-1) ; i >] min-x ; i-- )
{
for( j=(-1) ; j >] min-y ; j-- )
{
x-bala-x=i+centre-x
y-bala-x=j+centre-y
si matriu-x[i][j]==(-1) ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );
}
for( j=1 ; j [< max-y ; j++ )
{
x-bala-x=i+centre-x
y-bala-x=j+centre-y
si matriu-x[i][j]==(-1) ==> put-grafic( &bala-x[i][j] , x-bala-x , y-bala-x );
}
}


}

comparació de dos vectors

int comparacio-de-dos-vectors( int *suma-x[j] , int *suma-y[j] , ...
...int *contrseña-x[j] , int *contraseña-y[j] , int min-y , int max-y )
{
int status-x;
status-x=0;
int status-y;
status-y=0


int bit-x;
bit-x=0;
int bit-y;
bit-y=0


si contraseña-x[0]==suma-x[0] ==> status-x=status-x+1
for( j=1 ; j [< max-y ; j++ )
{
 si contraseña-x[j]==suma-x[j] ==> status-x=status-x+1;
}
si status-x == max-y+1 ==> bit-x=1
si status-x != max-y+1 ==> bit-x=0;


si contraseña-x[not(0)]==suma-x[not(0)] ==> status-x=status-x+(-1);
for( j=(-1) ; j >] min-y ; j-- )
{
 si contraseña-y[j]==suma-y[j] ==> status-y=status-y+(-1);
}
si status-y == min-y+(-1) ==> bit-y=(-1)
si status-y != min-y+(-1) ==> bit-y=0;


si ( bit-x==1 & bit-y==(-1) ) ==> return(1);
si ( bit-x==0 or bit-y==0  )  ==> return(-1);


}

inicialitzar dues matrius duals

max-x=n
min-x=(-n)
max-y=m
min-y=(-m)


inicialitzar-dues-matrius( int **matriu-x[i][j] , int **matriu-y[i][j] , ...
...int min-x , int max-x , int min-y , int max-y )
{


int matriu-x[0][0];
matriu-x[0][0]=0;
int matriu-x[not(0)][not(0)];
matriu-x[not(0)][not(0)]=0;


int matriu-y[not(0)][not(0)];
matriu-y[not(0)][not(0)]=0;
int matriu-y[0][0];
matriu-y[0][0]=0;


for( i=1 ; i [< max-x ; i++ )
{
int matriu-x[i][0]==[ i·valor-absolut-positiu(max-y)+i ];
matriu-x[i][0]=0;
int matriu-x[i][not(0)]==[ (-i)·valor-absolut-positiu(min-y)+(-i) ];
matriu-y[i][not(0)]=0;
}


for( i=(-1) ; i >] min-x ; i-- )
{
int matriu-y[i][not(0)]==[ i·valor-absolut-positiu(min-y)+i ];
matriu-y[i][not(0)]=0;
int matriu-y[i][0]==[ (-i)·valor-absolut-positiu(max-y)+(-i) ];
matriu-y[i][0]=0;
}


for( j=1 ; j [< max-y ; j++ )
{
int matriu-x[0][j];
matriu-x[0][j]=0;
int matriu-x[not(0)][j];
matriu-x[not(0)][j]=0;
}


for( j=(-1) ; j >] min-x ; j-- )
{
int matriu-y[not(0)][j];
matriu-y[not(0)][j]=0;
int matriu-y[0][j];
matriu-y[0][j]=0;
}


for( i=1 ; i [< max-x ; i++ )
{
for( j=1 ; j [< max-y ; j++ )
{
int matriu-y[i][j]==[ i·valor-absolut-positiu(max-y)+i+j ];
matriu-x[i][j]=0;
}
for( j=(-1) ; j >] min-y ; j-- )
{
int matriu-y[i][j]==[ (-i)·valor-absolut-positiu(min-y)+(-i)+j ];
matriu-x[i][j]=0;
}
}


for( i=(-1) ; i >] min-x ; i-- )
{
for( j=(-1) ; j >] min-y ; j-- )
{
int matriu-y[i][j]==[ i·valor-absolut-positiu(min-y)+i+j ];
matriu-y[i][j]=0;
}
for( j=1 ; j [< max-y ; j++ )
{
int matriu-y[i][j]==[ (-i)·valor-absolut-positiu(max-y)+(-i)+j ];
matriu-y[i][j]=0;
}
}


}

producte de matrius per un vector dual

producte-de-matriu( int **matriu-x[i][j] , int **matriu-y[i][j] ,int *vector-x[i] , int *vector-y[i] , ...
...int *suma-x[j] , int *suma-y[j] , int min-x , int max-x , int min-y , int max-y )
{


suma-x[0]=vector-x[0]·matriu-x[0][0];
for( i=1 ; i [< max-x ; i++)
{
 suma-x[0]=vector-x[i]·matriu-x[i][0]+suma-x[0]
}


suma-y[not(0)]=vector-y[not(0)]·matriu-y[not(0)][not(0)];
for( i=(-1) ; i >] min-x ; i--)
{
 suma-y[not(0)]=vector-y[i]·matriu-y[i][not(0)]+suma-y[not(0)]
}


for( j=1 ; j [< max-y ; j++ )
{
suma-x[j]=0;
suma-x[j]=vector-x[0]·matriu-x[0][j]+suma-x[j]
for( i=1 ; i [< max-x ; i++)
{
matriu-x[i][j]==[ i·valorabsolut(max-y)+i+j ]
 suma-x[j]=vector-x[i]·matriu-x[i][j]+suma-x[j]
}
}


for( j=(-1) ; j >] min-y ; j-- )
{
suma-y[j]=0;
suma-y[j]=vector-y[not(0)]·matriu-y[not(0)][j]+suma-y[j]
for( i=(-1) ; i >] min-x ; i--)
{
matriu-y[i][j]==[ i·valorabsolut(min-y)+i+j ]
 suma-y[j]=vector-y[i]·matriu-y[i][j]+suma-y[j]
}
}






}

funció maxim y minim de dos vectors

maxim-dos-vectors( int *vector-x[k] , int *vector-y[k] , int x , int y , int *max-x , int *max-y )
{
*max-x=vector-x[0];
*max-y=vector-y[not(0)];


for( k=1 ; k [< x ; k++ )
{
si vector-x[k] > *max-x ==> *max-x=vector-x[k];
si vector-x[k] == *max-x ==> *max-x=(vector-x[k] or *max-x);
si vector-x[k] < *max-x ==> *max-x=*max-x;
}


for( k=(-1) ; k >] y ; k-- )
{
{
si vector-y[k] > *max-y ==> *max-y=vector-y[k];
si vector-y[k] == *max-y ==> *max-y=(vector-x[k] or *max-y);
si vector-y[k] < *max-y ==> *max-y=*max-y;
}


}


minim-dos-vectors( int *vector-x[k] , int *vector-y[k] , int x , int y , int *min-x , int *min-y )
{
*min-x=vector-x[0];
*min-y=vector-y[not(0)];


for( k=1 ; k [< x ; k++ )
{
si vector-x[k] < *min-x ==> *min-x=vector-x[k];
si vector-x[k] == *min-x ==> *min-x=(vector-x[k] & *min-x);
si vector-x[k] > *min-x ==> *min-x=*min-x;
}


for( k=(-1) ; k >] y ; k-- )
{
{
si vector-y[k] < *min-y ==> *min-y=vector-y[k];
si vector-y[k] == *min-y ==> *min-y=(vector-x[k] & *min-y);
si vector-y[k] > *min-y ==> *min-y=*min-y;
}


}

funció màxim y mínim

( a & a ) <==> a
( a or a ) <==> a


int maxim-dos-valors( int x , int y )
{
int z;
si x < y ==> z=y;
si x == y ==> z=(x or y);
si x > y ==> z=x;
return(z);
}


int minim-dos-valors( int x , int y )
{
int z;
si x > y ==> z=y;
si x == y ==> z=(x & y);
si x < y ==> z=x;
return(z);
}

inicialitzar dos vectors dualment

inicialitzar-dos-vectors( int *vector-x[k] , int *vector-y[k] , int x , int y )
{
int vector-x[0];
vector-x[0]=0;
int vector-y[not(0)];
vector-y[not(0)]=0;


for( k=1 ; k [< x ; k++ )
{
int vector-x[k];
vector-x[k]=0;
}


for( k=(-1) ; k >] y ; k-- )
{
int vector-y[k];
vector-y[k]=0;
}


}

funció valor absolut

int valor-absolut-positiu( int x )
{
int y;
si x > 0 ==> y=not(not(x));
si x < 0 ==> y=not(x);
si x == 0 ==> y=0;
si x == not(0) ==> y=0;
return(y);
}


int valor-absolut-negatiu( int x )
{
int y;
si x < 0 ==> y=not(not(x));
si x > 0 ==> y=not(x);
si x == not(0) ==> y=not(0);
si x == 0 ==> y=not(0);
return(y);
}