returnValue VariablesGrid::appendTimes( const VariablesGrid& arg,
MergeMethod _mergeMethod
)
{
// nothing to do for empty grids
if ( arg.getNumPoints( ) == 0 )
return SUCCESSFUL_RETURN;
if ( getNumPoints( ) == 0 )
{
*this = arg;
return SUCCESSFUL_RETURN;
}
// consistency check
if ( acadoIsGreater( arg.getFirstTime( ),getLastTime( ) ) == BT_FALSE )
return ACADOERROR( RET_INVALID_ARGUMENTS );
if ( acadoIsEqual( getLastTime( ),arg.getFirstTime( ) ) == BT_FALSE )
{
// simply append
for( uint i=0; i<arg.getNumPoints( ); ++i )
addMatrix( *(arg.values[i]),arg.getTime( i ) );
}
else
{
// if last and first time point coincide, merge as specified
switch ( _mergeMethod )
{
case MM_KEEP:
break;
case MM_REPLACE:
setVector( getLastIndex(),arg.getFirstVector( ) );
break;
case MM_DUPLICATE:
addMatrix( *(arg.values[0]),arg.getTime( 0 ) );
break;
}
// simply append all remaining points
for( uint i=1; i<arg.getNumPoints( ); ++i )
addMatrix( *(arg.values[i]),arg.getTime( i ) );
}
return SUCCESSFUL_RETURN;
}
void trackRoll(){
//the old state+ current roll in this second
rotX = getMatX()+(int)rollvX;
rotY = getMatY()+(int)rollvY;
zoom = getMatZ()+zoomvZ;
//debug
//rotX = 90;
rotY = 0;
vertex c = getCenter();
glTranslated(c.x, c.y, c.z);
glRotated(-rotX, 0, 1, 0); //rotate around y axis
glRotated(-rotY, 1, 0, 0); //rotate around x axis
glTranslated(-c.x, -c.y, -c.z);
//when hand lost -> #INF
if(abs(zoom) >1){
glTranslated(c.x, c.y, c.z);
glScalef(1+(float)zoom/rate, 1+(float)zoom/rate, 1+(float)zoom/rate);
glTranslated(-c.x, -c.y, -c.z);
}
addMatrix((int)rollvX, (int)rollvY, zoomvZ);
//reset
rollvX=0;
rollvY=0;
zoomvZ=0;
}
void computeStrain(){
printf("Computing Green strain tensor...\n");
computeDeformGradient();
int j, atom;
double matrI[9];
for (atom = 0; atom < pdbData.atomCount; atom++){
for (j = 0; j < 9; j++){
atomGreenStrain[atom][j] = 0.0;
}
transposeMatrix(atomDeformGradient[atom], matrI);
multMatrix(matrI, atomDeformGradient[atom], atomGreenStrain[atom]);
for(j = 0; j < 9; j++)
matrI[j] = 0.0;
matrI[0] = -1.0;
matrI[4] = -1.0;
matrI[8] = -1.0;
addMatrix(atomGreenStrain[atom], matrI);
multScalarMatrix(atomGreenStrain[atom], 0.5);
}
if(stretchOn)
computeStretch();
}
int main(){
int row = 0;
int col = 0;
int maxsize = 100;
int matrixA[maxsize][maxsize];
int matrixB[maxsize][maxsize];
printf("Please enter the number of rows: ");
scanf("%d",&row);
printf("Please enter the number of columns: ");
scanf("%d",&col);
printf("Enter Matrix A \n");
readinMatrix(row,col,matrixA);
printf("Enter Matrix B \n");
readinMatrix(row,col,matrixB);
printf("A + B = \n");
addMatrix(row,col,matrixA,matrixB);
return 0;
}
int main(){
//start measuring time
clock_t start=clock();
//allocate matrices
int* matA = (int*)malloc(sizeof(int)*SIZE);
int* matB = (int*)malloc(sizeof(int)*SIZE);
int* matAns = (int*)malloc(sizeof(int)*SIZE);
int i;
for(i=0;i<SIZE;i++){
matA[i]=i;
matB[i]=SIZE-i;
}
//do the matrix addition on CPU
addMatrix(matAns,matA,matB);
//stop measuring time
clock_t stop=clock();
//print the elapsed time
double elapsedtime = (stop-start)/(double)CLOCKS_PER_SEC;
printf("Elapsed time is %f\n", (double)elapsedtime);
free(matA);
free(matB);
free(matAns);
return 0;
}
void SkPictureRecord::setMatrix(const SkMatrix& matrix) {
validate();
addDraw(SET_MATRIX);
addMatrix(matrix);
validate();
this->INHERITED::setMatrix(matrix);
}
bool SkPictureRecord::concat(const SkMatrix& matrix) {
validate();
addDraw(CONCAT);
addMatrix(matrix);
validate();
return this->INHERITED::concat(matrix);
}
void InstancesManagerImpl::_initData()
{
const size_t x_num = 16;
const size_t y_num = 16;
instancesData_.reserve( x_num * y_num);
#if 0
// create some matrices
srand(time(NULL));
for (unsigned int i = 0; i < x_num; ++i)
{
for (unsigned int j = 0; j < y_num; ++j)
{
// get random angle and random scale
double angle = (rand() % 360) / 180.0 * cg::pi;
double scale = 0.02 + (static_cast<double>(rand() % 10) / 1000.0 - 0.005);
// calculate position
osg::Vec3 position(i * 70, j * 70, 0.0f);
osg::Vec3 jittering((rand() % 100) * 2.f, (rand() % 100) * 2.f, (rand() % 100) * 2.f);
position += jittering;
position.z() *= 2.0f;
position.x() *= 2.0f;
position.y() *= 2.0f;
osg::Matrixd modelMatrix = osg::Matrixd::scale(scale, scale, scale)
* osg::Matrixd::rotate(angle, osg::Vec3d(0.0, 0.0, 1.0), angle, osg::Vec3d(0.0, 1.0, 0.0), angle, osg::Vec3d(1.0, 0.0, 0.0))
* osg::Matrixd::translate(position);
addMatrix(modelMatrix);
}
}
#endif
}
void SkPictureRecord::drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& matrix,
const SkPaint* paint) {
addDraw(DRAW_BITMAP_MATRIX);
addPaintPtr(paint);
addBitmap(bitmap);
addMatrix(matrix);
validate();
}
void
gaussianEstimator_Pred ( Matrix *xEst, Matrix *CEst, Matrix *U, Matrix *Cw, Matrix (*afun)(Matrix m, float t), float *dt, Matrix *m_opt)
{
float D = elem(sizeOfMatrix(*m_opt),0,1)+1; //printf("%f\n", D);
float w_opt = 1/D; //printf("%f\n", w_opt);
float Nx = elem(sizeOfMatrix(*xEst),0,0); //printf("%f\n", Nx);
float d = Nx*(D-1) + 1; //printf("%f\n", d);
float w = 1/d; //printf("%f\n", w);
/* Eigenvectors, Eigenvalues */
int dimC = elem ( sizeOfMatrix(*CEst), 0, 0 );
Matrix Vec = zeroMatrix(dimC, dimC);
Matrix Val = zeroMatrix(dimC, dimC);
eig ( CEst, &Vec, &Val );
/* m1 = vec*sqrtf(val) */
int i;
for ( i = 0; i < dimC; ++i )
setElem(Val, i, i, sqrtf(fabs(elem(Val, i,i))));
Matrix m1 = mulMatrix(Vec, Val);
freeMatrix(Vec);
freeMatrix(Val);
/* rotate & scale samples: m = m1*S */
Matrix m = scaledSamplePoints(m1, *m_opt);
/* x = x*ones(1,d) */
Matrix x = fillMatrix(*xEst, d);
/* shift samples: m = m + x */
m = addMatrix(m, x); //printMatrix(m);
/* afun */
/* Prediction: mean
xPredDiracs = feval(afun,m, [], [], t);
xPred = w*sum(xPredDiracs, 2);*/
Matrix xPredDiracs = (*afun) (m, *dt); //printMatrix(xPredDiracs);
Matrix xPredDiracsSum = sumMatrix(xPredDiracs, 2); //printMatrix(xPredDiracsSum);
Matrix xPred = mulScalarMatrix(w, xPredDiracsSum); //printMatrix(xPred);
//mxDiracs = xPredDiracs-repmat(xPred, 1, d);
//CPred = w_opt*mxDiracs*mxDiracs';
Matrix mxDiracs = subMatrix(xPredDiracs, fillMatrix(xPred, d)); //printMatrix(mxDiracs);
Matrix CPred = mulScalarMatrix(w_opt, mulMatrix(mxDiracs, transposeMatrix(mxDiracs))); //printMatrix(CPred);
//RETURN
*xEst = xPred; //printMatrix(*xEst);
*CEst = CPred; //printMatrix(*CEst);
freeMatrix(m);
freeMatrix(xPredDiracs);
freeMatrix(xPredDiracsSum);
}
RMatrix& RMatrix::addMatrix (const AMatrix& A, const LongInt& rowIndex, const LongInt& colIndex)
{
const AMatrixType theMatrixA = A.type();
LongInt m = numberOfRows();
LongInt n = numberOfColumns();
LongInt m1 = A.numberOfRows();
LongInt n1 = A.numberOfColumns();
if(theMatrixA==isRkRMatrix)
{
const RkRMatrix& R = (const RkRMatrix&)A;
LongInt k = R.rank();
LongInt mR = R.numberOfRows();
LongInt nR = R.numberOfColumns();
LongReal mike = 1.0;
// dgemm ( ¬ConjTrans, &conjTrans, &MIN(m,mR), &MIN(n,nR), &k, (LongReal*) &(Complex::complexUnit),
// (LongReal*) &(R.attr_A(rowIndex, 0)), &mR,
// (LongReal*) &(R.attr_B(colIndex, 0)), &nR, (LongReal*) &(Complex::complexUnit),
// (LongReal*) &(*this)(0, 0), &m);
TensorCalculus::Blas<double>::gemm (notConjTrans, conjTrans, MIN(m,mR), MIN(n,nR), k, 1.0,
&(R.attr_A(rowIndex, 0)), mR,
&(R.attr_B(colIndex, 0)), nR, 1.0,
&(*this)(0, 0), m);
}
else if(theMatrixA==isRMatrix)
{
const RMatrix& C = (const RMatrix&)A;
int ic = 1;
for(LongInt i=0; i<n; i++)
{
// daxpy (&m, (LongReal*) &(Complex::complexUnit), (LongReal*) &C(rowIndex, colIndex+i),
// &ic, (LongReal*) &(*this)(0, i), &ic);
TensorCalculus::Blas<double>::axpy (m, 1.0, &C(rowIndex, colIndex+i), ic, &(*this)(0, i), ic);
}
}
else if(theMatrixA==isHMatrixInterface)
{
RMatrix C(m1, n1);
C.isConversionOf(A);
addMatrix(C, rowIndex, colIndex);
}
else
{
throw SimpleException(IString("Warning In RMatrix::addMatrix (const AMatrix& A, const LongInt& rowIndex, const LongInt& colIndex), Type Not Implemented !!!"));
}
return (*this);
}
void KalmanFilter::getPPlus() {
double** prod1 = productMatrix(A,P,3,3,3);
double** tA = transposeMatrix(A,3,3);
double** prod2 = productMatrix(prod1,tA,3,3,3);
freeMatrix(P,3);
P = addMatrix(prod2,Q,3,3);
freeMatrix(prod1,3);
freeMatrix(prod2,3);
freeMatrix(tA,3);
}
void kalmanProcess(kalman_s *mykalman)
{
int i,j;
for(i=0;i<NM;i++)
memset(mykalman->temp_4_4[i],0,sizeof(double)*NM);
//第一个公式：x(k|k-1) = Ax(k-1|k-1)
multiplyMatrix(mykalman->A,NS,NS,mykalman->X,NS,1,mykalman->temp_1); //X=A*X
for (i=0;i<NS;i++)
mykalman->X[i][0]=mykalman->temp_1[i][0];
//第二个公式： P = A*P*A'+Q
multiplyMatrix(mykalman->A,NS,NS,mykalman->P,NS,NS,mykalman->temp_2_1); //temp_2_1 = A*P
transpositionMatrix(mykalman->A, mykalman->temp_2, NS, NS); //temp_2 = A'
multiplyMatrix(mykalman->temp_2_1,NS,NS,mykalman->temp_2,NS,NS,mykalman->P); //P = A*P*A’
addMatrix(mykalman->P,NS,NS,mykalman->Q,NS,NS,mykalman->P); //P = A*P*A’+Q
//第三个公式： X = X+K*[Z-H*X]
multiplyMatrix(mykalman->H,NM,NS,mykalman->X,NS,1,mykalman->temp_3_1); //temp_3_1=H*X
subMatrix(mykalman->Z,NM,1,mykalman->temp_3_1,NM,1,mykalman->temp_3_1); //temp_3_1=Z-H*X
multiplyMatrix(mykalman->K,NS,NM,mykalman->temp_3_1,NM,1,mykalman->temp_3_2); //temp_3_2 = K*(Z-H*X)
addMatrix(mykalman->X,NS,1,mykalman->temp_3_2,NS,1,mykalman->X); //X = X+ K*(Z-H*X)
//第四个公式：K = P*H'/[H*P*H'+R]
transpositionMatrix(mykalman->H,mykalman->temp_4_3,NM,NS); //temp_4_3 = H'
multiplyMatrix(mykalman->P,NS,NS,mykalman->temp_4_3,NS,NM,mykalman->temp_4_1); //temp_4_1 = P*H'
multiplyMatrix(mykalman->H,NM,NS,mykalman->temp_4_1,NS,NM,mykalman->temp_4_2); //temp_4_2 =H*P*H'
addMatrix(mykalman->temp_4_2,NM,NM,mykalman->R,NM,NM,mykalman->temp_4_2); //temp_4_2 =H*P*H'+R
InverseMatrix(mykalman->temp_4_2, mykalman->temp_4_4, NM,NM); //temp_4_4=~(H*P*H'+R)
multiplyMatrix(mykalman->temp_4_1,NS,NM,mykalman->temp_4_4,NM,NM,mykalman->K); //K = P*H'*~(H*P*H'+R)
//第五个公式：P = [I-K*H]*P
multiplyMatrix(mykalman->K,NS,NM,mykalman->H,NM,NS,mykalman->temp_5); //temp_5 = K*H
subMatrix(mykalman->E,NS,NS,mykalman->temp_5,NS,NS,mykalman->temp_5_1); //temp_5_1 = E-K*H
multiplyMatrix(mykalman->temp_5_1,NS,NS,mykalman->P,NS,NS,mykalman->temp_5_2); //temp_5_2 = (E-K*H)*P
for (i=0;i<NS;i++)
for (j=0;j<NS;j++)
mykalman->P[i][j] = mykalman->temp_5_2[i][j];
}
int main()
{
int N, K, i, j, k;
int **A;
int **S;
int **T;
int ***powers;
char *computed;
A = (int **) malloc(MAX_N * sizeof(int *));
for ( i=0; i<MAX_N; ++i )
A[i] = (int *) malloc(MAX_N * sizeof(int));
S = (int **) malloc(MAX_N * sizeof(int *));
for ( i=0; i<MAX_N; ++i )
S[i] = (int *) malloc(MAX_N * sizeof(int));
T = (int **) malloc(MAX_N * sizeof(int *));
for ( i=0; i<MAX_N; ++i )
T[i] = (int *) malloc(MAX_N * sizeof(int));
powers = (int ***) malloc((MAX_K+1) * sizeof(int **));
for ( i=0; i<MAX_K+1; ++i ) {
powers[i] = (int **) malloc((MAX_N) * sizeof(int *));
for ( j=0; j<MAX_N; ++j ) {
powers[i][j] = (int *) malloc((MAX_N) * sizeof(int));
}
}
computed = (char *) malloc((MAX_K+1) * sizeof(char));
while ( ~scanf("%d %d", &N, &K) && N!=0 ) {
readMatrix(A, N);
for ( k=1; k<=K; ++k ) computed[k] = 0;
for ( i=0; i<N; ++i )
for ( j=0; j<N; ++j )
S[i][j] = 0;
for ( k=1; k<=K; ++k ) {
powMatrix(T, A, k, powers, computed, N);
addMatrix(S, S, T, N);
}
printMatrix(S, N);
}
}
void evaluateASTNodeSimpleExp(ASTNode *node){
switch (node->subType) {
case SimpleExpTerm:
/*just clone the result*/
node->mat = cloneMatrix(node->l->mat);
break;
case SimpleExpPlus:
node->mat = addMatrix(node->l->mat, node->r->mat);
break;
case SimpleExpMinus:
node->mat = minusMatrix(node->l->mat, node->r->mat);
break;
case SimpleExpPower:
node->mat = powerMatrix(node->l->mat, (int)readOneElementOfMatrix(node->r->mat,1,1));
break;
default:
break;
}
return;
}
/*
Main-Funktion
*/
int main(int argc, char *argv[]) {
// Zufallszahlengenerator initialisieren
srand(time(NULL));
matrix a = initMatrixRand(5,5);
matrix b = initMatrixRand(5,5);
printf("a =\n"); prettyPrint(a);
printf("\nb =\n"); prettyPrint(b);
matrix c = addMatrix(a, b);
printf("\na + b =\n");
prettyPrint(c);
freeMatrix(c);
c = subMatrix(a, b);
printf("\na - b =\n");
prettyPrint(c);
freeMatrix(c);
c = multMatrix(a, b);
printf("\na * b =\n");
prettyPrint(c);
freeMatrix(c);
c = transposeMatrix(a);
printf("\na^T =\n");
prettyPrint(c);
freeMatrix(c);
printf("\ndet(a) = %.2f\n", determinante(a));
printf("detQuick(a) = %.2f\n\n", detQuick(a));
printf("\ndet(b) = %.2f\n", determinante(b));
printf("detQuick(b) = %.2f\n\n", detQuick(b));
freeMatrix(a);
freeMatrix(b);
return 0;
}
/*!
\class WorkbookView
\brief View class for Workbook
\ingroup commonfrontend
*/
WorkbookView::WorkbookView(Workbook* workbook) : QWidget(),
m_tabWidget(new TabWidget(this)),
m_workbook(workbook),
lastSelectedIndex(0) {
m_tabWidget->setTabPosition(QTabWidget::South);
m_tabWidget->setTabShape(QTabWidget::Rounded);
m_tabWidget->setMovable(true);
m_tabWidget->setContextMenuPolicy(Qt::CustomContextMenu);
m_tabWidget->setMinimumSize(200, 200);
QHBoxLayout* layout = new QHBoxLayout(this);
layout->setContentsMargins(0,0,0,0);
layout->addWidget(m_tabWidget);
//add tab for each children view
m_initializing = true;
foreach(const AbstractAspect* aspect, m_workbook->children<AbstractAspect>())
handleAspectAdded(aspect);
m_initializing = false;
//Actions
action_add_spreadsheet = new QAction(QIcon::fromTheme("labplot-spreadsheet"), i18n("Add new Spreadsheet"), this);
action_add_matrix = new QAction(QIcon::fromTheme("labplot-matrix"), i18n("Add new Matrix"), this);
connect(action_add_spreadsheet, SIGNAL(triggered()), this, SLOT(addSpreadsheet()));
connect(action_add_matrix, SIGNAL(triggered()), this, SLOT(addMatrix()));
//SIGNALs/SLOTs
connect(m_workbook, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(handleDescriptionChanged(const AbstractAspect*)));
connect(m_workbook, SIGNAL(aspectAdded(const AbstractAspect*)), this, SLOT(handleAspectAdded(const AbstractAspect*)));
connect(m_workbook, SIGNAL(aspectAboutToBeRemoved(const AbstractAspect*)), this, SLOT(handleAspectAboutToBeRemoved(const AbstractAspect*)));
connect(m_workbook, SIGNAL(requestProjectContextMenu(QMenu*)), this, SLOT(createContextMenu(QMenu*)));
connect(m_workbook, SIGNAL(workbookItemSelected(int)), this, SLOT(itemSelected(int)) );
connect(m_tabWidget, SIGNAL(currentChanged(int)), SLOT(tabChanged(int)));
connect(m_tabWidget, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(showTabContextMenu(QPoint)));
connect(m_tabWidget, SIGNAL(tabMoved(int,int)), this, SLOT(tabMoved(int,int)));
}
void
gaussianEstimator_Pred_decomp ( Matrix *xEst, Matrix *CEst, Matrix *U, Matrix *Cw, float *dt, Matrix *m_opt)
{
float r;
Matrix sizeMopt;
Matrix xn = zeroMatrix(3,1);
Matrix Cn = zeroMatrix(3,3);
Matrix xl = zeroMatrix(9,1);
Matrix Cl = zeroMatrix(9,9);
Matrix Cnl = zeroMatrix(3,9);
Matrix Cnl_T;
Matrix Cn_i;
Matrix CLN;
Matrix sizeCn;
Matrix Vec;
Matrix Val;
Matrix m1;
Matrix m;
Matrix x;
Matrix A;
Matrix Hi = zeroMatrix(12,9);
Matrix Cy = zeroMatrix(12, 12);
Matrix muy = zeroMatrix(12, 1);
Matrix zeros33 = zeroMatrix(3,3);
Matrix eye33 = unitMatrix(3,3);
Matrix Mat;
Matrix H;
Matrix gi = zeroMatrix(12,1);
Matrix Rot_vec = zeroMatrix(3,1);
Matrix mui;
Matrix muiy;
Matrix Ciy;
Matrix tmp;
Matrix tmp1;
Matrix tmp2;
Matrix tmp3;
Matrix tmp4;
Matrix tmp5;
Matrix tmp6;
Matrix tmp7;
Matrix tmp8;
Matrix tmpHi;
sizeMopt = sizeOfMatrix(*m_opt); //printf("%f\n",*dt);
float D = elem(sizeMopt,0,1)+1; //printf("%f\n", D);
freeMatrix(sizeMopt);
float w_opt = 1/D; //printf("%f\n", w_opt);
float Nx = 3;
float d = Nx*(D-1) + 1; //printf("%f\n", d);
float w = 1/d; //printf("%f\n", w);
//xn = xEst(4:6); % Rotation vector
appMatrix(xn, 0, 2, 0, 0, *xEst, 3, 5, 0, 0); //printMatrix(xn);system("PAUSE");
//Cn = CEst(4:6,4:6);
appMatrix(Cn, 0, 2, 0, 2, *CEst, 3, 5, 3, 5); //printMatrix(Cn);system("PAUSE");
//xl = [xEst(1:3) ; xEst(7:12)]; % Translation, angular velocity, linear velocity
appMatrix(xl, 0, 2, 0, 0, *xEst, 0, 2, 0, 0);
appMatrix(xl, 3, 8, 0, 0, *xEst, 6, 11, 0, 0); //printMatrix(xl);system("PAUSE");
//Cl = [CEst(1:3,1:3) CEst(1:3,7:12);
// CEst(7:12,1:3) CEst(7:12,7:12)] ;
appMatrix(Cl, 0, 2, 0, 2, *CEst, 0, 2, 0, 2);
appMatrix(Cl, 0, 2, 3, 8, *CEst, 0, 2, 6, 11);
appMatrix(Cl, 3, 8, 0, 2, *CEst, 6, 11, 0, 2);
appMatrix(Cl, 3, 8, 3, 8, *CEst, 6, 11, 6, 11); //printMatrix(Cl);system("PAUSE");
//Cnl = [CEst(4:6,1:3) CEst(4:6,7:12)];
appMatrix(Cnl, 0, 2, 0, 2, *CEst, 3, 5, 0, 2);
appMatrix(Cnl, 0, 2, 3, 8, *CEst, 3, 5, 6, 11); //printMatrix(Cnl);system("PAUSE");
//CLN = Cl - Cnl'*inv(Cn)*Cnl;
Cnl_T = transposeMatrix(Cnl);
// printMatrix(Cn);system("PAUSE");
Cn_i = invertCovMatrix(Cn); //printMatrix(Cn_i);system("PAUSE");
tmp = mulMatrix( Cnl_T, Cn_i);
tmp7 = mulMatrix(tmp, Cnl);
CLN = subMatrix ( Cl, tmp7); //printMatrix(CLN);system("PAUSE");
freeMatrix(tmp);
freeMatrix(tmp7);
// Eigenvectors, Eigenvalues
sizeCn = sizeOfMatrix(Cn);
int dimC = elem ( sizeCn, 0, 0 );
freeMatrix(sizeCn);
Vec = zeroMatrix(dimC, dimC);
Val = zeroMatrix(dimC, dimC);
eig ( &Cn, &Vec, &Val ); //printMatrix(Cn);printMatrix(Vec);printMatrix(Val);system("PAUSE");
// m1 = vec*sqrtf(val)
int i;
for ( i = 0; i < dimC; ++i )
setElem(Val, i, i, sqrtf(fabs(elem(Val, i,i))));
m1 = mulMatrix(Vec, Val); //printMatrix(m1);system("PAUSE");
// rotate & scale samples: m = m1*S
m = scaledSamplePoints(m1, *m_opt); //printMatrix(m);system("PAUSE");
// x = x*ones(1,d)
x = fillMatrix(xn, d);
// shift samples: m = m + x
tmp = addMatrix(m, x);
appMatrix(m, 0, m->height-1, 0, m->width-1, tmp, 0, tmp->height-1, 0, tmp->width-1 ); //printMatrix(m);system("PAUSE");
freeMatrix(tmp);
//A = [[eye(3,3),t*eye(3,3)];[zeros(3,3),eye(3,3)]];
A = unitMatrix(6,6);
setElem(A, 0, 3, *dt);
setElem(A, 1, 4, *dt);
setElem(A, 2, 5, *dt); //printMatrix(A);system("PAUSE");
for (i=0; i<d; i++)
{
//gi = [zeros(3,1); m(:,i); zeros(6,1)];
setElem(gi, 3, 0, elem(m, 0, i));
setElem(gi, 4, 0, elem(m, 1, i));
setElem(gi, 5, 0, elem(m, 2, i)); //printMatrix(gi);system("PAUSE");
//Rot_vec = m(:,i);
setElem(Rot_vec, 0, 0, elem(m, 0, i));
setElem(Rot_vec, 1, 0, elem(m, 1, i));
setElem(Rot_vec, 2, 0, elem(m, 2, i)); //printMatrix(Rot_vec);system("PAUSE");
//r = norm(Rot_vec);
r = sqrtf( powf((elem(Rot_vec,0,0)),2) + powf((elem(Rot_vec,1,0)),2) + powf((elem(Rot_vec,2,0)),2) ); //printf("%f\n",r);
H = zeroMatrix(3,3);
if (fmod(r, 2*pi) == 0)
{
Mat = unitMatrix(3,3);
}
else
{
// build skew symmetric Matrix
setElem(H, 0, 1, -elem(Rot_vec,2,0));
setElem(H, 0, 2, elem(Rot_vec,1,0));
setElem(H, 1, 0, elem(Rot_vec,2,0));
setElem(H, 1, 2, -elem(Rot_vec,0,0));
setElem(H, 2, 0, -elem(Rot_vec,1,0));
setElem(H, 2, 1, elem(Rot_vec,0,0)); //printMatrix(H);system("PAUSE");
// Bortz equation
// Mat = eye(3,3) + 0.5*H + (1- r*sin(r)/( 2*(1-cos(r))))/r^2*H*H;
// already declared Mat = unitMatrix(3,3);
tmp1 = mulScalarMatrix(0.5, H);
tmp4 = addMatrix( eye33 , tmp1 );
tmp2 = mulMatrix(H, H);
tmp3 = mulScalarMatrix( (1-(r*sin(r)/(2*(1-cos(r)))))/powf(r,2), tmp2);
Mat = addMatrix( tmp4, tmp3);
//printMatrix(Mat);system("PAUSE");
freeMatrix(tmp1);
freeMatrix(tmp2);
freeMatrix(tmp3);
freeMatrix(tmp4);
}
//Hi = [[A(1:3,1:3) zeros(3,3) A(1:3,4:6)];
// [zeros(3,3), t*Mat, zeros(3,3)];
// [zeros(3,3), eye(3,3), zeros(3,3)];
// [A(4:6,1:3),zeros(3,3), A(4:6,4:6)]];
appMatrix( Hi, 0, 2, 0, 2, A, 0, 2, 0, 2 );
appMatrix( Hi, 0, 2, 3, 5, zeros33, 0, 2, 0, 2 );
appMatrix( Hi, 0, 2, 6, 8, A, 0, 2, 3, 5 );
appMatrix( Hi, 3, 5, 0, 2, zeros33, 0, 2, 0, 2 );
tmpHi = mulScalarMatrix(*dt, Mat);
appMatrix( Hi, 3, 5, 3, 5, tmpHi, 0, 2, 0, 2 );
freeMatrix(tmpHi);
appMatrix( Hi, 3, 5, 6, 8, zeros33, 0, 2, 0, 2 );
appMatrix( Hi, 6, 8, 0, 2, zeros33, 0, 2, 0, 2 );
appMatrix( Hi, 6, 8, 3, 5, eye33, 0, 2, 0, 2 );
appMatrix( Hi, 6, 8, 6, 8, zeros33, 0, 2, 0, 2 );
appMatrix( Hi, 9, 11, 0, 2, A, 3, 5, 0, 2 );
appMatrix( Hi, 9, 11, 3, 5, zeros33, 0, 2, 0, 2 );
appMatrix( Hi, 9, 11, 6, 8, A, 3, 5, 3, 5 ); //printMatrix(Hi);system("PAUSE");
// mui = xl + Cnl'*inv(Cn)*(m(:,i)-xn); //m(:,i) -> Rot_vec
tmp = mulMatrix(Cnl_T, Cn_i );
tmp1 = subMatrix(Rot_vec, xn);
tmp2 = mulMatrix(tmp, tmp1);
mui = addMatrix(xl, tmp2);
freeMatrix(tmp);
freeMatrix(tmp1);
freeMatrix(tmp2); //printMatrix(mui);system("PAUSE");
// muiy = gi + Hi * mui;
tmp = mulMatrix(Hi, mui);
muiy = addMatrix( gi, tmp); //printMatrix(muiy);system("PAUSE");
freeMatrix(tmp);
// Ciy = Hi *CLN *Hi';
tmp1 = mulMatrix(Hi, CLN);
tmp2 = transposeMatrix(Hi);
Ciy = mulMatrix( tmp1, tmp2); //printMatrix(Ciy);system("PAUSE");
freeMatrix(tmp1);
freeMatrix(tmp2);
// Cy = Cy + (w*Ciy + w_opt*muiy*muiy');
tmp3 = mulScalarMatrix(w, Ciy);
tmp1 = transposeMatrix(muiy);
tmp2 = mulMatrix(muiy, tmp1);
tmp4 = mulScalarMatrix( w_opt, tmp2 );
tmp5 = addMatrix( tmp3, tmp4 );
tmp6 = addMatrix( Cy, tmp5);
appMatrix(Cy,0,Cy->height-1,0,Cy->width-1,tmp6, 0,tmp6->height-1,0,tmp6->width-1); //printMatrix(Cy);system("PAUSE");
freeMatrix(tmp1);
freeMatrix(tmp2);
freeMatrix(tmp3);
freeMatrix(tmp4);
freeMatrix(tmp5);
freeMatrix(tmp6);
// muy = muy + w*muiy;
tmp = mulScalarMatrix( w, muiy );
tmp2 = addMatrix( muy, tmp );
appMatrix(muy,0,muy->height-1,0,muy->width-1, tmp2, 0, tmp2->height-1, 0, tmp2->width-1); //printMatrix(muy);system("PAUSE");
freeMatrix(tmp);
freeMatrix(tmp2);
freeMatrix(H);
freeMatrix(Mat);
freeMatrix(mui);//
freeMatrix(muiy);//
freeMatrix(Ciy);
}
appMatrix(*xEst, 0, 11, 0, 0, muy, 0, 11, 0, 0 ); //printMatrix(muy);system("PAUSE");
//CEst = Cy - muy*muy' * w_opt/w + Cw;
tmp1 = transposeMatrix(muy);
tmp2 = mulMatrix(muy, tmp1);
tmp5 = mulScalarMatrix( w_opt/w, tmp2 );
tmp6 = subMatrix(Cy, tmp5);
tmp8 = addMatrix( tmp6, *Cw); //printMatrix(*CEst);system("PAUSE");
appMatrix(*CEst,0,11,0,11, tmp8, 0,11,0,11 ); //printMatrix(tmp8);system("PAUSE");
freeMatrix(tmp1);
freeMatrix(tmp2);
freeMatrix(tmp5);
freeMatrix(tmp6);
freeMatrix(tmp8);
freeMatrix(muy);//
freeMatrix(zeros33);//
freeMatrix(Vec);
freeMatrix(Val);
freeMatrix(Cy);
freeMatrix(xn);
freeMatrix(Cn);
freeMatrix(xl);
freeMatrix(Cl);//
freeMatrix(Cnl);
freeMatrix(Cnl_T);
freeMatrix(Cn_i);
freeMatrix(CLN);//
freeMatrix(m1);
freeMatrix(m);//
freeMatrix(x);
freeMatrix(A);
freeMatrix(eye33);
freeMatrix(Hi);
freeMatrix(gi);
freeMatrix(Rot_vec);
} /* End gaussianPred_decomp */
// function to update data due to a thickness change
void CHak3DShell_4::change_thk(double tin)
{
int i, nt[3];
double fact = tin / t; // new / old
t = tin; // update thickness
volume *= fact; // update volume
for(i=0; i<4; i++)
{
sub_shells[i]->change_thk(tin); // chane thk of sub elems
}
// update stiffness matrix - from sub-matrices
if(Ke)
{
delete [] Ke;
Ke = new double [300]();
// assemble sub matrices into total elem matrix
// first triangle is 0,1,2
nt[0] = 0;
nt[1] = 1;
nt[2] = 2;
addMatrix(3, 4, sub_shells[0]->getKe(), Ke, 6, nt);
// second triangle is 0,2,3
nt[1] = 2;
nt[2] = 3;
addMatrix(3, 4, sub_shells[1]->getKe(), Ke, 6, nt);
// third triangle is 0,1,3
nt[1] = 1;
addMatrix(3, 4, sub_shells[2]->getKe(), Ke, 6, nt);
// forth triangle is 1,2,3
nt[0] = 1;
nt[1] = 2;
addMatrix(3, 4, sub_shells[3]->getKe(), Ke, 6, nt);
// now divide by 2
for(i=0; i<300; i++) {
Ke[i] *= 0.5;
}
}
// update mass matrix - from sub-matrices
if(Me)
{
delete [] Me;
Me = new double [300]();
// assemble sub matrices into total elem matrix
// first triangle is 0,1,2
nt[0] = 0;
nt[1] = 1;
nt[2] = 2;
addMatrix(3, 4, sub_shells[0]->getMe(), Me, 6, nt);
// second triangle is 0,2,3
nt[1] = 2;
nt[2] = 3;
addMatrix(3, 4, sub_shells[1]->getMe(), Me, 6, nt);
// third triangle is 0,1,3
nt[1] = 1;
addMatrix(3, 4, sub_shells[2]->getMe(), Me, 6, nt);
// forth triangle is 1,2,3
nt[0] = 1;
nt[1] = 2;
addMatrix(3, 4, sub_shells[3]->getMe(), Me, 6, nt);
// now divide by 2
for(i=0; i<300; i++) {
Me[i] *= 0.5;
}
}
}
int main() {
int i;
double **K, **M, **Q, **T, **aux, **InverseM;
double **A, **Q2, **R;
double **L, **U;
double *eigenValues, **eigenVectors;
int aux2;
h = (double) (b - a) / n;
alfa = (double) a2 / a1;
beta = (double) b2 / b1;
if (ua == 0 && ub == 0) {
tam = n - 1;
aux2 = 1;
} else {
tam = n + 1;
aux2 = 0;
}
createVector(&x, tam);
x[0] = a + (h * aux2);
for (i = 1; i < tam; i++)
x[i] = x[i - 1] + h;
createMatrix(&K, tam, tam);
createMatrix(&M, tam, tam);
createMatrix(&InverseM, tam, tam);
createMatrix(&Q, tam, tam);
createMatrix(&T, tam, tam);
createMatrix(&aux, tam, tam);
createMatrix(&A, tam, tam);
createMatrix(&Q2, tam, tam);
createMatrix(&R, tam, tam);
createMatrix(&L, tam, tam);
createMatrix(&U, tam, tam);
createVector(&eigenValues, tam);
createMatrix(&eigenVectors, tam, tam);
funcT = functionT;
funcT2 = functionT2;
funcQ = functionQ;
funcM = functionM;
triDiagonalMatrix(tam, funcT, funcT2, funcT, T);
diagonalMatrix(tam, funcQ, Q);
diagonalMatrix(tam, funcM, M);
//inverseMatrix(tam, M, InverseM);
escaleByMatrix(tam, tam, 1.0/pow(h, 2), T, aux);
addMatrix(tam, tam, aux, Q, K);
copyMatrix(tam,tam,K,A);
//multiplicationMatrix(tam, tam, InverseM, K, A);
/*matrixLU(tam, A, L, U);
printMatrix(tam, tam, A);
printf("\n");
printMatrix(tam, tam, L);
printf("\n");
L[0][0] = 0;
L[0][1] = 0;
L[1][0] = 0;
L[1][1] = 0;
printf("%d\n", isCeroDiagonalInf(L,tam));
printMatrix(tam, tam, U);*/
factorizeUL(tam,A,eigenValues,eigenVectors);
printf("Eigenvalues:\n");
printVector(tam, eigenValues);
printf("\nEigenvectors:\n");
printMatrix(tam,tam, eigenVectors);
destroyMatrix(&K, tam, tam);
destroyMatrix(&M, tam, tam);
destroyMatrix(&InverseM, tam, tam);
destroyMatrix(&Q, tam, tam);
destroyMatrix(&T, tam, tam);
destroyMatrix(&aux, tam, tam);
destroyMatrix(&A, tam, tam);
destroyMatrix(&Q2, tam, tam);
destroyMatrix(&R, tam, tam);
destroyMatrix(&L, tam, tam);
destroyMatrix(&U, tam, tam);
destroyVector(&x, tam);
destroyVector(&eigenValues, tam);
destroyMatrix(&eigenVectors, tam, tam);
return 0;
}
int main()
{
char cmd[1000]={},split[5][100]={};
char *token;
int cmdSpt=0,i,returnA,returnB,returnTar,returnFunc,row,col,size;
double mul;
FILE *fileA=NULL,*fileB=NULL,*fileTar=NULL;
matrix matA,matB,matTar;
//prints welcome messages
system("cls");
printf("\n\n===Matrix manipulation program===\n\n");
printf("Type <help> for command list and usage\n\n");
do
{
printf("MATRIX> "); //command prompt
rewind(stdin); //rewind everything
scanf("%[^\n]",cmd); //get command (with spaces)
cmdSpt=0; //set sub command count to 0
token=strtok(cmd," "); //partition command to subcommand with spaces
while(token!=NULL&&cmdSpt<=5)
{
strcpy(split[cmdSpt],token); //save subcommands to split[]
cmdSpt++; //increase sub command count
token=strtok(NULL," ");
}
for(i=0;i<strlen(split[0]);i++) //set command to lowercase
split[0][i]=tolower(split[0][i]);
if(strcmp(split[0],"show")==0&&cmdSpt==2) //show command
{
returnA=openFile(&fileA,split[1],0); //call openFile() to open file to show
if(returnA==1) //failed to open
printf("Error: file %s failed to open.\n\n",split[1]);
else
{
matA=readMatrix(fileA); //read matrix and save to matA
showMatrix(matA,split[1]); //show matrix matA
}
}
else if(strcmp(split[0],"create")==0&&cmdSpt==4) //create command
{
returnA=openFile(&fileA,split[3],1); //call openFile() to create a new file
{
if(returnA==1) //failed to open
printf("Error: file %s failed to open.\n\n",split[3]);
else if(sscanf(split[1],"%d",&row)!=1||sscanf(split[2],"%d",&col)!=1) //incorrect matrix size entered
printf("Error: invalid matrix size.\n\n");
else if(row>50||col>50) //size too large
printf("Error: maximum matrix size is 50x50.\n\n");
else
{
createMatrix(row,col,fileA); //create a new matrix with specified size
printf("%dx%d matrix was successfully saved to %s.\n\n",row,col,split[3]);
}
}
}
else if(strcmp(split[0],"copy")==0&&cmdSpt==3) //copy command
{
returnA=openFile(&fileA,split[1],0); //open source and destination files
returnB=openFile(&fileTar,split[2],1);
if(returnA==1) //failed to open source
printf("Error: file %s failed to open.\n\n",split[1]);
if(returnB==1) //failed to open destination
printf("Error: file %s failed to open.\n\n",split[2]);
if(returnA==0&&returnB==0) //passed
{
matA=readMatrix(fileA); //read source file
writeMatrix(matA,fileTar); //write to destination file
printf("Matrix from %s is successfully copied to %s.\n\n",split[1],split[2]);
}
}
else if(strcmp(split[0],"add")==0&&cmdSpt==4) //add command
{
returnA=openFile(&fileA,split[1],0); //open source and destination files
returnB=openFile(&fileB,split[2],0);
returnTar=openFile(&fileTar,split[3],1);
if(returnA==1) //failed to open source A
printf("Error: file %s failed to open.\n\n",split[1]);
if(returnB==1) //failed to open source B
printf("Error: file %s failed to open.\n\n",split[2]);
if(returnTar==1) //failed to open destination
printf("Error: file %s failed to open.\n\n",split[3]);
if(returnA==0&&returnB==0&&returnTar==0) //passed
{
matA=readMatrix(fileA); //read both sources files
matB=readMatrix(fileB);
returnFunc=addMatrix(matA,matB,fileTar); //add matrices and save to destination
if(returnFunc==0) //success
{
printf("New matrix is successfully saved to %s.\n\n",split[3]);
matTar=readMatrix(fileTar);
printf("===Base matrix===\n");
showMatrix(matA,split[1]);
printf("===Adder matrix===\n");
showMatrix(matB,split[2]);
printf("===Result matrix===\n");
showMatrix(matTar,split[3]);
}
else //dimensions not matched
printf("Error: matrix dimensions unmatched.\n\n");
}
}
else if((strcmp(split[0],"subtract")==0||strcmp(split[0],"sub")==0)&&cmdSpt==4) //subtract command
{
returnA=openFile(&fileA,split[1],0); //open source and destination files
returnB=openFile(&fileB,split[2],0);
returnTar=openFile(&fileTar,split[3],1);
if(returnA==1) //failed to open source A
printf("Error: file %s failed to open.\n\n",split[1]);
if(returnB==1) //failed to open source B
printf("Error: file %s failed to open.\n\n",split[2]);
if(returnTar==1) //failed to open destination
printf("Error: file %s failed to open.\n\n",split[3]);
if(returnA==0&&returnB==0&&returnTar==0) //passed
{
matA=readMatrix(fileA); //read both sources files
matB=readMatrix(fileB);
returnFunc=subMatrix(matA,matB,fileTar); //subtract matrices and save to destination
if(returnFunc==0) //success
{
printf("New matrix is successfully saved to %s.\n\n",split[3]);
matTar=readMatrix(fileTar);
printf("===Base matrix===\n");
showMatrix(matA,split[1]);
printf("===Subtractor matrix===\n");
showMatrix(matB,split[2]);
printf("===Result matrix===\n");
showMatrix(matTar,split[3]);
}
else //dimensions not matched
printf("Error: matrix dimensions unmatched.\n\n");
}
}
else if((strcmp(split[0],"multiply")==0||strcmp(split[0],"mul")==0)&&cmdSpt==4) //multiply command
{
returnA=openFile(&fileA,split[1],0); //open source and destination files
returnB=openFile(&fileB,split[2],0);
returnTar=openFile(&fileTar,split[3],1);
if(returnA==1) //failed to open source A
printf("Error: file %s failed to open.\n\n",split[1]);
if(returnB==1) //failed to open source B
printf("Error: file %s failed to open.\n\n",split[2]);
if(returnTar==1) //failed to open destination
printf("Error: file %s failed to open.\n\n",split[3]);
if(returnA==0&&returnB==0&&returnTar==0) //passed
{
matA=readMatrix(fileA); //read both sources files
matB=readMatrix(fileB);
returnFunc=mulMatrix(matA,matB,fileTar); //multiply matrices and save to destination
if(returnFunc==0) //success
{
printf("New matrix is successfully saved to %s.\n\n",split[3]);
matTar=readMatrix(fileTar);
printf("===Base matrix===\n");
showMatrix(matA,split[1]);
printf("===Multiplier matrix===\n");
showMatrix(matB,split[2]);
printf("===Result matrix===\n");
showMatrix(matTar,split[3]);
}
else //dimensions not matched
printf("Error: matrix dimensions unmatched.\n\n");
}
}
else if((strcmp(split[0],"mulscalar")==0||strcmp(split[0],"muls")==0)&&cmdSpt==4) //multiply scalar command
{
returnA=openFile(&fileA,split[2],0); //open source and destination files
returnTar=openFile(&fileTar,split[3],1);
returnFunc=sscanf(split[1],"%lf",&mul); //convert multiplier to double
if(returnA==1) //failed to open source A
printf("Error: file %s failed to open.\n\n",split[2]);
if(returnTar==1) //failed to open destination
printf("Error: file %s failed to open.\n\n",split[3]);
if(returnFunc!=1) //cannot convert multiplier to double (invalid)
printf("Error: invalid multiplier.\n\n");
if(returnA==0&&returnB==0&&returnFunc==1) //passed
{
matA=readMatrix(fileA); //read source file
mulScaMatrix(matA,mul,fileTar); //multiply with scalar and save to destination
printf("New matrix is successfully saved to %s.\n\n",split[3]);
matTar=readMatrix(fileTar);
printf("===Base matrix===\n");
showMatrix(matA,split[2]);
printf("Multiply with %g\n\n",mul);
printf("===Result matrix===\n");
showMatrix(matTar,split[3]);
}
}
else if((strcmp(split[0],"transpose")==0||strcmp(split[0],"trans")==0)&&cmdSpt==3) //transpose command
{
returnA=openFile(&fileA,split[1],0); //open source and destination files
returnTar=openFile(&fileTar,split[2],1);
if(returnA==1) //failed to open source A
printf("Error: file %s failed to open.\n\n",split[1]);
if(returnTar==1) //failed to open destination
printf("Error: file %s failed to open.\n\n",split[2]);
if(returnA==0&&returnTar==0) //passed
{
matA=readMatrix(fileA); //read source file
transMatrix(matA,fileTar); //transpose matrix and save to destination
printf("New matrix is successfully saved to %s.\n\n",split[2]);
}
}
else if((strcmp(split[0],"identity")==0||strcmp(split[0],"iden")==0)&&cmdSpt==3) //identity matrix command
{
returnTar=openFile(&fileTar,split[2],1); //open destination file
returnFunc=sscanf(split[1],"%d",&size); //convert size to integer
if(returnTar==1) //failed to open destination
printf("Error: file %s failed to open.\n\n",split[2]);
else if(returnFunc!=1) //failed to convert size to integer (invalid)
printf("Error: invalid matrix size.\n\n");
else if(size>50) //size too large
printf("Error: maximum matrix size is 50x50.\n\n");
else
{
idenMatrix(size,fileTar); //create identity matrix with specified size and save to destination
printf("Identity matrix of size %d is successfully saved to %s.\n\n",size,split[2]);
}
}
else if(strcmp(split[0],"help")==0&&cmdSpt==1) //help command
{
displayHelp(); //display help
}
else if((strcmp(split[0],"clear")==0||strcmp(split[0],"cls")==0)&&cmdSpt==1) //clear screen command
{
system("cls"); //clear screen
}
else if((strcmp(split[0],"exit")==0||strcmp(split[0],"end")==0)&&cmdSpt==1) //exit command
{
printf("Exit\n"); //display exit message
}
else //invalid command
{
printf("Invalid command or incorrect command syntax, type <help> for command list and usage.\n\n");
}
if(fileA!=NULL) //close all file pointers in case they weren't closed by functions
fclose(fileA);
if(fileB!=NULL)
fclose(fileB);
if(fileTar!=NULL)
fclose(fileTar);
} while(strcmp(cmd,"exit")!=0&&strcmp(cmd,"end")!=0); //loop until exit
return 0;
}
void axtCalcMatrix(int fileCount, char *files[])
/* axtCalcMatrix - Calculate substitution matrix and make indel histogram. */
{
int *histIns, *histDel, *histPerfect, *histGapless, *histT, *histQ;
int maxInDel = optionInt("maxInsert", 21);
static int matrix[4][4];
static char bestGapless[256], bestPerfect[256];
int i, j, total = 0;
double scale;
int fileIx;
struct axt *axt;
static int trans[4] = {A_BASE_VAL, C_BASE_VAL, G_BASE_VAL, T_BASE_VAL};
static char *bases[4] = {"A", "C", "G", "T"};
int totalT = 0, totalMatch = 0, totalMismatch = 0,
tGapStart = 0, tGapExt=0, qGapStart = 0, qGapExt = 0;
AllocArray(histIns, maxInDel+1);
AllocArray(histDel, maxInDel+1);
AllocArray(histPerfect, maxPerfect+1);
AllocArray(histGapless, maxPerfect+1);
AllocArray(histT, maxInDel+1);
AllocArray(histQ, maxInDel+1);
for (fileIx = 0; fileIx < fileCount; ++fileIx)
{
char *fileName = files[fileIx];
struct lineFile *lf = lineFileOpen(fileName, TRUE);
while ((axt = axtRead(lf)) != NULL)
{
totalT += axt->tEnd - axt->tStart;
addMatrix(matrix, axt->tSym, axt->qSym, axt->symCount);
addInsert(histIns, maxInDel, axt->tSym, axt->symCount,
&tGapStart, &tGapExt);
addInsert(histDel, maxInDel, axt->qSym, axt->symCount,
&qGapStart, &qGapExt);
addPerfect(axt, histPerfect, maxPerfect,
axt->qSym, axt->tSym, axt->symCount, bestPerfect);
addGapless(axt, histGapless, maxPerfect,
axt->qSym, axt->tSym, axt->symCount, bestGapless);
axtFree(&axt);
}
lineFileClose(&lf);
}
printf(" ");
for (i=0; i<4; ++i)
printf("%5s ", bases[i]);
printf("\n");
for (i=0; i<4; ++i)
{
for (j=0; j<4; ++j)
{
int one = matrix[i][j];
total += matrix[i][j];
if (i == j)
totalMatch += one;
else
totalMismatch += one;
}
}
scale = 1.0 / total;
for (i=0; i<4; ++i)
{
int it = trans[i];
printf(" %s", bases[i]);
for (j=0; j<4; ++j)
{
int jt = trans[j];
printf(" %5.4f", matrix[it][jt] * scale);
}
printf("\n");
}
printf("\n");
for (i=1; i<21; ++i)
{
if (i == 20)
printf(">=");
printf("%2d %6.4f%% %6.4f%%\n", i, 100.0*histIns[i]/totalT,
100.0*histDel[i]/totalT);
}
#ifdef OLD
for (i=0; i<100; i += 10)
{
int delSum = 0, insSum=0, perfectSum = 0, perfectBaseSum = 0;
for (j=0; j<10; ++j)
{
int ix = i+j;
insSum += histIns[ix];
delSum += histDel[ix];
perfectSum += histPerfect[ix];
perfectBaseSum += histPerfect[ix] * ix;
}
printf("%2d to %2d: %6.4f%% %6.4f%% %6d %7d\n", i, i+9,
100.0*insSum/totalT, 100.0*delSum/totalT, perfectSum, perfectBaseSum);
}
for (i=0; i<1000; i += 100)
{
int delSum = 0, insSum=0, perfectSum = 0, perfectBaseSum = 0;
for (j=0; j<100; ++j)
{
int ix = i+j;
int ins = histIns[ix];
int del = histDel[ix];
both = ins + del;
insSum += ins;
delSum += del;
perfectSum += histPerfect[ix];
perfectBaseSum += histPerfect[ix] * ix;
}
printf("%3d to %3d: %6.4f%% %6.4f%% %6d %7d\n", i, i+99,
100.0*insSum/totalT, 100.0*delSum/totalT, perfectSum, perfectBaseSum);
}
printf(">1000 %6.4f%% %6.4f%% %6d %7d\n",
100.0*histIns[1000]/totalT, 100.0*histDel[1000]/totalT, histPerfect[1000],
histPerfect[1000]*1000);
both = histIns[1000] + histDel[1000];
#endif /* OLD */
printf("\n");
printMedianEtc("perfect", histPerfect, maxPerfect, bestPerfect);
printMedianEtc("gapless", histGapless, maxPerfect, bestGapless);
printf("\n");
printLabeledPercent("totalT: ", totalT, totalT);
printLabeledPercent("matches: ", totalMatch, totalT);
printLabeledPercent("mismatches:", totalMismatch, totalT);
printLabeledPercent("tGapStart: ", tGapStart, totalT);
printLabeledPercent("qGapStart: ", qGapStart, totalT);
printLabeledPercent("tGapExt: ", tGapExt, totalT);
printLabeledPercent("qGapExt: ", qGapExt, totalT);
printLabeledPercent("baseId: ", totalMatch, totalMatch+totalMismatch);
}
void ofxGuiPanel::buildFromXml()
{
int numberOfTags = mGlobals->mXml.getNumTags("OBJECT");
if(numberOfTags > 0)
{
for(int i = 0; i < numberOfTags; i++)
{
mGlobals->mXml.pushTag("OBJECT", i);
int id = mGlobals->mXml.getValue("ID", 0);
string type = mGlobals->mXml.getValue("TYPE", "");
string name = mGlobals->mXml.getValue("NAME", "");
int width = mGlobals->mXml.getValue("WIDTH", 0);
int height = mGlobals->mXml.getValue("HEIGHT", 0);
int display = mGlobals->mXml.getValue("DISPLAY", 0);
int steps = mGlobals->mXml.getValue("STEPS", 0);
int mode = mGlobals->mXml.getValue("MODE", 0);
string image = mGlobals->mXml.getValue("IMAGE", "");
if(type == "SLIDER")
{
float min = mGlobals->mXml.getValue("MIN", 0.0f);
float max = mGlobals->mXml.getValue("MAX", 0.0f);
float value = mGlobals->mXml.getValue("VALUE", 0.0f);
ofxGuiSlider* slider = addSlider(id, name, width, height, min, max, value, display, steps);
slider->buildFromXml();
}
else if(type == "XYPAD")
{
float minx = mGlobals->mXml.getValue("MIN_X", 0.0f);
float miny = mGlobals->mXml.getValue("MIN_Y", 0.0f);
float maxx = mGlobals->mXml.getValue("MAX_X", 0.0f);
float maxy = mGlobals->mXml.getValue("MAX_Y", 0.0f);
float valuex = mGlobals->mXml.getValue("VALUE_X", 0.0f);
float valuey = mGlobals->mXml.getValue("VALUE_Y", 0.0f);
ofxPoint2f min = ofxPoint2f(minx, miny);
ofxPoint2f max = ofxPoint2f(maxx, maxy);
ofxPoint2f value = ofxPoint2f(valuex, valuey);
ofxGuiXYPad* xypad = addXYPad(id, name, width, height, min, max, value, display, steps);
xypad->buildFromXml();
}
else if(type == "POINTS")
{
float minx = mGlobals->mXml.getValue("MIN_X", 0.0f);
float miny = mGlobals->mXml.getValue("MIN_Y", 0.0f);
float maxx = mGlobals->mXml.getValue("MAX_X", 0.0f);
float maxy = mGlobals->mXml.getValue("MAX_Y", 0.0f);
float valuex = mGlobals->mXml.getValue("VALUE_X", 0.0f);
float valuey = mGlobals->mXml.getValue("VALUE_Y", 0.0f);
ofxPoint2f min = ofxPoint2f(minx, miny);
ofxPoint2f max = ofxPoint2f(maxx, maxy);
ofxPoint2f value = ofxPoint2f(valuex, valuey);
ofxGuiPoints* points = addPoints(id, name, width, height, min, max, value, display, steps);
points->buildFromXml();
}
else if(type == "BUTTON")
{
bool value = mGlobals->mXml.getValue("VALUE", 0);
ofxGuiButton* button = addButton(id, name, width, height, value, mode, image);
button->buildFromXml();
}
else if(type == "FILES")
{
string subPath = mGlobals->mXml.getValue("SUBPATH", "");
string suffix = mGlobals->mXml.getValue("SUFFIX", "");
ofxGuiFiles* files = addFiles(id, name, width, height, mGlobals->mXmlfile, subPath, suffix);
files->buildFromXml();
}
else if(type == "COLOR")
{
ofRGBA value = ofRGBA(mGlobals->mXml.getValue("VALUE", "FFFFFFFF"));
ofxGuiColor* color = addColor(id, name, width, height, value, mode);
color->buildFromXml();
}
else if(type == "MATRIX")
{
int xGrid = mGlobals->mXml.getValue("XGRID", 0);
int yGrid = mGlobals->mXml.getValue("YGRID", 0);
int value = mGlobals->mXml.getValue("VALUE", 0);
int spacing = mGlobals->mXml.getValue("SPACING", 0);
ofxGuiMatrix* matrix = addMatrix(id, name, width, height, xGrid, yGrid, value, mode, spacing);
matrix->buildFromXml();
}
else if(type == "SCOPE")
{
int length = mGlobals->mXml.getValue("LENGTH", 0);
float valuex = mGlobals->mXml.getValue("VALUE_X", 0.0f);
float valuey = mGlobals->mXml.getValue("VALUE_Y", 0.0f);
ofxPoint2f value = ofxPoint2f(valuex, valuey);
ofxGuiScope* scope = addScope(id, name, width, height, length, value, mode);
scope->buildFromXml();
}
else if(type == "KNOB")
{
float min = mGlobals->mXml.getValue("MIN", 0.0f);
float max = mGlobals->mXml.getValue("MAX", 0.0f);
float value = mGlobals->mXml.getValue("VALUE", 0.0f);
ofxGuiKnob* knob = addKnob(id, name, width, height, min, max, value, display, steps);
knob->buildFromXml();
}
mGlobals->mXml.popTag();
}
}
}
SkColorSpaceXform_A2B::SkColorSpaceXform_A2B(SkColorSpace_A2B* srcSpace,
SkColorSpace_XYZ* dstSpace)
: fLinearDstGamma(kLinear_SkGammaNamed == dstSpace->gammaNamed()) {
#if (SkCSXformPrintfDefined)
static const char* debugGammaNamed[4] = {
"Linear", "SRGB", "2.2", "NonStandard"
};
static const char* debugGammas[5] = {
"None", "Named", "Value", "Table", "Param"
};
#endif
int currentChannels;
switch (srcSpace->iccType()) {
case SkColorSpace_Base::kRGB_ICCTypeFlag:
currentChannels = 3;
break;
case SkColorSpace_Base::kCMYK_ICCTypeFlag:
currentChannels = 4;
// CMYK images from JPEGs (the only format that supports it) are actually
// inverted CMYK, so we need to invert every channel.
// TransferFn is y = -x + 1 for x < 1.f, otherwise 0x + 0, ie y = 1 - x for x in [0,1]
this->addTransferFns({1.f, 0.f, 0.f, -1.f, 1.f, 0.f, 1.f}, 4);
break;
default:
currentChannels = 0;
SkASSERT(false);
}
// add in all input color space -> PCS xforms
for (int i = 0; i < srcSpace->count(); ++i) {
const SkColorSpace_A2B::Element& e = srcSpace->element(i);
SkASSERT(e.inputChannels() == currentChannels);
currentChannels = e.outputChannels();
switch (e.type()) {
case SkColorSpace_A2B::Element::Type::kGammaNamed:
if (kLinear_SkGammaNamed == e.gammaNamed()) {
break;
}
// take the fast path for 3-channel named gammas
if (3 == currentChannels) {
if (k2Dot2Curve_SkGammaNamed == e.gammaNamed()) {
SkCSXformPrintf("fast path from 2.2\n");
fElementsPipeline.append(SkRasterPipeline::from_2dot2);
break;
} else if (kSRGB_SkGammaNamed == e.gammaNamed()) {
SkCSXformPrintf("fast path from sRGB\n");
// Images should always start the pipeline as unpremul
fElementsPipeline.append_from_srgb(kUnpremul_SkAlphaType);
break;
}
}
SkCSXformPrintf("Gamma stage added: %s\n", debugGammaNamed[(int)e.gammaNamed()]);
SkColorSpaceTransferFn fn;
SkAssertResult(named_to_parametric(&fn, e.gammaNamed()));
this->addTransferFns(fn, currentChannels);
break;
case SkColorSpace_A2B::Element::Type::kGammas: {
const SkGammas& gammas = e.gammas();
SkCSXformPrintf("Gamma stage added:");
for (int channel = 0; channel < gammas.channels(); ++channel) {
SkCSXformPrintf(" %s", debugGammas[(int)gammas.type(channel)]);
}
SkCSXformPrintf("\n");
bool gammaNeedsRef = false;
for (int channel = 0; channel < gammas.channels(); ++channel) {
if (SkGammas::Type::kTable_Type == gammas.type(channel)) {
SkTableTransferFn table = {
gammas.table(channel),
gammas.data(channel).fTable.fSize,
};
this->addTableFn(table, channel);
gammaNeedsRef = true;
} else {
SkColorSpaceTransferFn fn;
SkAssertResult(gamma_to_parametric(&fn, gammas, channel));
this->addTransferFn(fn, channel);
}
}
if (gammaNeedsRef) {
fGammaRefs.push_back(sk_ref_sp(&gammas));
}
break;
}
case SkColorSpace_A2B::Element::Type::kCLUT:
SkCSXformPrintf("CLUT (%d -> %d) stage added\n", e.colorLUT().inputChannels(),
e.colorLUT().outputChannels());
fCLUTs.push_back(sk_ref_sp(&e.colorLUT()));
fElementsPipeline.append(SkRasterPipeline::color_lookup_table,
fCLUTs.back().get());
break;
case SkColorSpace_A2B::Element::Type::kMatrix:
if (!e.matrix().isIdentity()) {
SkCSXformPrintf("Matrix stage added\n");
addMatrix(e.matrix());
}
break;
}
}
// Lab PCS -> XYZ PCS
if (SkColorSpace_A2B::PCS::kLAB == srcSpace->pcs()) {
SkCSXformPrintf("Lab -> XYZ element added\n");
fElementsPipeline.append(SkRasterPipeline::lab_to_xyz);
}
// we should now be in XYZ PCS
SkASSERT(3 == currentChannels);
// and XYZ PCS -> output color space xforms
if (!dstSpace->fromXYZD50()->isIdentity()) {
addMatrix(*dstSpace->fromXYZD50());
}
switch (dstSpace->gammaNamed()) {
case kLinear_SkGammaNamed:
// do nothing
break;
case k2Dot2Curve_SkGammaNamed:
fElementsPipeline.append(SkRasterPipeline::to_2dot2);
break;
case kSRGB_SkGammaNamed:
fElementsPipeline.append(SkRasterPipeline::to_srgb);
break;
case kNonStandard_SkGammaNamed: {
for (int channel = 0; channel < 3; ++channel) {
const SkGammas& gammas = *dstSpace->gammas();
if (SkGammas::Type::kTable_Type == gammas.type(channel)) {
static constexpr int kInvTableSize = 256;
std::vector<float> storage(kInvTableSize);
invert_table_gamma(storage.data(), nullptr, storage.size(),
gammas.table(channel),
gammas.data(channel).fTable.fSize);
SkTableTransferFn table = {
storage.data(),
(int) storage.size(),
};
fTableStorage.push_front(std::move(storage));
this->addTableFn(table, channel);
} else {
SkColorSpaceTransferFn fn;
SkAssertResult(gamma_to_parametric(&fn, gammas, channel));
this->addTransferFn(fn.invert(), channel);
}
}
}
break;
}
}
void
gaussianEstimator_Est (Matrix *xEst, Matrix *CEst, Matrix *y, Matrix *Cv, Matrix (*hfun)(Matrix m), Matrix *m_opt)
{
//printMatrix(*xEst);
//printMatrix(*CEst);system("PAUSE");
Matrix tmp = sizeOfMatrix(*m_opt);
float D = elem(tmp,0,1)+1; //printf("%f\n", D);
freeMatrix(tmp);
float w_opt = 1/D; //printf("%f\n", w_opt);
tmp = sizeOfMatrix(*xEst);
float Nx = elem(tmp,0,0); // printf("%f\n", Nx);
freeMatrix(tmp);
float d = Nx*(D-1) + 1; //printf("%f\n", d);
float w = 1/d; // printf("%f\n", w);system("PAUSE");
// Eigenvectors, Eigenvalues
tmp = sizeOfMatrix(*CEst);
int dimC = elem ( tmp, 0, 0 );
freeMatrix(tmp);
Matrix Vec = zeroMatrix(dimC, dimC);
Matrix Val = zeroMatrix(dimC, dimC);
eig ( CEst, &Vec, &Val ); //printMatrix(Vec);printMatrix(Val);system("PAUSE");
// m1 = vec*sqrtf(val)
int i;
for ( i = 0; i < dimC; ++i )
setElem(Val, i, i, sqrtf(fabs(elem(Val, i,i))));
Matrix m1 = mulMatrix(Vec, Val); //printMatrix(m1); system("PAUSE");
freeMatrix(Vec);
freeMatrix(Val);
//* rotate & scale samples: m = m1*S
Matrix m = scaledSamplePoints(m1, *m_opt); // printMatrix(m); system("PAUSE");
Matrix mxDiracs = mulScalarMatrix(1, m);
//* x = x*ones(1,d)
Matrix x = fillMatrix(*xEst, d);
// shift samples: m = m + x
tmp = addMatrix(m, x);
appMatrix(m, 0, m->height-1, 0, m->width-1, tmp, 0, tmp->height-1, 0, tmp->width-1 ) ; //printMatrix(m);
freeMatrix(tmp);
//% Predicted Measurements
//* hfun
// yPredDiracs = feval(hfun, m, [], [], t);
// yPred = w*sum(yPredDiracs, 2);
Matrix yPredDiracs = (*hfun) (m); //printMatrix(yPredDiracs );
Matrix yPredDiracsSum = sumMatrix(yPredDiracs, 2);
Matrix yPred = mulScalarMatrix(w, yPredDiracsSum);
// myDiracs = yPredDiracs-repmat(yPred, 1, d);
tmp = fillMatrix(yPred, d);
Matrix myDiracs = subMatrix(yPredDiracs, tmp);
freeMatrix(tmp);
//* CPred = w_opt*mxDiracs*mxDiracs';
// Matrix CPred = mulScalarMatrix( w_opt, mulMatrix(mxDiracs, transposeMatrix(mxDiracs)) );
// Matrix CPred = *CEst;
// Cxy = w_opt*mxDiracs*myDiracs';
Matrix tmp1 = transposeMatrix(myDiracs);
Matrix tmp2 = mulMatrix(mxDiracs, tmp1);
Matrix Cxy = mulScalarMatrix( w_opt, tmp2);
freeMatrix(tmp1);
freeMatrix(tmp2);
// Cy = w_opt*myDiracs*myDiracs'+Cv;
tmp1 = transposeMatrix(myDiracs);
tmp2 = mulMatrix(myDiracs, tmp1);
Matrix tmp3 = mulScalarMatrix( w_opt, tmp2);
Matrix Cy = addMatrix( tmp3 , *Cv );
freeMatrix(tmp1);
freeMatrix(tmp2);
freeMatrix(tmp3);
// K = Cxy / Cy;
tmp = invertCovMatrix(Cy);
Matrix K = mulMatrix( Cxy, tmp);
freeMatrix(tmp);
// I = y - yPred;
Matrix I = subMatrix( *y, yPred );
// xEst = xPred + K*I;
tmp = mulMatrix( K, I );
Matrix tmp23 = addMatrix( *xEst, tmp);
appMatrix(*xEst,0,5,0,0, tmp23,0,5,0,0);
freeMatrix(tmp);
// CEst = CPred - K*Cy*K';
tmp1 = mulMatrix(K, Cy);
tmp2 = transposeMatrix(K);
tmp3 = mulMatrix( tmp1, tmp2);
Matrix tmp24 = subMatrix(*CEst, tmp3);
appMatrix(*CEst,0,5,0,5, tmp24,0,5,0,5);
freeMatrix(tmp1);
freeMatrix(tmp2);
freeMatrix(tmp3);
freeMatrix(tmp24);
freeMatrix(m1);
freeMatrix(m);
freeMatrix(mxDiracs);
freeMatrix(x);
freeMatrix(yPredDiracs);
freeMatrix(yPredDiracsSum);//
freeMatrix(yPred);//
freeMatrix(myDiracs);
freeMatrix(Cxy);
freeMatrix(Cy);
freeMatrix(K);//
freeMatrix(I);//
freeMatrix(tmp23);
}
