int main (int argc, char ** argv){
unsigned int * V;
double timetick;
double limit = sqrt(CANTELEM)+1; //no puede haber divisores más grandes que limit
timetick = dwalltime();
int i,j;
if (NULL == (V = malloc(CANTELEM * sizeof(unsigned int)))){
printf("No hay memoria suficiente :(\n");
return -1;
}
for (i = 0; i < CANTELEM - 1; i++){V[i] = i;}
printf("Inicialización = %f\n", dwalltime() - timetick);
timetick = dwalltime();
for (i = 2; i < limit; i++){
for (j = 0; j < CANTELEM; j++){
if (V[j] != 0){
if ((V[j] % i) == 0){
V[j] = 0;
}
}
}
}
printf("Criba completa = %f\n", dwalltime() - timetick);
for (i = 0; i < CANTELEM; i++){
if (V[i] != 0){
//printf("%u es primo\n", V[i]);
}
}
return 0;
}
int main(int argc,char*argv[]){
double *A,*B,*C;
int i,j,k;
int check=1;
double timetick;
//Controla los argumentos al programa
if ((argc != 2) || ((N = atoi(argv[1])) <= 0) )
{
printf("\nUsar: %s n\n n: Dimension de la matriz (nxn X nxn)\n", argv[0]);
exit(1);
}
//Aloca memoria para las matrices
A=(double*)malloc(sizeof(double)*N*N);
B=(double*)malloc(sizeof(double)*N*N);
C=(double*)malloc(sizeof(double)*N*N);
//Inicializa las matrices A y B en 1, el resultado sera una matriz con todos sus valores en N
for(i=0;i<N;i++){
for(j=0;j<N;j++){
setValor(A,i,j,ORDENXFILAS,1);
setValor(B,i,j,ORDENXFILAS,1);
}
}
//Realiza la multiplicacion
timetick = dwalltime();
for(i=0;i<N;i++){
for(j=0;j<N;j++){
setValor(C,i,j,ORDENXFILAS,0);
for(k=0;k<N;k++){
setValor(C,i,j,ORDENXFILAS, getValor(C,i,j,ORDENXFILAS) + getValor(A,i,k,ORDENXFILAS)*getValor(B,k,j,ORDENXFILAS));
}
}
}
printf("Tiempo en segundos %f\n", dwalltime() - timetick);
//Verifica el resultado
for(i=0;i<N;i++){
for(j=0;j<N;j++){
check=check&&(getValor(C,i,j,ORDENXFILAS)==N);
}
}
if(check){
printf("Multiplicacion de matrices resultado correcto\n");
}else{
printf("Multiplicacion de matrices resultado erroneo\n");
}
free(A);
free(B);
free(C);
return(0);
}
main(int argc, char *argv[])
{
float *A, *B, *C;
int n, i, j, k;
double timetick;
/* Chequeando parametros */
if ((argc != 2) || ((n = atoi(argv[1])) <= 0) )
{
printf("Uso: %s n\n donde n: dimension de la matriz cuadrada (nxn X nxn)\n", argv[0]);
exit(1);
}
// Inicializando Matrices
A = (float *) malloc(n*n*sizeof(float));
B = (float *) malloc(n*n*sizeof(float));
C = (float *) malloc(n*n*sizeof(float));
initvalmat(A, n, 1.0);
initvalmat(B, n, 1.0);
initvalmat(C, n, 0.0);
printf("Multiplicando matrices de %d x %d \n", n, n);
timetick = dwalltime();
/*************************************************************/
/* Programar aqui el algoritmo de multiplicacion de matrices */
/*************************************************************/
for (i = 0; i < n; ++i)
{
for (j = 0; j < n; ++j)
{
for (k = 0; k < n; ++k)
{
C[i*n + j] += A[i*n + k] * B[k*n + j];
}
}
}
/*************************************************************/
timetick = dwalltime() - timetick;
verify_result(C, n);
printf("Resultado correcto. Tiempo de ejecucion: %f segundos\n", timetick);
}
int main (int argc, char *argv[]){
double *A; // Matriz A
double *B; // Matriz B
double *C; // Matriz C
double timetick;
//El tamano de la matriz sera n= N*r , donde N y r se reciben
//por parametro se tendran N*N bloques de r*r cada uno
if (argc < 4){
printf("\n Falta un parametro ");
printf("\n 1. Cantidad de bloques por dimension ");
printf("\n 2. Dimension de cada bloque ");
printf("\n 3. 0/1 para imprimir/no imprimir resultados ");
return 0;
}
int N = atoi(argv[1]);
int r = atoi(argv[2]);
int imprimir=atoi(argv[3]);
int n = N*r; //dimension de la matriz
int sizeMatrix=n*n; //cantidad total de datos matriz
int sizeBlock=r*r; //cantidad total de datos del bloque
int i;
A= (double *)malloc(sizeMatrix*sizeof(double)); //aloca memoria para A
B= (double *)malloc(sizeMatrix*sizeof(double)); //aloca memoria para B
C= (double *)malloc(sizeMatrix*sizeof(double)); //aloca memoria para C
crearMatriz(A, sizeMatrix); //Inicializa A
crearIdentidad(B,sizeBlock,sizeMatrix,N,r); //Inicializa B como matriz identidad
timetick = dwalltime();
producto(A,B,C,r,N,sizeMatrix,sizeBlock);
printf("Tiempo en segundos %f \n", dwalltime() - timetick);
//tiempo
if (imprimir ==1){
printf("\n\n A (como esta almacenada): \n" );
imprimeVector(A, sizeMatrix);
printf("\n\n B (como esta almacenada): \n" );
imprimeVector(B,sizeMatrix);
printf("\n\n A: \n" );
imprimeMatriz(A,N,r);
printf(" \n\n B: \n" );
imprimeMatriz(B,N,r);
printf("\n\n C: \n" );
imprimeMatriz(C,N,r);
}
printf(" \n\n Realizando comprobacion ... \n" );
for (i=0;i<sizeMatrix ;i++ )
{
if (A[i]!=C[i])
{
printf("\n Error %f", C[i] );
}
}
//imprimir tiempo
free(A);
free(B);
free(C);
return 0;
} //FIN MAIN
int main(int argc,char*argv[]){
double *A,*B,*C,*D,*E;
int i,j,k,N;
int check=1;
double timetick;
//Controla los argumentos al programa
if (argc < 3){
printf("\n Faltan argumentos:: N dimension de la matriz, T cantidad de threads \n");
return 0;
}
N=atoi(argv[1]);
int numThreads = atoi(argv[2]);
omp_set_num_threads(numThreads);
//Aloca memoria para las matrices
A=(double*)malloc(sizeof(double)*N*N);
B=(double*)malloc(sizeof(double)*N*N);
C=(double*)malloc(sizeof(double)*N*N);
D=(double*)malloc(sizeof(double)*N*N);
E=(double*)malloc(sizeof(double)*N*N);
//Inicializa las matrices A, B,C en 1
for(i=0;i<N;i++){
for(j=0;j<N;j++){
A[i*N+j]=1;
B[i+j*N]=1;
C[i*N+j]=1;
}
}
timetick = dwalltime();
//Realiza la multiplicacion D= AxB
for(i=0;i<N;i++){
for(j=0;j<N;j++){
D[i*N+j]=0;
for(k=0;k<N;k++){
D[i*N+j]= D[i*N+j] + A[i*N+k]*B[k+j*N];
}
}
}
//Realiza la multiplicacion E= CxB
for(i=0;i<N;i++){
for(j=0;j<N;j++){
E[i*N+j]=0;
for(k=0;k<N;k++){
E[i*N+j]= E[i*N+j] + C[i*N+k]*B[k+j*N];
}
}
}
printf("Tiempo en segundos %f \n", dwalltime() - timetick);
//Verifica el resultado
for(i=0;i<N;i++){
for(j=0;j<N;j++){
check=check&&(D[i*N+j]==N)&&(E[i*N+j]==N);
}
}
if(check){
printf("Multiplicacion de matrices resultado correcto\n");
}else{
printf("Multiplicacion de matrices resultado erroneo\n");
}
free(A);
free(B);
free(C);
free(D);
free(E);
return(0);
}
int main(int argc,char*argv[]){
double *A,*B,*C ,*D,*ab,*cd, *tot;
int i,j,k,N;
int check=1;
double timetick;
//Controla los argumentos al programa
if (argc < 2){
printf("\n Falta un argumento:: N dimension de la matriz \n");
return 0;
}
N=atoi(argv[1]);
//Aloca memoria para las matrices
A=(double*)malloc(sizeof(double)*N*N);
B=(double*)malloc(sizeof(double)*N*N);
C=(double*)malloc(sizeof(double)*N*N);
D=(double*)malloc(sizeof(double)*N*N);
ab=(double*)malloc(sizeof(double)*N*N);
cd=(double*)malloc(sizeof(double)*N*N);
tot=(double*)malloc(sizeof(double)*N*N);
//Inicializa las matrices A y B en 1, el resultado sera una matriz con todos sus valores en N
for(i=0;i<N;i++){
for(j=0;j<N;j++){
A[i*N+j]=1;
B[i+j*N]=1;
C[i*N+j]=1;
D[i+j*N]=1;
}
}
timetick = dwalltime();
//Realiza la multiplicacion
for(i=0;i<N;i++){
for(j=0;j<N;j++){
ab[i*N+j]=0;
for(k=0;k<N;k++){
ab[i*N+j]= ab[i*N+j] + A[i*N+k]*B[k+j*N];
cd[i*N+j]= cd[i*N+j] + C[i*N+k]*D[k+j*N];
tot[i*N+j]= cd[i*N+j]+ ab[i*N+j];
}
}
}
printf("Tiempo en segundos %f \n", dwalltime() - timetick);
//Verifica el resultado
for(i=0;i<N;i++){
for(j=0;j<N;j++){
check=check&&(tot[i*N+j]==N*2);
}
}
if(check){
printf("Multiplicacion de matrices resultado correcto\n");
}else{
printf("Multiplicacion de matrices resultado erroneo\n");
}
free(A);
free(B);
free(C);
free(D);
free(ab);
free(cd);
free(tot);
return(0);
}
int main(int argc,char*argv[]) {
omp_set_num_threads(numThreads);
double *A,*B,*B2,*C,*D,*r1,*r2, *aux, *C2;
int i,j,k;
double timetick;
int check=1;
int param[numThreads];
if ((argc != 2) || ((N = atoi(argv[1])) <= 0) )
{
printf("\nUsar: %s n\n n: Dimension de la matriz (nxn X nxn)\n", argv[0]);
exit(1);
}
//Aloca memoria para las matrices
A=(double*)malloc(sizeof(double)*N*N);
B=(double*)malloc(sizeof(double)*N*N);
C=(double*)malloc(sizeof(double)*N*N);
B2=(double*)malloc(sizeof(double)*N*N);
D=(double*)malloc(sizeof(double)*N);
r1=(double*)malloc(sizeof(double)*2);
r2=(double*)malloc(sizeof(double)*2);
/*
A=(double*)malloc(sizeof(double)*9);
B=(double*)malloc(sizeof(double)*9);
C=(double*)malloc(sizeof(double)*9);
B2=(double*)malloc(sizeof(double)*9);
D=(double*)malloc(sizeof(double)*3);
*/
//Inicializa las matrices A y B en 1, el resultado sera una matriz con todos sus valores en N
// private(j) ?
#pragma omp parallel for shared (A,B,D)
for(i=0;i<N;i++){
for(j=0;j<N;j++){
A[i*N+j]=1;
B[i+j*N]=1;
}
D[i]=1;
}
/*Inicializa matrices con los valores de prueba
A[0]=1;
A[1]=2;
A[2]=6;
A[3]=5;
A[4]=9;
A[5]=3;
A[6]=4;
A[7]=8;
A[8]=7;
B[0]=3;
B[1]=3;
B[2]=1;
B[3]=2;
B[4]=5;
B[5]=7;
B[6]=1;
B[7]=3;
B[8]=2;
D[0]=4;
D[1]=2;
D[2]=3;
*/
//Punto A
timetick = dwalltime();
#pragma omp parallel for private(j,k) shared (A,B,B2,N)
for(i=0;i<N;i++){
for(j=0;j<N;j++){
B2[i*N+j]=0;
for(k=0;k<N;k++){
B2[i*N+j]=(B2[i*N+j] + A[i*N+k]*B[k+j*N]);
}
}
}
#pragma omp parallel for private(j) shared (C,B2,D,N)
for(i=0;i<N;i++){
for(j=0;j<N;j++){
C[i*N+j]=(B2[i*N+j]*D[j]);
}
}
free(B2);
/*VERIFICACION
printf("\n");
printf("Matriz resultante del punto A:\n");
printf(" %f",C[0]);printf(" %f",C[1]);printf(" %f\n",C[2]);
printf(" %f",C[3]);printf(" %f",C[4]);printf(" %f\n",C[5]);
printf(" %f",C[6]);printf(" %f",C[7]);printf(" %f\n",C[8]);
*/
//Punto B
double result;
int l;
getValues(A,r1);
getValues(B,r2);
result=((r1[0]*r1[0])/r1[1])*((r2[0]*r2[0])/r2[1]);
#pragma omp parallel for shared(C)
for(l=0;l<(N*N);l++) {
C[l]=C[l]*result;
}
/*VERIFICACION
printf("\n");
printf("Matriz resultante del punto B:\n");
printf(" %f",C[0]);printf(" %f",C[1]);printf(" %f\n",C[2]);
printf(" %f",C[3]);printf(" %f",C[4]);printf(" %f\n",C[5]);
printf(" %f",C[6]);printf(" %f",C[7]);printf(" %f\n",C[8]);
*/
free(r1);
free(r2);
//Punto C
C2=(double*)malloc(sizeof(double)*N*N);
column=(struct celda*)malloc((sizeof(double)+sizeof(double))*N);
merge=(struct celda*)malloc((sizeof(double)+sizeof(double))*N);
for(i=0;i<N;i++) {
#pragma omp parallel for shared (valor,column)
for(k=0;k<N;k++) {
valor.pos=k;
valor.value=C[i+N*k];
column[k]=valor;
}
#pragma omp parallel for
for(k=0; k<numThreads; k++){
//param[k]=k;
sort( k );
}
#pragma omp parallel for
for(k=0; k<2; k++){
initial_merge(k);
}
j=0;
k=N/2;
l=0;
while(j<N/2 && k<N) {
if (column[j].value<=column[k].value){
merge[l]=column[j];
j++;
}else{
merge[l]=column[k];
k++;
}
l++;
}
while(j<N/2) {
merge[l]=column[j];
j++;
l++;
}
while(k<N) {
merge[l]=column[k];
k++;
l++;
}
#pragma omp parallel for private(k) shared (valor,N,i,C2,C)
for(j=0;j<N;j++){
valor=column[j];
for(k=0;k<N-i;k++){
C2[(j*N)+k]=C[((int)valor.pos*N)+i+k];
}
}
#pragma omp parallel for private(k) shared (N,i,C2,C)
for(j=0;j<N;j++){
for(k=0;k<N-i;k++){
C[(j*N)+k+i]=C2[(j*N)+k];
}
}
}
free(C2);
/*VERIFICACION
printf("\n");
printf("Matriz resultante del punto C:\n");
printf(" %f",C[0]);printf(" %f",C[1]);printf(" %f\n",C[2]);
printf(" %f",C[3]);printf(" %f",C[4]);printf(" %f\n",C[5]);
printf(" %f",C[6]);printf(" %f",C[7]);printf(" %f\n",C[8]);
*/
printf("Tiempo en segundos %f\n", dwalltime() - timetick);
free(A);
free(B);
free(C);
free(D);
return 0;
}
int main(int argc,char*argv[]){
double *A,*B,*C;
int i,j,k,N;
int check=1;
double timetick;
//Controla los argumentos al programa
if (argc < 3){
printf("\n Faltan argumentos:: N dimension de la matriz, T cantidad de threads \n");
return 0;
}
N=atoi(argv[1]);
int numThreads=atoi(argv[2]);
omp_set_num_threads(numThreads);
//Aloca memoria para las matrices
A=(double*)malloc(sizeof(double)*N*N);
B=(double*)malloc(sizeof(double)*N*N);
C=(double*)malloc(sizeof(double)*N*N);
//Inicializa las matrices A y B en 1, el resultado sera una matriz con todos sus valores en N
for(i=0;i<N;i++){
for(j=0;j<N;j++){
A[i*N+j]=1;
B[i+j*N]=1;
}
}
timetick = dwalltime();
//Realiza la multiplicacion
int tmp;
#pragma omp parallel for default(shared) private(i,j,tmp)
for(i=0;i<N;i++){
for(j=0;j<N;j++){
tmp=0;
for(k=0;k<N;k++){
tmp += A[i*N+k]*B[k+j*N];
}
C[i*N+j]=tmp;
}
}
printf("Tiempo en segundos %f \n", dwalltime() - timetick);
//Verifica el resultado
for(i=0;i<N;i++){
for(j=0;j<N;j++){
check=check&&(C[i*N+j]==N);
}
}
if(check){
printf("Multiplicacion de matrices resultado correcto\n");
}else{
printf("Multiplicacion de matrices resultado erroneo\n");
}
free(A);
free(B);
free(C);
return(0);
}
int main(int argc,char*argv[]){
int i,in,j,k;
int check=1;
double timetick;
//Controla los argumentos al programa
if ((argc != 2) || ((N = atoi(argv[1])) <= 0) )
{
printf("\nUsar: %s n\n n: Dimension de la matriz (nxn X nxn)\n", argv[0]);
exit(1);
}
//Aloca memoria para las matrices
A=(double*)malloc(sizeof(double)*N*N);
B=(double*)malloc(sizeof(double)*N*N);
C=(double*)malloc(sizeof(double)*N*N);
for(i=0;i<N;i++){
in=i*N;
for(j=0;j<N;j++){
A[in+j] = 1;
B[in+j] = 1;
}
}
// Defino los thread
pthread_t thread[N_THREADS];
struct thread_data data[N_THREADS];
pthread_attr_t attr;
int rc;
jobs_thread=N/N_THREADS;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
timetick = dwalltime();
for(i=0; i<N_THREADS; i++)
{
data[i].tid=i;
rc = pthread_create(&thread[i], &attr, t_average, (void *) &data[i]);
if (rc){
printf("ERROR; return code from pthread_create() is %d\n", rc);
exit(-1);
}
}
double a,b = 0;
for(i=0; i<N_THREADS; i++)
{
pthread_join(thread[i], NULL);
a += data[i].result_a;
b += data[i].result_b;
}
average = (a/(N*N))*(b/(N*N));
for(i=0; i<N_THREADS; i++)
{
rc = pthread_create(&thread[i], &attr, prod_matrix, (void *)&data[i]);
if (rc){
printf("ERROR; return code from pthread_create() is %d\n", rc);
exit(-1);
}
}
for(i=0; i<N_THREADS; i++)
{
pthread_join(thread[i], NULL);
}
//printf("Tiempo en segundos %f\n", dwalltime() - timetick);
//Verifica el resultado
for(i=0;i<N;i++){
in=i*N;
for(j=0;j<N;j++){
//check=check&&(getValor(C,i,j,ORDENXFILAS)==N);
check=check&&(C[in+j]==N);
}
}
if(check){
printf("%f\n",dwalltime() - timetick);
// printf("Multiplicacion de matrices resultado correcto\n");
}else{
printf("Multiplicacion de matrices resultado erroneo\n");
}
free(A);
free(B);
free(C);
pthread_exit(NULL);
return(0);
}
int main(int argc,char*argv[]) {
double *A;
double temp;
int i,j, N;
int check=1;
double timetick;
//Controla los argumentos al programa
if (argc < 2) {
printf("\n Faltan argumentos:: N dimension de la matriz \n");
return 0;
}
N=atoi(argv[1]);
//Aloca memoria para las matrices
A=(double*)malloc(sizeof(double)*N*N);
//Inicializa la matriz con unos en el triangulo inferior y ceros en el triangulo superior.
for(i=0; i<N; i++) {
for(j=0; j<N; j++) {
if (i>=j)
{
A[i*N+j]= 1.0;
}
else
{
A[i*N+j]= 0.0;
}
}
}
timetick = dwalltime();
for(i=0; i<N; i++) {
for(j=i+1; j<N; j++) {
temp = A[i*N+j];
A[i*N+j]= A[j*N+i];
A[j*N+i]= temp;
}
}
printf("Tiempo en segundos: %f \n", dwalltime() - timetick);
//Chequea los resultados
for(i=0; i<N; i++) {
for(j=0; j<N; j++) {
if (i>j)
{
check= check&&(A[i*N+j]==0.0);
}
else
{
check= check&&(A[i*N+j]== 1.0);
}
}
}
if(check) {
printf("Resultado correcto\n");
} else {
printf("Resultado erroneo\n");
}
free(A);
return(0);
}
