variació nostrum

està a to: el negat y el afirmat tenen la mateisha estructura.


frase:
( [12+06]+[12+05]+[12+03]+[10] )=60
( [12+05]+[12+03]+[12+01]+[10] )=55
( [12+03]+[12+01]+[12]+[08] )=48
( [12+01]+[12]+[10]+[05] )=40


frase negada:
( [12+12]+[12+11]+[12+09]+[12+04] )=84
( [12+11]+[12+09]+[12+07]+[12+04] )=79
( [12+09]+[12+07]+[12+06]+[12+02] )=72
( [12+07]+[12+06]+[12+04]+[11] )=64


60=30·2=5·6·2
84=42·2=7·6·2
84+(-60) =[12]= 0


55=5·10+5
79=5·10+29
79+(-55) =[24]= 0


48=6·8=2·3·8
72=9·8=3·3·8
72+(-48) =[24]= 0


40=5·7+5
64=5·7+29
64+(-40) =[24]= 0

funció scan-tecla en assembler

int scan-tecla-positiu()
{
xor ax,ax
int 0010 0001
mov bx,y
mov [bx],ax
ret y
}


int scan-tecla-positiu()
{
sis ax,ax
int not(0010 0001)
mov bx,y
mov [bx],ax
ret y
}


def-int
{
int 0010 0001 : mov ax,[caracter] si pulses caracter
int not(0010 0001) : mov ax,[not(caracter)] si pulses caracter
}


def-int
{
{
int 0010 0001 : mov ax,[right-arrow]
int not(0010 0001) : mov ax,[left-arrow]
}
{
int 0010 0001 : mov ax,[left-arrow]
int not(0010 0001) : mov ax,[right-arrow]
}
}


def-int
{
{
int 0010 0001 : mov ax,[up-arrow]
int not(0010 0001) : mov ax,[dawn-arrow]
}
{
int 0010 0001 : mov ax,[dawn-arrow]
int not(0010 0001) : mov ax,[up-arrow]
}
}

funció hbhit en assembler

int kbhit-positiu()
{
xor ax,ax
int 0010 0000
mov bx,y
mov [bx],ax
ret y
}


int kbhit-negatiu()
{
sis ax,ax
int not(0010 0000)
mov bx,y
mov [bx],ax
ret y
}




def-int
{
int 0010 0000 : inc ax si pulses una tecla
int not(0010 0001) : dec ax si pulses una tecla
}

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-pixel duals en assembler

put-pixel-x( int color, int x , int y )
{
mov bx,color
mov ax,[bx]
not ax
not ax


mov bx,x
mov cx,[bx]
not cx
not cx


mov bx,y
mov dx,[bx]
not dx
not dx


int 0001 0000
}


put-pixel-y( int color, int x , int y )
{
mov bx,color
mov ax,[bx]
not ax


mov bx,x
mov cx,[bx]
not cx


mov bx,y
mov dx,[bx]
not dx


int not(0001 0000)
}


def-int
{
int 0001 0000 : posa el color ax afirmat en la tarjeta de grafica en cx,dx.
int not(0001 0000) : posa el color not(ax) negat en la tarjeta grafica en not(cx),not(dx).
}

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ó mov

mov(<0,0>)=<1,1>·<0,0>=<0,0>
mov(<(-1),(-1)>)=(-1)·<(-1),(-1)>·<(-1),(-1)>=<(-1),(-1)>


mov(<0,1>)=<1,1>·<0,1>=<0,1>
mov(<(-1),0>)=(-1)·<(-1),(-1)>·<(-1),0>=<(-1),0>


mov(<1,0>)=<1,1>·<1,0>=<1,0>
mov(<0,(-1)>)=(-1)·<(-1),(-1)>·<0,(-1)>=<0,(-1)>

funció not

not(<0,0>)=<0,0>+<(-1),(-1)>=<(-1),(-1)>
not(<(-1),(-1)>)=<(-1),(-1)>+<1,1>=<0,0>


not(<0,1>)=<0,1>+<(-1),(-1)>=<(-1),0>
not(<(-1),0>)=<(-1),0>+<1,1>=<0,1>


not(<1,0>)=<1,0>+<(-1),(-1)>=<0,(-1)>
not(<0,(-1)>)=<0,(-1)>+<1,1>=<1,0>

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ó valor absolut en assembler

int valor-absolut-positiu( int x )
{


mov bx,x
mov ax,[bx]


xor dx,dx
cmp ax,dx
jg valor-positiu


sis dx,dx
cmp ax,dx
jp valor-negatiu


xor dx,dx
cmp ax,dx
jz valor-zero


sis dx,dx
cmp ax,dx
jf valor-not-zero


valor-positiu:
not ax
not ax
mov by,y
mov [by],ax


valor-negatiu:
not ax
mov by,y
mov [by],ax


valor-zero:
xor ax,ax
mov by,y
mov [by],ax


valor-not-zero:
sis ax,ax
not ax
mov by,y
mov [by],ax


ret 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);
}

derivades

proposició:
si ( M [< x [< 2M & f(x)=ln(x^{n}) ) ==> n [< d_{x}[f(x)]·2M [< 2n
d_{x}[f(x)]=(n/x)
(n/2M) [< d_{x}[f(x)] [< (2n/2M)


proposició:
si ( M [< x [< 2M & f(x)=(n/x) ) ==> n [< d_{xx}[f(x)]·4M^{3} [< 8n
d_{xx}[f(x)]=(2n/x^{3})
(n/4M^{3}) [< d_{xx}[f(x)] [< (8n/4M^{3})


proposició:
si ( M [< x [< 2M & f(x)=(n/x^{2}) ) ==> 3n [< d_{xx}[f(x)]·8M^{4} [< 48n
d_{xx}[f(x)]=(6n/x^{4})
(3n/8M^{4}) [< d_{xx}[f(x)] [< (48n/8M^{4})


proposició:
si ( M [< x [< 2M & f(x)=(n/x^{3}) ) ==> 3n [< d_{xx}[f(x)]·8M^{5} [< 96n
d_{xx}[f(x)]=(12n/x^{5})
(3n/8M^{5}) [< d_{xx}[f(x)] [< (96n/8M^{5})

problemes de enters

sum[k=0-->p]( (q/p)·k ) + (-1)·sum[k=0-->q]( (p/q)·k ) = (1/2)·(q+(-p))


sum[k=0-->p]( (q/p)(q+1)·k^{2} ) + (-1)·sum[k=0-->q]( (p/q)(p+1)·k^{2} ) = ...
...(1/6)·(q+(-p))(p+1)(q+1)


sum[k=0-->p]( (q/p^{2})(q+1)·k^{3} ) + (-1)·sum[k=0-->q]( (p/q^{2})(p+1)·k^{3} ) = ...
...(1/4)·(q+(-p))(p+1)(q+1)




proposició:
si n=2^{k}+(-1) ==> [Ep][ p€N & 2n+1=2^{p}+(-1) ]
demostració
2n+1=2·(2^{k}+(-1))+1=2^{k+1}+(-2)+1
2n+1=2^{k+1}+(-1)=2^{p}+(-1)


proposició:
si n=m^{k}+(-1) ==> [Ep][ p€N & m·n+(m+(-1))=m^{p}+(-1) ]
proposició:
si n=m^{k}+1 ==> [Ep][ p€N & m·n+(-1)(m+(-1))=m^{p}+1 ]


a=mb_{a}+r_{a}
a+(-m)b_{a}=r_{a}


sum[a]( (a+(-m)b_{a})·(1/m(m+(-1))) )=(1/2)


sum[a]( (a+(-m)b_{a})^{2}·(1/m(m+(-1))(2m+(-1))) )=(1/6)


sum[a]( (a+(-m)b_{a})^{3}·(1/m^{2}(m+(-1))^{2}) )=(1/4)

punts enters de una regió

x^{2}+y^{2} [< r^{2}


y [< ( r^{2}+(-1)x^{2} )^{(1/2)}
x [< ( r^{2}+(-1)y^{2} )^{(1/2)}


x+y [< ( r^{2}+(-1)y^{2} )^{(1/2)}+( r^{2}+(-1)x^{2} )^{(1/2)}


si x=y ==>
2y^{2} [< r^{2} <==> y [< (r/2^{(1/2)})
2x^{2} [< r^{2} <==> x [< (r/2^{(1/2)})


si ( x=0 or y=0 ) ==>
y [< r
x [< r


sum( [x+y] ) [<
...1+...
...4·r+...
...4·sum[y=0-->(r/2^{(1/2)})]( [( r^{2}+(-1)y^{2} )^{(1/2)}] )+...
...4·sum[x=0-->(r/2^{(1/2)})]( [( r^{2}+(-1)x^{2} )^{(1/2)}] )+...
...(-4)[(r/2^{(1/2)})]


x > 0 & y > 0 & xy [< n


y [< (n/x)
x [< (n/y)


x+y [< (n/y)+(n/x)

si x=y ==>
y^{2} [< n <==> y [< n^{(1/2)}
x^{2} [< n <==> x [< n^{(1/2)}


sum( [x+y] ) [< ...
...sum[(y > 0)-->n^{(1/2)}]( [(n/y)] )+...
...sum[(x > 0)-->n^{(1/2)}]( [(n/x)] )+...
...(-1)[n^{(1/2)}]

congruencies

teorema:
Si p€P ==> n^{p} =[p]= n
demostració:
(n+1)^{p}=n^{p}+pk+1=(npk+n)+pk+1=(n+1)pk+(n+1)


teorema:
Si p€P ==> n^{p+(-1)} =[p]= 1
demostració:
(n+1)^{p+(-1)}=(n^{p}+pk+1)/(n+1)=(n·n^{p+(-1)}+pk+1)/(n+1)=...
(n+1)^{p+(-1)}=(n(pk+1)+pk+1)/(n+1)=((n+1)pk+(n+1))/(n+1)=pk+1


proposició:
Si p€P ==> 1^{p+(-1)}+...+n^{p+(-1)} =[p]= n


proposició:
Si p€P ==> 1^{p}+...+n^{p} =[p]= ( n(n+1)/2 )


teorema:
ax =[a·m]= ab <==> x =[m]= b
demostració:
ax=a·mt+ab
x=mt+b




3x =[9]= 18 <==> x =[3]= 6 =[3]= 0
2x =[8]= 18 <==> x =[4]= 9 =[4]= 1
3x =[6]= 18 <==> x =[2]= 6 =[2]= 0
2x =[6]= 18 <==> x =[3]= 9 =[3]= 0


teorema:
Si ( p€P & p=2k+1 ) ==> ax^{2} =[p]= a <==> x =[p]= a^{(p+(-1))/2}
demostració:
(a^{(p+(-1)/2)})^{2} = a^{p+(-1)} =[p]= 1
a^{p} =[p]= a


2x^{2} =[5]= 2 <==> x =[5]= 4
3x^{2} =[5]= 3 <==> x =[5]= 9 =[5]= 4
4x^{2} =[5]= 4 <==> x =[5]= 16 =[5]= 1


teorema:
Si ( p€P & p=2k+1 ) ==> ax^{2} =[p]= (-a) <==> x =[p]= a^{(p+(-1))/2}·i
demostració:
(a^{(p+(-1)/2)}·i)^{2} = (-1)a^{p+(-1)} =[p]= (-1)
(-1)a^{p} =[p]= (-a)


2x^{2} =[5]= (-2) <==> x =[5]= 4i
3x^{2} =[5]= (-3) <==> x =[5]= 9i =[5]= 4i
4x^{2} =[5]= (-4) <==> x =[5]= 16i =[5]= i


teorema:
Si ( p€P & p=3k+1 ) ==> ax^{3} =[p]= a <==> x =[p]= a^{(p+(-1))/3}
demostració:
(a^{(p+(-1)/3)})^{3} = a^{p+(-1)} =[p]= 1
a^{p} =[p]= a


2x^{3} =[7]= 2 <==> x =[7]= 4
3x^{3} =[7]= 3 <==> x =[7]= 9 =[7]= 2
4x^{3} =[7]= 4 <==> x =[7]= 16 =[7]= 2


teorema:
Si p€N ==> ...
...x^{2}+2bx =[p^{2}]= (-1)b^{2} <==> x =[p]= (-b)
demostració:
x^{2}+2bx =[p^{2}]= (-1)b^{2}
x^{2}+2bx+b^{2} =[p^{2}]= 0
(x+b)^{2} =[p^{2}]= 0
x+b =[p]= 0
x =[p]= (-b)


x^{2}+4x =[9]= (-4) <==> x =[3]= (-2) =[3]= 1
x^{2}+6x =[9]= (-9) <==> x =[3]= (-3) =[3]= 0
x^{2}+8x =[9]= (-16) <==> x =[3]= (-4) =[3]= (-1) =[3]= 2

problemes de números

s=1+(1/2)+...+(1/n)  ==> ¬( s€N ) or s=1


s = sum[k=1-->n]( (1·...·(k+(-1))(k+1)·...·n)/n! )
sigui m_{k}€N ==>
s = sum[k=1-->n]( m_{k} )=sum[k=1-->n]( (1·...·(k+(-1))(k+1)·...·n)/n! )
sum[k=1-->n]( m_{k} )n!=sum[k=1-->n]( (1·...·(k+(-1))(k+1)·...·n) )
m_{k}=(1/k)


s=1+(1/3)+...+(1/(2n+1))  ==> ¬( s€N ) or s=1


s = sum[k=1-->n]( (1·...·(2(k+(-1))+1)(2(k+1)+1)·...·(2n+1))/(2n+1)!! )
sigui m_{k}€N ==>
s = sum[k=1-->n]( m_{k} )=sum[k=1-->n]( (1·...·(2(k+(-1))+1)(2(k+1)+1)·...·(2n+1))/(2n+1)!! )
sum[k=1-->n]( m_{k} )(2n+1)!!=sum[k=1-->n]( (1·...·(2(k+(-1))+1)(2(k+1)+1)·...·(2n+1)) )
m_{k}=(1/(2k+1))


s=1+(1/2!)+...+(1/n!)  ==> ¬( s€N ) or s=1


s = sum[k=1-->n]( (1·...·(k+(-1))!(k+1)!)·...·n!)/(n!)! )
sigui m_{k}€N ==>
s = sum[k=1-->n]( m_{k} )=sum[k=1-->n]( (1·...·(k+(-1))!(k+1)!)·...·n!)/(n!)! )
sum[k=1-->n]( m_{k} )(n!)!=sum[k=1-->n]( (1·...·(k+(-1))!(k+1)!)·...·n!) )
m_{k}=(1/k!)


s=(p/n)+...(n)...+(p/n)==> s€N


s = ( (p+...(n)...+p)/n )
sigui m_{k}€N ==>
s = sum[k=1-->p]( m_{k} )=( ( p+...(n)...+p )/n )
( m_{1}+...(p)...+m_{p} )=(np/n)
( 1+...(p)...+1 )=p
m_{k}=1


s=(p/n^{q})+...(n)...+(p/n^{q})==> ¬( s€N ) or p=n^{q+(-1)}


s = ( (p+...(n)...+p)/n^{q} )
sigui m_{k}€N ==>
s = sum[k=1-->p]( m_{k} )=( ( p+...(n)...+p )/n^{q} )
( m_{1}+...(p)...+m_{p} )=(np/n^{q})
( 1/n^{q+(-1)}+...(p)...+1/n^{q+(-1)} )n^{q+(-1)}=p
m_{k}=(1/n^{q+(-1)})
( 1/n^{q+(-1)}+...(n^{q+(-1)})...+1/n^{q+(-1)} )n^{q+(-1)}=n^{q+(-1)}

ecuacions diferencials lineals

d_{tt}[ z( af(t) ) [o(t)o] f(t)^{[o(t)o](-1)}) ]=(-1)a^{2}·z( af(t) )d_{t}[f(t)]


d_{tt}[ sin( af(t) ) [o(t)o] f(t)^{[o(t)o](-1)}) ]=...
...d_{t}[ cos( af(t) )a ]=...
...(-1)a^{2}·sin( af(t) )d_{t}[f(t)]


d_{tt}[ z( at ) ]=(-1)a^{2}·z( at )






d_{tt}[ d_{t}[ z( af(t) ) [o(t)o] f(t)^{[o(t)o](-1)}) ] [o(t)o] f(t)^{[o(t)o](-1)}) ]=...
...(-1)a^{3}·z( af(t) )d_{t}[f(t)]


d_{tt}[ d_{t}[ red( af(t) ) [o(t)o] f(t)^{[o(t)o](-1)}) ] [o(t)o] f(t)^{[o(t)o](-1)}) ]=...
d_{tt}[ blue( af(t) )a [o(t)o] f(t)^{[o(t)o](-1)}) ]=...
...d_{t}[ yel( af(t) )a^{2} ]=...
...(-1)a^{3}·red( af(t) )d_{t}[f(t)]


d_{ttt}[ z( at ) ]=(-1)a^{3}·z( at )

camps electrics discrets

E(0,0,z)= k_{e}·int-int-int[rho[q]]d[x]d[y]d[ d_{t}[f(t)]z ]·(1/(cm)^{n})·<1,1,1>
on d_{t}[f(t)] es la resistencia del material.


circumferencia
E(0,0,z)= ...
...k_{e}·int-int[0-->2pi][rho[q]]d[sR]d[z]·(1/(cm)^{n})·<1,1,1>
E(0,0,z)= k_{e}(1/(cm)^{n})·rho[q]·2pi·R·z
m_{i}d_{tt}[z]=q_{i}·k_{e}(1/(cm)^{n})·rho[q]·2pi·R·z


disc cercle
E(0,0,z)= ...
...k_{e}·int-int[0-->2pi][rho[q]]d[(1/2)·s·R^{2}]d[ d_{t}[f(t)]z ]·...
...(1/(cm)^{n})·<1,1,1>
E(0,0,z)= k_{e}(1/(cm)^{n})·rho[q]·pi·R^{2}( d_{t}[f(t)]z )


esfera plena
E(0,0,z)= ...
...k_{e}·int-int[0-->4pi][rho[q]]d[(1/3)·s·R^{3}]d[ d_{t}[f(t)]z ]·...
...(1/(cm)^{n})·<1,1,1>
E(0,0,z)= k_{e}(1/(cm)^{n})·rho[q]·(4/3)·pi·R^{3}( d_{t}[f(t)]z )


esfera buida
E(0,0,z)= ...
...k_{e}·int-int[0-->4pi][rho[q]]d[s·R^{2}]d[ d_{t}[f(t)]z ]·...
...(1/(cm)^{n})·<1,1,1>
E(0,0,z)= k_{e}(1/(cm)^{n})·rho[q]·4pi·R^{2}( d_{t}[f(t)]z )


doble esfera plena per tall de porta
E(0,0,z)= ...
...k_{e}·int-int[0-->8pi][rho[q]]d[(1/3)·s·R^{3}]d[ d_{t}[f(t)]z ]·...
...(1/(cm)^{n})·<1,1,1>
E(0,0,z)= k_{e}(1/(cm)^{n})·rho[q]·(8/3)pi·R^{3}( d_{t}[f(t)]z )




doble esfera buida per tall de porta
E(0,0,z)= ...
...k_{e}·int-int[0-->8pi][rho[q]]d[R^{2}]d[ d_{t}[f(t)]z ]·...
...(1/(cm)^{n})·<1,1,1>
E(0,0,z)= k_{e}(1/(cm)^{n})·rho[q]·8pi·R^{2}( d_{t}[f(t)]z )


doble esfera:


1 1
2 2


2 2
1 1


doble esfera:


1 2
2 1


2 1
1 2


triple esfera plena per tall de porta
E(0,0,z)= ...
...k_{e}·int-int[0-->12pi][rho[q]]d[(1/3)·s·R^{3}]d[ d_{t}[f(t)]z ]·...
...(1/(cm)^{n})·<1,1,1>
E(0,0,z)= k_{e}(1/(cm)^{n})·rho[q]·4pi·R^{3}( d_{t}[f(t)]z )




triple esfera buida per tall de porta
E(0,0,z)= ...
...k_{e}·int-int[0-->12pi][rho[q]]d[R^{2}]d[ d_{t}[f(t)]z ]·...
...(1/(cm)^{n})·<1,1,1>
E(0,0,z)= k_{e}(1/(cm)^{n})·rho[q]·12pi·R^{2}( d_{t}[f(t)]z )


triple esfera:


1 2
3 1


2 3
1 2


3 1
2 3






quadruble esfera plena per doble tall de porta ortogonal
E(0,0,z)= ...
...k_{e}·int-int[0-->16pi][rho[q]]d[(1/3)·s·R^{3}]d[ d_{t}[f(t)]z ]·...
...(1/(cm)^{n})·<1,1,1>
E(0,0,z)= k_{e}(1/(cm)^{n})·rho[q]·(16/3)pi·R^{3}( d_{t}[f(t)]z )




quadruble esfera buida per doble tall de porta ortogonal
E(0,0,z)= ...
...k_{e}·int-int[0-->16pi][rho[q]]d[R^{2}]d[ d_{t}[f(t)]z ]·...
...(1/(cm)^{n})·<1,1,1>
E(0,0,z)= k_{e}(1/(cm)^{n})·rho[q]·16pi·R^{2}( d_{t}[f(t)]z )


cuadruble esfera:


1 2
3 4


4 3
2 1




2 4
1 3


3 1
4 2


a^{2}=(q_{i}/m_{i})·k_{e}(1/(cm)^{n})rho[q]·V


d_{tt}[ sinh(at^{(-p)}) [o(t)o] (1/(-p))(1/(p+2))t^{p+2} ]=...
...a^{2}( (-p)t^{(-p)+(-1)}sinh(at^{(-p)}) )


d_{tt}[ sinh( a·(bt^{2}+ct) ) [o(t)o] (1/(2b))·ln(2bt+c) ]=...
...a^{2}(2bt+c)sinh( a·(bt^{2}+ct) )

ones electro-magnétiques y gravito-magnétiques

E_{e}(r) = k_{e}q_{e}·( 1/r^{n} )
E_{g}(r) = (-1)·k_{g}q_{g}·( 1/r^{n} )


B_{e}(r) = (-1)·k_{e,m}q_{e}·( d_{t}[r]^{n}/r^{n} )
B_{g}(r) = k_{g,m}q_{g}·( d_{t}[r]^{n}/r^{n} )


divergencia y laplacià del camp eléctric y gravitatori:
d_{r}[ E_{e}(r) ] = (-n)·kq·(1/r^{n+1})
d_{rr}^{2}[ E_{e}(r) ] = (-n)((-n)+(-1))·kq·(1/r^{n+2})


d_{r}[ E_{g}(r) ] = (-1)·(-n)·kq·(1/r^{n+1})
d_{rr}^{2}[ E_{g}(r) ] = (-1)·(-n)((-n)+(-1))·kq·(1/r^{n+2})


divergencia y laplacià del camp magnétic:
d_{r}[ B_{e}(r) ] = (-1)·(-n)·kq·( d_{t}[r]^{n}/r^{n+1} )
d_{rr}^{2}[ B_{e}(r) ] = (-1)·(-n)((-n)+(-1))·kq·( d_{t}[r]^{n}/r^{n+2} )


d_{r}[ B_{g}(r) ] = (-n)·kq·( d_{t}[r]^{n}/r^{n+1} )
d_{rr}^{2}[ B_{g}(r) ] = (-n)((-n)+(-1))·kq·( d_{t}[r]^{n}/r^{n+2} )


ecuacions de camp del temps:
d_{t}[ d_{r}[ E_{e}(r) ] ] = d_{rr}^{2}[ E_{e}(r) ]·d_{t}[r]
d_{t}[ d_{r}[ B_{e}(r) ] ] = d_{rr}^{2}[ B_{e}(r) ]·d_{t}[r]


d_{t}[ d_{r}[ E_{g}(r) ] ] = d_{rr}^{2}[ E_{g}(r) ]·d_{t}[r]
d_{t}[ d_{r}[ B_{g}(r) ] ] = d_{rr}^{2}[ B_{g}(r) ]·d_{t}[r]


d_{t}[ d_{r}[ E_{e}(r)+B_{e}(r) ] ] = d_{rr}^{2}[ E_{e}(r)+B_{e}(r) ]·d_{t}[r]
d_{t}[ d_{r}[ E_{g}(r)+B_{g}(r) ] ] = d_{rr}^{2}[ E_{g}(r)+B_{g}(r) ]·d_{t}[r]


d_{tt}^{2}[r] = 0 <==> r(t)  = (k_{e}/k_{e,m})^{(1/n)}·t
d_{tt}^{2}[r] = 0 <==> r(t)  = (k_{g}/k_{g,m})^{(1/n)}·t


d_{t}[ d_{t}[ E_{e}(r)+B_{e}(r) ]·( 1/d_{t}[r] ) ] = d_{rr}^{2}[ E_{e}(r)+B_{e}(r) ]·d_{t}[r]


d_{tt}^{2}[ E_{e}(r)+B_{e}(r) ]·( 1/d_{t}[r] ) +...
... (-1)·d_{r}[ E_{e}(r)+B_{e}(r) ]·( d_{tt}^{2}[r]/d_{t}[r] ) =...
... d_{rr}^{2}[ E_{e}(r)+B_{e}(r) ]·d_{t}[r]


ecuacions de front de ones:
d_{tt}^{2}[ E_{e}(r)+B_{e}(r) ] = d_{rr}^{2}[ E_{e}(r)+B_{e}(r) ]·d_{t}[r]^{2}
d_{tt}^{2}[ E_{g}(r)+B_{g}(r) ] = d_{rr}^{2}[ E_{g}(r)+B_{g}(r) ]·d_{t}[r]^{2}