/* Interpolate a value between two energies on the grid */ double intepolateMatrixValue(size_t nerg, size_t nrea, double factor) { /* Get limits */ double low_value = getMatrixValue(nerg,nrea); double high_value = getMatrixValue(nerg + 1,nrea); /* Apply the interpolation factor */ return low_value + factor * (high_value - low_value); }
/* the output "m" is size of: * colum = t->order; * row = v->size */ void DvectorArrayDotProduct(array* t, dvector* v, matrix* m) { /*We do not need tests because getMatrixValue and setMatrixValue and getArrayValue handle some errors*/ size_t i, j, k; double res; /* m = v't * * k = order of array * j = column size * i = row size * * m[j][k] = Σ v[i] * t[k][i][j] * */ for(k = 0; k < t->order; k++){ for(i = 0; i < t->m[k]->row; i++){ for(j = 0; j < t->m[k]->col; j++){ if(v->size == t->m[k]->row && t->m[k]->col == m->row && t->order == m->col){ res = getDVectorValue(v, i) * getArrayValue(t, k, i, j); if(_isnan_(res) || _isinf_(res)){ setMatrixValue(m, j, k, (getMatrixValue(m, j, k) + 0)); } else{ setMatrixValue(m, j, k, (getMatrixValue(m, j, k) + res)); } } else{ fprintf(stderr, "Error while computing DvectorArrayDotProduct.\n"); fflush(stderr); abort(); } } } } }
//Lecture d'une matrice et transformation en arêtes. static void readMatrixAndCreateEdges(Matrix m){ // On crée un tableau contenant toutes les arêtes. ensemble = malloc(sizeof(Edge)*somme(getMatrixLength(m))); tailleEnsemble = somme(getMatrixLength(m)); int numCase = 0; Edge tmp; caseActuelleEnsemble = 0; for (int i=0; i<getMatrixLength(m); i++){ for (int j=i+1; j<getMatrixLength(m); j++){ ensemble[numCase] = createEdge(i, j, getMatrixValue(m, i, j)); if (numCase > 0){ // Si la case actuelle a un poids plus léger que la précédente if (ensemble[numCase]->weightEdge < ensemble[numCase-1]->weightEdge){ int n = numCase; // On la fait reculer tant qu'elle est plus légère que la case précédente, qui effectue un tri du tableau en le remplissant. while (n > 0 && ensemble[n]->weightEdge < ensemble[n-1]->weightEdge){ tmp = ensemble[n]; ensemble[n] = ensemble[n-1]; ensemble[n-1] = tmp; n--; } } } numCase++; } } //Affiche le tableau des arêtes de la matrice, trié. //for (int i=0; i<tailleEnsemble; i++){ // printEdgeValues(ensemble[i]); //} }
void ArrayMatrixDotProduct(array *t, matrix *m, dvector *v) { size_t i, j, k; double res; for(k = 0; k < t->order; k++){ if(m->col == t->order && m->row == t->m[k]->col){ for(i = 0; i < t->m[k]->row; i++){ for(j = 0; j < t->m[k]->col; j++){ res = (getArrayValue(t, k, i, j)*getMatrixValue(m, j, k)); if(_isnan_(res) || _isinf_(res)){ setDVectorValue(v, i, (getDVectorValue(v, i) + 0)); } else{ setDVectorValue(v, i, (getDVectorValue(v, i) + res)); } } } } else{ fprintf(stderr, "Error while computing ArrayMatrixDotProduct."); fflush(stderr); abort(); } } }
/* * k = order * i = row * j = column * * E'(j,i,k) = E(i,j,k) * * P(k,j) = Sum_i[ E'(j,i,k)*t(i) ] * */ void TransposedArrayDVectorProduct(array *t, dvector *v, matrix *p) { size_t i, j, k; double res; for(k = 0; k < t->order; k++){ for(i = 0; i < t->m[k]->row; i++){ for(j = 0; j < t->m[k]->col; j++){ res = getArrayValue(t, k, i, j)*getDVectorValue(v, j); if(_isnan_(res) || _isinf_(res)){ setMatrixValue(p, k, i, getMatrixValue(p, k, i) + 0); } else{ setMatrixValue(p, k, i, getMatrixValue(p, k, i) + res); } } } } }
/* * i = row * j = column * k = order * * t(i) = Sum_j[ Sum_k[ E(i,j,k) * P(k,j)] ] * */ void ArrayMatrixDotProduct2(array *t, matrix *m, dvector *v) { size_t i, j, k; for(i = 0; i < v->size; i++){ for(k = 0; k < t->order; k++){ for(j = 0; j < t->m[k]->col; j++){ setDVectorValue(v, i, getDVectorValue(v, i) + (getArrayValue(t, k, i, j)*getMatrixValue(m, k, j))); } } } }
void PrintArray(array *t) { size_t i, j, k; printf("Array - order: %u\n", (unsigned int)t->order); for(i = 0; i < t->order; i++){ printf("Array No: %u of row: %u; col: %u\n", (unsigned int)i+1, (unsigned int)t->m[i]->row, (unsigned int)t->m[i]->col); for(j = 0; j < t->m[i]->row; j++){ for(k = 0; k < t->m[i]->col; k++) printf("%8.3f\t", getMatrixValue(t->m[i], j, k)); printf("\n"); } } }
void KronekerProductVectorMatrix(dvector* v, matrix* m, array* t) { size_t i, j, k; double res; for(i = 0; i < v->size; i++){ for(j = 0; j < m->row; j++){ for(k = 0; k < m->col; k++){ res = getDVectorValue(v, i)*getMatrixValue(m, j, k); if(_isnan_(res) || _isinf_(res)){ setArrayValue(t, k, i, j, 0.f); } else{ setArrayValue(t, k, i, j, res); } } } } }
double getArrayValue(array *t, size_t i, size_t j, size_t k){ if(i < (*t).order){ if(j < (*t).m[i]->row){ if(k < (*t).m[i]->col){ return getMatrixValue((*t).m[i], j, k); } else{ fprintf(stderr, "getArrayValue Error! Wrong colum index.\n"); fflush(stderr); return NAN; } } else{ fprintf(stderr, "getArrayValue Error! Wrong row index.\n"); fflush(stderr); return NAN; } } else{ fprintf(stderr, "getArrayValue Error! Wrong order.\n"); fflush(stderr); return NAN; } }