float
CRebuildGraph::compareMatrix(gsl_matrix* matrixA, gsl_matrix*matrixB){
float delta;
gsl_vector *work ,*s;
if (matrixA->size1 != matrixB->size1)
throw runtime_error(" size 1 and size 2 are different");
gsl_matrix *U1, *U2,*V1,*V2;
InitMatrix((int)matrixA->size1,&work,&s,&U1,&U2,&V1,&V2);
gsl_matrix_memcpy (U1, matrixA);
//gsl_linalg_SV_decomp (gsl_matrix * A, gsl_matrix * V, gsl_vector * S, gsl_vector * work)
//La matriu A es substitueix per U a la sortida
gsl_linalg_SV_decomp(U1,V1,s,work);
gsl_matrix_memcpy (U2, matrixB);
gsl_linalg_SV_decomp(U2,V2,s,work);
//F = U1 VS2 V1^T = U1 U2^T A2 V2 V1^T
gsl_matrix *F=gsl_matrix_alloc(matrixA->size1,matrixA->size1);
gsl_matrix_transpose(U2);
multiplica(F,U1,U2);
multiplica(F,F,matrixB);
multiplica(F,F,V2);
gsl_matrix_transpose(V1);
multiplica(F,F,V1);
//F ja esta calculada. Calculem la norma.
delta=0;
for(int i=0; i<matrixA->size1; i++){
for(int j=0; j<matrixA->size1; j++){
delta+=pow(gsl_matrix_get(matrixA,i,j)-gsl_matrix_get(F,i,j),2);
}
}
delta=std::pow(delta,0.5f);
delta/=matrixA->size1;
printingCompareMatrixResults(delta,F,matrixA);
FreeMatrix(&work,
&s,
&U1,
&U2,
&V1,
&V2,
&F );
return delta;
}
void main (void)
{
int p, x, y, j, k;
x = 1;
y = 2;
p = multiplica (x, y);
printf ("%d \n", p);
j = 234;
k = 10;
p = multiplica (j, k);
printf ("%d \n", p);
}
int main(int argc, char const *argv[])
{
char sel;
int v1[ELEMENTOS]={1,3,5,7,9};
int v2[ELEMENTOS]={0,2,4,6,8};
while (1){
printf("Seleccione operación\n");
printf("s: suma, r: resta, m: multiplicación, d: división, x: salir\n");
printf("Selección: ");
sel= getchar();
switch (sel){
case 's':
suma(v1, v2);
break;
case 'r':
resta(v1, v2);
break;
case 'm':
multiplica(v1,v2);
break;
case 'd':
divide(v1, v2);
break;
case 'x':
exit(0);
default:
printf("Selección inválida.\n");
}
}
return 0;
}
int main()
{
int j,k;
k = 3 ;
j = 2 ;
k = multiplica(k,j) ;
printf(k);
return 0;
}
int main( int argc, char *argv[ ] ){
//variaveis de tempo
struct timeb start, stop;
double elapsed;
int i;
if (argc > 1 ) {
dimensao = atoi(argv[1]);
}
else {
printf("\nQual a dimensao N (NxN) de suas matrizes?\n");
scanf("%i",&dimensao);
}
//Cria matrizes
if (dimensao<=0 ) return -1;
matrizA = (int **)malloc(dimensao*sizeof(int *));
matrizB = (int **)malloc(dimensao*sizeof(int *));
matrizResultado = (int **)malloc(dimensao*sizeof(int *));
for (i=0;i<dimensao;i++) matrizA[i] = (int *)malloc(dimensao*sizeof(int));
for (i=0;i<dimensao;i++) matrizB[i] = (int *)malloc(dimensao*sizeof(int));
for (i=0;i<dimensao;i++) matrizResultado[i] = (int *)malloc(dimensao*sizeof(int));
//PREENCHE MATRIZ
preenche(matrizA,time(NULL));
preenche(matrizB,time(NULL)+1);
//THREADS CALCULAM A MULTIPLICACAO
ftime(&start); //inicia timer
multiplica(matrizA,matrizB);
ftime(&stop); //para timer
elapsed=((double) stop.time + ((double) stop.millitm * 0.001)) - ((double) start.time + ((double) start.millitm * 0.001));
//IMPRIME
printf ("\nMatriz A:");
imprime(matrizA);
printf ("\nMatriz B:");
imprime(matrizB);
printf ("\n-Resultado:");
imprime(matrizResultado);
//gera link
gerasite(matrizA,matrizB);
printf("\n[1 arquivo e Subprocessos =%i] Matrizes = %i x %i -> O tempo de execucao e de %.3lf\n",dimensao, dimensao, dimensao,elapsed);
//exit(0);
return 0;
}
int main(){
int n1, n2, m;
printf("informe 2 numero\n");
scanf ("%d%d",&n1, &n2);
m = multiplica(n1, n2);
printf("O resultado da multiplicacao eh:%d\n",m);
return 0;
}
int main(void)
{
float a = 5.0;
float b = 2.0;
float resultado = multiplica(a, b);
// a virgula utilizada para separar a variável do valor é util para gerar dataframes
printf("a,%f \n",a );
printf("b,%f \n",b );
printf("a*b,%f \n",resultado );
return 0;
}
int main (){
int a;
printf("Digite a opção desejada:\n\n");
printf("1. Somar dois números\n");
printf("2. Subtrair dois números\n");
printf("3. Multiplicar dois números\n");
printf("4. Dividir dois números\n");
printf("5. Raiz quadrada de um número\n\n");
scanf("%d", &a);
switch (a){
case 1: soma(); break;
case 2: subtrai(); break;
case 3: multiplica(); break;
case 4: divide(); break;
case 5: raiz(); break;
default: printf("Você NÃO digitou uma opção válida!\n\n"); break;
}
return (0);
}
int main(int argc, const char **argv) {
int matriz_a[FIL_A][COMUN],
matriz_b[COMUN][COL_B],
matriz_prod[FIL_A][COL_B];
system("clear");
rellenar((int *)matriz_a, FIL_A, COMUN, "primera: A");
imprimir((int *)matriz_a, FIL_A, COMUN, "A");
rellenar((int *)matriz_b, COMUN, COL_B, "segunda: B");
imprimir((int *)matriz_b, COMUN, COL_B, "B");
multiplica((int *) matriz_a, (int *) matriz_b, (int *) matriz_prod, FIL_A, COL_B, COMUN);
imprimir((int *)matriz_prod, FIL_A, COL_B, "P");
return EXIT_SUCCESS;
}
/* DESENHA O CARRO ANDANDO SOBRE A CURVA */
void CanvasPista::startAutorama(void) {
int iFinal = pontosDeControle.size() - 3; // posicao do ultimo segmento de curva
if (tempo > 1.0) // Passa para o proximo segmento de curva
{
tempo = 0;
posicaoAtual += 3;
if (posicaoAtual >= iFinal)
{
posicaoAtual = 0;
}
}
if ((iFinal - posicaoAtual) <= 3) // Se nao formar mais dois segmentos, o ultimo segmento sera maior
{
subPontosDeControle2 = std::vector<Ponto>(&pontosDeControle[posicaoAtual], &pontosDeControle[pontosDeControle.size()]);
first = true;
}
else // Forma os segmentos de curvas cubicas
{
subPontosDeControle2 = std::vector<Ponto>(&pontosDeControle[posicaoAtual], &pontosDeControle[posicaoAtual + 3 + 1]);
first = true;
}
// Calcula o bezier e a tangente
Ponto pontoBezier = bezier(subPontosDeControle2, tempo);
Ponto tangente = derivadaBezier(subPontosDeControle2, tempo);
float angulo = (float)(atan((float)tangente.y / (float)tangente.x) * 180) / 3.14;
// Define as posicoes iniciais do carro
Ponto inferiorEsquerdo(pontoBezier.x - 10, pontoBezier.y - 4);
Ponto inferiorDireito(pontoBezier.x + 10, pontoBezier.y - 4);
Ponto superiorEsquerdo(pontoBezier.x - 10, pontoBezier.y + 4);
Ponto superiorDireito(pontoBezier.x + 10, pontoBezier.y + 4);
// Realiza as transformacoes 2D (ordem inversa)
Matriz matriz; // Cria matriz de transformacao
matriz.translada(pontoBezier.x, pontoBezier.y); // Translada para o ponto de bezier
matriz.rotacao(angulo); // Faz a rotacao
matriz.translada(-pontoBezier.x, -pontoBezier.y); // Translada para a origem
// Novos pontos do carro
Ponto novoInferiorEsquerdo = multiplica(matriz.matriz, inferiorEsquerdo);
Ponto novoInferiorDireito = multiplica(matriz.matriz, inferiorDireito);
Ponto novoSuperiorEsquerdo = multiplica(matriz.matriz, superiorEsquerdo);
Ponto novoSuperiorDireito = multiplica(matriz.matriz, superiorDireito);
// Desenha o carro apos as transformacoes
color(1, 0, 0);
circleFillf(pontoBezier.x, pontoBezier.y, 4, 20);
linef(novoInferiorEsquerdo.x, novoInferiorEsquerdo.y, novoInferiorDireito.x, novoInferiorDireito.y);
linef(novoInferiorEsquerdo.x, novoInferiorEsquerdo.y, novoSuperiorEsquerdo.x, novoSuperiorEsquerdo.y);
linef(novoInferiorDireito.x, novoInferiorDireito.y, novoSuperiorDireito.x, novoSuperiorDireito.y);
linef(novoSuperiorEsquerdo.x, novoSuperiorEsquerdo.y, novoSuperiorDireito.x, novoSuperiorDireito.y);
// Ajusta a velocidade do carro:
setSpeed();
tempo += 0.001*speed;
if (buttonViewControlGraphs == true) // Se viewControlGraphs == true, mostra vetor de direcao do carro
{
color(0, 0, 1);
float moduloTangente = sqrt(pow(tangente.x, 2) + pow(tangente.y, 2));
tangente.x = (tangente.x / moduloTangente);
tangente.y = (tangente.y / moduloTangente);
linef(pontoBezier.x, pontoBezier.y, pontoBezier.x + tangente.x * 40, pontoBezier.y + tangente.y * 40);
/*Ponto inferiorEsquerdo(pontoBezier.x - 5, pontoBezier.y - 5);
Ponto inferiorDireito(pontoBezier.x + 5, pontoBezier.y - 5);
Ponto superiorEsquerdo(pontoBezier.x - 5, pontoBezier.y + 5);
Ponto superiorDireito(pontoBezier.x + 5, pontoBezier.y + 5);
if (angulo < 0)
{
angulo = angulo*(-1);
std::cout << angulo << std::endl;
}
// Realiza as transformacoes 2D (ordem inversa)
Matriz matriz; // Cria matriz de transformacao
matriz.translada(pontoBezier.x + tangente.x * 40, pontoBezier.y + tangente.y * 40); // Translada para o ponto de bezier
matriz.rotacao( 45); // Faz a rotacao
matriz.translada(-pontoBezier.x, -pontoBezier.y); // Translada para a origem
// Novos pontos do carro
Ponto novoInferiorEsquerdo = multiplica(matriz.matriz, inferiorEsquerdo);
Ponto novoInferiorDireito = multiplica(matriz.matriz, inferiorDireito);
Ponto novoSuperiorEsquerdo = multiplica(matriz.matriz, superiorEsquerdo);
Ponto novoSuperiorDireito = multiplica(matriz.matriz, superiorDireito);
color(1, 0, 0);
circleFillf(pontoBezier.x, pontoBezier.y, 4, 20);
//linef(novoInferiorEsquerdo.x, novoInferiorEsquerdo.y, novoInferiorDireito.x, novoInferiorDireito.y);
linef(novoInferiorEsquerdo.x, novoInferiorEsquerdo.y, novoSuperiorEsquerdo.x, novoSuperiorEsquerdo.y);
//linef(novoInferiorDireito.x, novoInferiorDireito.y, novoSuperiorDireito.x, novoSuperiorDireito.y);
linef(novoSuperiorEsquerdo.x, novoSuperiorEsquerdo.y, novoSuperiorDireito.x, novoSuperiorDireito.y);*/
}
}
int main()
{
multiplica();
return 0;
}
int main()
{
char acao;
num_matriz k, k1, k2, k3;
int m, n, i, j;
float x;
matriz a[num_nomes];
while (true)
{
scanf("%c", &acao);
printf("ação: %c", acao);
switch (acao)
{
case 'r':
le_nome(&k); prox_linha();
printf(" %c\n", min_nome+k);
le_matriz(&a[k]);
break;
case 'z':
le_nome(&k); scanf("%d %d", &m, &n); prox_linha();
printf(" %c %d %d\n", min_nome+k, m, n);
inicializa(&a[k], m, n);
break;
case 'v':
le_nome(&k); scanf("%d %d", &i, &j); prox_linha();
printf(" %c %d %d\n", min_nome+k, i, j);
printf(" %c[%d,%d] = %8.2f\n", min_nome+k, i, j, valor(&(a[k]), i, j));
break;
case 'a':
le_nome(&k); scanf("%d %d %f", &i, &j, &x); prox_linha();
printf(" %c %2d %2d %8.2f\n", min_nome+k, i, j, x);
atribui(&a[k], i, j, x);
break;
case 's':
le_nome(&k1); le_nome(&k2); le_nome(&k3); prox_linha();
printf(" %c %c %c\n", min_nome+k1, min_nome+k2, min_nome+k3);
soma(&a[k1], &a[k2], &a[k3]);
break;
case 'm':
le_nome(&k1); le_nome(&k2); le_nome(&k3); prox_linha();
printf(" %c %c %c\n", min_nome+k1, min_nome+k2, min_nome+k3);
multiplica(&a[k1], &a[k2], &a[k3]);
break;
case 't':
le_nome(&k1); le_nome(&k2); prox_linha();
printf(" %c %c\n", min_nome+k1, min_nome+k2);
transpoe(&a[k1], &a[k2]);
break;
case 'w':
le_nome(&k); prox_linha();
printf(" %c\n", min_nome+k);
imprime_matriz(&a[k]);
break;
case 'x':
printf("\n");
bapply(bprint);
printf("fim da execução.\n");
exit(0);
break;
case '#':
{ int c;
do
{ c = getchar(); putchar(c); }
while ((c != '\n') && (c != EOF));
}
break;
case 'l':
le_nome(&k); prox_linha();
printf(" %c\n", min_nome+k);
libera(&a[k]);
break;
default:
{ erro("ação inválida"); }
} /* switch */
} /* while */
bapply(bprint);
return 0;
} /* main */
