/* x are the indipendent value of the polynomial equation
y are the dependent value
*/
void OrdinaryLeastSquares(matrix *x, dvector *y, dvector *coefficients)
{
/*y->size = x->row
*
* Z' = n x m => n = x->col; m = x->row
*
* Z'Z = m x n * n x m = m x m => m = x->row
*
* Z'y =
*
*
*/
matrix *x_t; /* Z' that is x transposed */
matrix *x_x_t; /* Z'*Z is the product between x and x_t */
matrix *x_x_t_i; /* x_x_t_i inverted matrix (Z' * Z')^-1 */
dvector *x_t_y; /* Z'* y = x->col */
/* transpose x to x_t*/
NewMatrix(&x_t, x->col, x->row);
MatrixTranspose(x, x_t);
/* Z'*Z */
NewMatrix(&x_x_t, x->col, x->col);
MatrixDotProduct(x_t, x, x_x_t);
/* (Z'*Z)^-1 */
initMatrix(&x_x_t_i);
MatrixInversion(x_x_t, &x_x_t_i);
/* create a vector for store the results of Z'y */
NewDVector(&x_t_y, x->col);
/* Z'y */
MatrixDVectorDotProduct(x_t, y, x_t_y);
/* final data coefficient value */
DVectorResize(&coefficients, x->col);
MatrixDVectorDotProduct(x_x_t_i, x_t_y, coefficients);
/*
for(i = 0; i < 10; i++)
printf("%f\n", coefficients->data[i]);
*/
DelDVector(&x_t_y);
DelMatrix(&x_x_t_i);
DelMatrix(&x_x_t);
DelMatrix(&x_t);
}
void test3()
{
matrix *m; /* Data matrix */
PCAMODEL *model;
int run = SIGSCIENTIFICRUN;
NewMatrix(&m, 10, 2);
m->data[0][0] = 2.2; m->data[0][1] = 3.3;
m->data[1][0] = 2.9; m->data[1][1] = 4.5;
m->data[2][0] = 4.0; m->data[2][1] = 3.5;
m->data[3][0] = 4.500; m->data[3][1] = 4.7;
m->data[4][0] = 5.1; m->data[4][1] = 6.0;
m->data[5][0] = 5.5; m->data[5][1] = 4.5;
m->data[6][0] = 6.5000; m->data[6][1] = 6.4;
m->data[7][0] = 7.2; m->data[7][1] = 6.2;
m->data[8][0] = 8.8; m->data[8][1] = 3.9;
m->data[9][0] = 10; m->data[9][1] = 6.2;
NewPCAModel(&model);
printf("Test PCA 3\n");
PCA(m, 1, 5, model, &run);
PrintPCA(model);
DelPCAModel(&model);
DelMatrix(&m);
}
void AMatrix_base::MakeArrayBigger(const int RowIndex, const int ColIndex) {
//-------------------------------------------------------------
// if m_Array is big enough, return true.
// if m_Array is too small, make it bigger and return false.
//-------------------------------------------------------------
// make an array that's big enough (don't let either dimension shrink)
int NumRows = Max(m_NumRows, RowIndex+1);
int NumCols = Max(m_NumCols, ColIndex+1);
AMatrix_base NewMatrix(NumRows, NumCols);
// copy old array into new array
NewMatrix.SlowCopy(*this);
// free the old array
DeAllocate();
// save new array in place of old array
m_Array = NewMatrix.m_Array;
m_ColumnFlags = NewMatrix.m_ColumnFlags;
m_NumRows = NewMatrix.m_NumRows;
m_NumCols = NewMatrix.m_NumCols;
// pretend new array has been freed
// (so that new array isn't freed when leaving this routine)
NewMatrix.m_Array = NULL;
NewMatrix.m_ColumnFlags = NULL;
NewMatrix.m_NumRows = 0;
NewMatrix.m_NumCols = 0;
}
void test1()
{
matrix *mx, *u, *v;
dvector *w;
NewMatrix(&mx, 4, 5);
MatrixSet(mx, 0.f);
mx->data[0][0] = 1; mx->data[0][4] = 2;
mx->data[1][2] = 3;
mx->data[3][1] = 4;
PrintMatrix(mx);
initMatrix(&u);
initMatrix(&v);
initDVector(&w);
svd(mx, &u, &w, &v);
puts("U");
PrintMatrix(u);
puts("W");
PrintDVector(w);
puts("V");
PrintMatrix(v);
DelMatrix(&u);
DelMatrix(&v);
DelDVector(&w);
DelMatrix(&mx);
}
void AminoacidData::FillAminoacidMatrixFromDNA(const NucleotideData *dnaData, GeneticCode *code){
//first we need to convert the nucleotide data to codons, and then translate the codons to AA's
//codons are ordered AAA, AAC, AAG, AAT, ACA, ... TTT
short pos1, pos2, pos3;
nChar = dnaData->NChar()/3;
nTax = dnaData->NTax();
if(dnaData->NChar() % 3 != 0) throw ErrorException("Codon to Aminoacid translation specified, but number of nucleotides not divisible by 3!");
NewMatrix(nTax, nChar);
//this will just map from the bitwise format to the index format (A, C, G, T = 0, 1, 2, 3)
//partial ambiguity is mapped to total ambiguity currently
short bitwiseToIndexFormat[16] = {15,0,1,15,2,15,15,15,3,15,15,15,15,15,15,15};
int tax=0, thisCodonNum;
for(int tax=0;tax<NTax();tax++){
bool firstAmbig = true;
for(int cod=0;cod<nChar;cod++){
short p1 = dnaData->Matrix(tax, cod*3);
short p2 = dnaData->Matrix(tax, cod*3+1);
short p3 = dnaData->Matrix(tax, cod*3+2);
pos1 = bitwiseToIndexFormat[p1];
pos2 = bitwiseToIndexFormat[p2];
pos3 = bitwiseToIndexFormat[p3];
thisCodonNum=(pos1)*16 + (pos2)*4 + pos3;
if(pos1==15||pos2==15||pos3==15){//check for gaps
if(pos1+pos2+pos3 != 45){
//warn about gaps or ambiguity in codons
if(firstAmbig){
outman.UserMessageNoCR("Gaps or ambiguity codes found within codon for taxon %s.\n\tAminoacids coded as missing for that taxon: ", dnaData->TaxonLabel(tax));
firstAmbig = false;
}
outman.UserMessageNoCR("%d ", cod+1);
}
thisCodonNum=64;
}
char prot;
//note that a return code of 20 from the codon lookup indicates a stop codon, but a protein code of 20 generally means total ambiguity
if(thisCodonNum != 64){
prot = code->CodonLookup(thisCodonNum);
if(prot == 20){
string c;
char b[4]={'A','C','G','T'};
c += b[pos1];
c += b[pos2];
c += b[pos3];
throw ErrorException("stop codon %s found at codon site %d (nuc site %d) in taxon %s. Bailing out.", c.c_str(), cod+1, cod*3+1, dnaData->TaxonLabel(tax));
}
}
else prot = 20;
matrix[tax][cod] = prot;
}
if(firstAmbig == false) outman.UserMessage("");
}
}
void AddArrayMatrix(array **t, size_t row, size_t col)
{
if((*t)->order > 0){
/*if((*t)->m[(*t)->order-1]->row != row){
fprintf(stderr, "Error while appending matrix to array! Object size differ: matrix: %u; array: %u", (unsigned int)row, (unsigned int)(*t)->m[(*t)->order-1]->row);
abort();
}
else{*/
(*t)->order += 1;
(*t)->m = xrealloc((*t)->m, sizeof(matrix*)*(*t)->order);
NewMatrix(&(*t)->m[(*t)->order-1], row, col);
/* }*/
}
else{
(*t)->order = 1;
(*t)->m = xmalloc(sizeof(matrix*)*1);
NewMatrix(&(*t)->m[0], row, col);
}
}
void ArrayAppendMatrix(array **tdst, matrix *msrc)
{
if((*tdst)->order > 0){
if((*tdst)->m[(*tdst)->order-1]->row != msrc->row){
fprintf(stderr, "Error while appending matrix to array! Object size differ: matrix: %u; array: %u", (unsigned int)msrc->row, (unsigned int)(*tdst)->m[(*tdst)->order-1]->row);
abort();
}
else{
(*tdst)->order += 1;
(*tdst)->m = xrealloc((*tdst)->m, sizeof(matrix*)*(*tdst)->order);
NewMatrix(&(*tdst)->m[(*tdst)->order-1], msrc->row, msrc->col);
MatrixCopy(msrc, &(*tdst)->m[(*tdst)->order-1]);
}
}
else{
(*tdst)->order = 1;
(*tdst)->m = xmalloc(sizeof(matrix*)*1);
NewMatrix(&(*tdst)->m[0], msrc->row, msrc->col);
MatrixCopy(msrc, &(*tdst)->m[0]);
}
}
void CallFunction(FunctionCall fc)
{
int function = GetFunction(fc->function);
switch (function)
{
case VAR : NewVariable(fc); break;
case NMX : NewMatrix(fc); break;
case ADD : Addition(fc); break;
case SUB : Substraction(fc); break;
case MUL : Multiplication(fc); break;
case MSC : Scalar_Mult(fc); break;
case EXP : Exponentiation(fc); break;
case TRA : Transpose(fc); break;
case DET : Determinant(fc); break;
case DLU : Decomposition(fc); break;
case SOL : Solve(fc); break;
case INV : Inversion(fc); break;
case RNK : Rank(fc); break;
case DSP : Display(fc); break;
case NOF : // default
default :
{
if (GetFunction(fc->name)==SPT) SpeedTest(fc);
else if (IndexVariable(fc->function)!=-1) NewVariable(fc);
else if (IndexMatrix(fc->function)!=-1) NewMatrix(fc);
else
{
printf("\t%s : Function Not Implemented\n", fc->function);
fni++;
}
break;
}
}
if (function!=NOF && function !=VAR) fni = 0;
}
void NewArrayMatrix(array **t, size_t order, size_t row, size_t col)
{
if((*t)->order != 0){
if(order < (*t)->order){
NewMatrix(&(*t)->m[order], row, col);
}
else{
fprintf(stderr, "Error! Order not in range order. order: %u > ordersize: %u\n", (unsigned int)order, (unsigned int)(*t)->order);
}
}
else{
fprintf(stderr, "Error! Order Array not Defined! Please create Array with NewArray(array **t, size_t order);\n");
abort();
}
}
void ArrayCopy(array* asrc, array** adst)
{
size_t i, j, k;
if((*adst)->m == NULL){
(*adst)->order = asrc->order;
(*adst)->m = xmalloc(sizeof(matrix*)*asrc->order);
for(k = 0; k < asrc->order; k++){
NewMatrix(&((*adst)->m[k]), asrc->m[k]->row, asrc->m[k]->col);
}
}
else{
if(asrc->order != (*adst)->order){
/* resize the order */
(*adst)->m = xrealloc((*adst)->m, sizeof(array*)*asrc->order);
}
/*chek and resize the matrix for each order if is necessary */
for(k = 0; k < asrc->order; k++){
if(asrc->m[k]->row != (*adst)->m[k]->row || asrc->m[k]->col != (*adst)->m[k]->col){
(*adst)->m[k]->row = asrc->m[k]->row;
(*adst)->m[k]->col = asrc->m[k]->col;
(*adst)->m[k]->data = xrealloc((*adst)->m[k]->data, sizeof(double*)*asrc->m[k]->row);
for(i = 0; i < asrc->m[k]->row; i++){
(*adst)->m[k]->data[i] = xrealloc((*adst)->m[k]->data[i], sizeof(double)*asrc->m[k]->col);
}
}
}
}
/*copy the data...*/
for(k = 0; k < asrc->order; k++){
for(i = 0; i < asrc->m[k]->row; i++){
for(j = 0; j < asrc->m[k]->col; j++){
setArrayValue((*adst), k, i, j, getArrayValue(asrc, k, i, j));
}
}
}
}
void test1()
{
matrix *dmx;
NewMatrix(&dmx, 4, 4);
G *graph;
dmx->data[0][1] = dmx->data[1][0] = 0.3;
dmx->data[0][2] = dmx->data[2][0] = 0.4;
dmx->data[0][3] = dmx->data[3][0] = 0.7;
dmx->data[1][2] = dmx->data[2][1] = 0.9;
dmx->data[1][3] = dmx->data[3][1] = 0.2;
dmx->data[2][3] = dmx->data[3][2] = 0.1;
PrintMatrix(dmx);
NewGraph(&graph);
GenerateAdjMX(dmx, 0.8, &graph);
PrintGraph(graph);
DelMatrix(&dmx);
DelGraph(&graph);
}
void MpView::NewDataSet (int dataset_index, int graph_index)
{
if (dataset_index < 0) return;
for (MpViewGraphMap::iterator i = Graphs.begin(); i != Graphs.end(); ++i) {
int grf = i->first;
if (dataset_index == i->second.iset
&& (graph_index < 0 || graph_index == grf)) {
MpViewGraphData *G = &GD(grf);
if (DataSetExists(dataset_index)) {
switch (G->DS().GetDataType()) {
case MpViewDataSet::a_EmptySet:
// nothing to do
break;
case MpViewDataSet::a_Matrix:
NewMatrix(G);
break;
case MpViewDataSet::a_Matrix3d:
NewVolume(G);
break;
case MpViewDataSet::a_ComplexMatrix:
NewComplexMatrix(G,G->DS().C);
break;
case MpViewDataSet::a_Scene:
NewScene(G);
break;
case MpViewDataSet::a_XYZSet:
NewXYZSet(G);
break;
case MpViewDataSet::a_Image:
cerr<<"MpView::NewDataSet: IMAGE - can't happen"<<endl;
break;
default:
cerr<<"MpView::NewDataSet: found illegal data set type" << endl;
break;
}
} else {
// data set doesn't exist (e.g. was deleted) -> unlink
G->iset = -1;
}
}
}
}
void test6()
{
matrix *m;
PCAMODEL *model;
NewMatrix(&m, 3,3);
m->data[0][0] = 7; m->data[0][1] = 4; m->data[0][2] = 4;
m->data[1][0] = 4; m->data[1][1] = 4; m->data[1][2] = 4;
m->data[2][0] = 1; m->data[2][1] = 4; m->data[2][2] = 7;
PrintMatrix(m);
NewPCAModel(&model);
PCA(m, 0, 5, model, NULL);
PrintPCA(model);
DelPCAModel(&model);
DelMatrix(&m);
}
void test4()
{
matrix *m; /* Data matrix */
PCAMODEL *model;
int run = SIGSCIENTIFICRUN;
NewMatrix(&m, 3, 2);
setMatrixValue(m, 0, 0, 0.424264); setMatrixValue(m, 0, 1, 0.565685);
setMatrixValue(m, 1, 0, 0.565685); setMatrixValue(m, 1, 1, 0.424264);
setMatrixValue(m, 2, 0, 0.707101); setMatrixValue(m, 2, 1, 0.707101);
NewPCAModel(&model);
printf("Test PCA 4\n");
PCA(m, 1, 5, model, &run);
PrintPCA(model);
DelPCAModel(&model);
DelMatrix(&m);
}
void test5()
{
matrix *m; /* Data matrix */
PCAMODEL *model;
NewMatrix(&m, 3, 4);
setMatrixValue(m, 0, 0, 0.424264); setMatrixValue(m, 0, 1, 0.565685); setMatrixValue(m, 0, 2, 0.565685); setMatrixValue(m, 0, 3, 0.424264);
setMatrixValue(m, 1, 0, 0.565685); setMatrixValue(m, 1, 1, 0.424264); setMatrixValue(m, 1, 2, 0.424264); setMatrixValue(m, 1, 3, 0.565685);
setMatrixValue(m, 2, 0, 0.707101); setMatrixValue(m, 2, 1, 0.707101); setMatrixValue(m, 2, 2, 0.707101); setMatrixValue(m, 2, 3, 0.707101);
NewPCAModel(&model);
printf("Test PCA 5\n");
PCA(m, 1, 5, model, NULL);
PrintPCA(model);
DelPCAModel(&model);
DelMatrix(&m);
}
void test7()
{
matrix *m;
PCAMODEL *model;
int nobj = 200;
int nvars = 32000;
NewMatrix(&m, nobj, nvars);
srand(nobj);
for(size_t i = 0; i < nobj; i++){
for(size_t j = 0; j < nvars; j++){
m->data[i][j] = randDouble(0,20);
}
}
NewPCAModel(&model);
PCA(m, 1, 5, model, NULL);
DelPCAModel(&model);
DelMatrix(&m);
}
void test2()
{
size_t i;
matrix *m; /* Data matrix */
dvector *R;
int run = SIGSCIENTIFICSTOP;
NewMatrix(&m, 14, 7);
m->data[0][0] = 4.0000; m->data[0][1] = 4.0000; m->data[0][2] = 1.0000; m->data[0][3] = 84.1400; m->data[0][4] = 1.0500; m->data[0][5] = 235.1500; m->data[0][6] = 357.1500;
m->data[1][0] = 5.0000; m->data[1][1] = 5.0000; m->data[1][2] = 1.0000; m->data[1][3] = 79.1000; m->data[1][4] = 0.9780; m->data[1][5] = 1.5090; m->data[1][6] = 231.0000;
m->data[2][0] = 4.0000; m->data[2][1] = 5.0000; m->data[2][2] = 1.0000; m->data[2][3] = 67.0900; m->data[2][4] = 0.9700; m->data[2][5] = 249.0000; m->data[2][6] = 403.0000;
m->data[3][0] = 4.0000; m->data[3][1] = 4.0000; m->data[3][2] = 1.0000; m->data[3][3] = 68.0700; m->data[3][4] = 0.9360; m->data[3][5] = 187.3500; m->data[3][6] = 304.5500;
m->data[4][0] = 3.0000; m->data[4][1] = 4.0000; m->data[4][2] = 2.0000; m->data[4][3] = 68.0800; m->data[4][4] = 1.0300; m->data[4][5] = 363.0000; m->data[4][6] = 529.0000;
m->data[5][0] = 9.0000; m->data[5][1] = 7.0000; m->data[5][2] = 1.0000; m->data[5][3] = 129.1600; m->data[5][4] = 1.0900; m->data[5][5] = 258.0000; m->data[5][6] = 510.0000;
m->data[6][0] = 10.0000; m->data[6][1] = 8.0000; m->data[6][2] = 0.0000; m->data[6][3] = 128.1600; m->data[6][4] = 1.1500; m->data[6][5] = 352.0000; m->data[6][6] = 491.0000;
m->data[7][0] = 6.0000; m->data[7][1] = 6.0000; m->data[7][2] = 0.0000; m->data[7][3] = 78.1118; m->data[7][4] = 0.8765; m->data[7][5] = 278.6400; m->data[7][6] = 353.3000;
m->data[8][0] = 16.0000; m->data[8][1] = 10.0000; m->data[8][2] = 0.0000; m->data[8][3] = 202.2550; m->data[8][4] = 1.2710; m->data[8][5] = 429.1500; m->data[8][6] = 666.6500;
m->data[9][0] = 6.0000; m->data[9][1] = 12.0000; m->data[9][2] = 0.0000; m->data[9][3] = 84.1600; m->data[9][4] = 0.7800; m->data[9][5] = 279.0000; m->data[9][6] = 354.0000;
m->data[10][0] = 4.0000; m->data[10][1] = 8.0000; m->data[10][2] = 1.0000; m->data[10][3] = 72.1100; m->data[10][4] = 0.8900; m->data[10][5] = 164.5000; m->data[10][6] = 339.0000;
m->data[11][0] = 4.0000; m->data[11][1] = 9.0000; m->data[11][2] = 1.0000; m->data[11][3] = 71.1100; m->data[11][4] = 0.8660; m->data[11][5] = 210.0000; m->data[11][6] = 360.0000;
m->data[12][0] = 5.0000; m->data[12][1] = 11.0000; m->data[12][2] = 1.0000; m->data[12][3] = 85.1500; m->data[12][4] = 0.8620; m->data[12][5] = 266.0000; m->data[12][6] = 379.0000;
m->data[13][0] = 5.0000; m->data[13][1] = 10.0000; m->data[13][2] = 1.0000; m->data[13][3] = 86.1300; m->data[13][4] = 0.8800; m->data[13][5] = 228.0000; m->data[13][6] = 361.0000;
puts("Test 2");
initDVector(&R);
PCARankValidation(m, 5, 1, 3, 20, &R, &run);
puts("-----------------");
puts("PC\t R^2");
for(i = 0; i < R->size; i++)
printf("%zu\t%f\n", i+1, getDVectorValue(R, i));
puts("-----------------");
DelDVector(&R);
DelMatrix(&m);
}
void test1()
{
matrix *m; /* Data matrix */
PCAMODEL *model;
int run = SIGSCIENTIFICRUN;
NewMatrix(&m, 14, 7);
m->data[0][0] = 4.0000; m->data[0][1] = 4.0000; m->data[0][2] = 1.0000; m->data[0][3] = 84.1400; m->data[0][4] = 1.0500; m->data[0][5] = 235.1500; m->data[0][6] = 357.1500;
m->data[1][0] = 5.0000; m->data[1][1] = 5.0000; m->data[1][2] = 1.0000; m->data[1][3] = 79.1000; m->data[1][4] = 0.9780; m->data[1][5] = 1.5090; m->data[1][6] = 231.0000;
m->data[2][0] = 4.0000; m->data[2][1] = 5.0000; m->data[2][2] = 1.0000; m->data[2][3] = 67.0900; m->data[2][4] = 0.9700; m->data[2][5] = 249.0000; m->data[2][6] = 403.0000;
m->data[3][0] = 4.0000; m->data[3][1] = 4.0000; m->data[3][2] = 1.0000; m->data[3][3] = 68.0700; m->data[3][4] = 0.9360; m->data[3][5] = 187.3500; m->data[3][6] = 304.5500;
m->data[4][0] = 3.0000; m->data[4][1] = 4.0000; m->data[4][2] = 2.0000; m->data[4][3] = 68.0800; m->data[4][4] = 1.0300; m->data[4][5] = 363.0000; m->data[4][6] = 529.0000;
m->data[5][0] = 9.0000; m->data[5][1] = 7.0000; m->data[5][2] = 1.0000; m->data[5][3] = 129.1600; m->data[5][4] = 1.0900; m->data[5][5] = 258.0000; m->data[5][6] = 510.0000;
m->data[6][0] = 10.0000; m->data[6][1] = 8.0000; m->data[6][2] = 0.0000; m->data[6][3] = 128.1600; m->data[6][4] = 1.1500; m->data[6][5] = 352.0000; m->data[6][6] = 491.0000;
m->data[7][0] = 6.0000; m->data[7][1] = 6.0000; m->data[7][2] = 0.0000; m->data[7][3] = 78.1118; m->data[7][4] = 0.8765; m->data[7][5] = 278.6400; m->data[7][6] = 353.3000;
m->data[8][0] = 16.0000; m->data[8][1] = 10.0000; m->data[8][2] = 0.0000; m->data[8][3] = 202.2550; m->data[8][4] = 1.2710; m->data[8][5] = 429.1500; m->data[8][6] = 666.6500;
m->data[9][0] = 6.0000; m->data[9][1] = 12.0000; m->data[9][2] = 0.0000; m->data[9][3] = 84.1600; m->data[9][4] = 0.7800; m->data[9][5] = 279.0000; m->data[9][6] = 354.0000;
m->data[10][0] = 4.0000; m->data[10][1] = 8.0000; m->data[10][2] = 1.0000; m->data[10][3] = 72.1100; m->data[10][4] = 0.8900; m->data[10][5] = 164.5000; m->data[10][6] = 339.0000;
m->data[11][0] = 4.0000; m->data[11][1] = 9.0000; m->data[11][2] = 1.0000; m->data[11][3] = 71.1100; m->data[11][4] = 0.8660; m->data[11][5] = 210.0000; m->data[11][6] = 360.0000;
m->data[12][0] = 5.0000; m->data[12][1] = 11.0000; m->data[12][2] = 1.0000; m->data[12][3] = 85.1500; m->data[12][4] = 0.8620; m->data[12][5] = 266.0000; m->data[12][6] = 379.0000;
m->data[13][0] = 5.0000; m->data[13][1] = 10.0000; m->data[13][2] = 1.0000; m->data[13][3] = 86.1300; m->data[13][4] = 0.8800; m->data[13][5] = 228.0000; m->data[13][6] = 361.0000;
NewPCAModel(&model);
printf("Test PCA 1\n");
PCA(m, 1, 5, model, &run);
PrintPCA(model);
DelPCAModel(&model);
DelMatrix(&m);
}
/* last column must be an integer column which define the classes */
void LDA(matrix *mx, uivector *y, LDAMODEL *lda)
{
size_t i, j, l, k, cc, imin, imax;
array *classes;
array *S;
matrix *X, *X_T, *Sb, *Sw, *InvSw_Sb;
dvector *mutot;
dvector *classmu;
dvector *evect_, *ldfeature;
matrix *covmx;
lda->nclass = 0;
imin = imax = y->data[0];
for(i = 1; i < y->size; i++){
if(y->data[i] > imax){
imax = y->data[i];
}
if(y->data[i] < imin){
imin = y->data[i];
}
}
/* get the number of classes */
if(imin == 0){
lda->class_start = 0;
lda->nclass = imax + 1;
}
else{
lda->class_start = 1;
lda->nclass = imax;
}
/*printf("nclass %d\n", (int)lda->nclass);*/
/* Copy data */
NewMatrix(&X, mx->row, mx->col);
MatrixCopy(mx, &X);
MatrixCheck(X);
/*
for(j = 0; j < mx->col-1; j++){
for(i = 0; i < mx->row; i++){
X->data[i][j] = mx->data[i][j];
}
}
*/
/*create classes of objects */
NewArray(&classes, lda->nclass);
UIVectorResize(&lda->classid, mx->row);
j = 0;
if(imin == 0){
for(k = 0; k < lda->nclass; k++){
cc = 0;
for(i = 0; i < X->row; i++){
if(y->data[i] == k)
cc++;
else
continue;
}
NewArrayMatrix(&classes, k, cc, X->col);
cc = 0;
for(i = 0; i < X->row; i++){
if(y->data[i] == k){
for(l = 0; l < X->col; l++){
classes->m[k]->data[cc][l] = X->data[i][l];
}
lda->classid->data[j] = i;
j++;
cc++;
}
else{
continue;
}
}
}
}
else{
for(k = 0; k < lda->nclass; k++){
cc = 0;
for(i = 0; i < X->row; i++){
if(y->data[i] == k+1)
cc++;
else
continue;
}
NewArrayMatrix(&classes, k, cc, X->col);
cc = 0;
for(i = 0; i < X->row; i++){
if(y->data[i] == k+1){
for(l = 0; l < X->col; l++){
classes->m[k]->data[cc][l] = X->data[i][l];
}
lda->classid->data[j] = i;
j++;
cc++;
}
else{
continue;
}
}
}
}
/*puts("Classes"); PrintArray(classes);*/
/* Compute the prior probability */
for(k = 0; k < classes->order; k++){
DVectorAppend(&lda->pprob, (classes->m[k]->row/(double)X->row));
}
/*
puts("Prior Probability");
PrintDVector(lda->pprob);
*/
/*Compute the mean of each class*/
for(k = 0; k < classes->order; k++){
initDVector(&classmu);
MatrixColAverage(classes->m[k], &classmu);
MatrixAppendRow(&lda->mu, classmu);
DelDVector(&classmu);
}
/*puts("Class Mu");
FindNan(lda->mu);
PrintMatrix(lda->mu);*/
/*Calculate the total mean of samples..*/
initDVector(&mutot);
MatrixColAverage(X, &mutot);
/*puts("Mu tot");
PrintDVector(mutot);*/
/*NewDVector(&mutot, mu->col);
for(k = 0; k < mu->row; k++){
for(i = 0; i < mu->col; i++){
mutot->data[i] += mu->data[k][i];
}
}
for(i = 0; i < mutot->size; i++){
mutot->data[i] /= nclasses;
}*/
/*Centering data before computing the scatter matrix*/
for(k = 0; k < classes->order; k++){
for(i = 0; i < classes->m[k]->row; i++){
for(j = 0; j < classes->m[k]->col; j++){
classes->m[k]->data[i][j] -= mutot->data[j];
}
}
}
/*
puts("Classes");
for(i = 0; i < classes->order; i++){
FindNan(classes->m[i]);
}
PrintArray(classes);
*/
/*Compute the scatter matrix
* S = nobj - 1 * covmx
*/
initArray(&S);
NewMatrix(&covmx, X->col, X->col);
for(k = 0; k < classes->order; k++){
matrix *m_T;
NewMatrix(&m_T, classes->m[k]->col, classes->m[k]->row);
MatrixTranspose(classes->m[k], m_T);
MatrixDotProduct(m_T, classes->m[k], covmx);
for(i = 0; i < covmx->row; i++){
for(j = 0; j < covmx->col; j++){
covmx->data[i][j] /= classes->m[k]->row;
}
}
ArrayAppendMatrix(&S, covmx);
MatrixSet(covmx, 0.f);
DelMatrix(&m_T);
}
/*
puts("Scatter Matrix");
for(i = 0; i < S->order; i++)
FindNan(S->m[i]);
PrintArray(S);*/
/* Compute the class scatter which represent the covariance matrix */
NewMatrix(&Sw, X->col, X->col);
for(k = 0; k < S->order; k++){
for(i = 0; i < S->m[k]->row; i++){
for(j = 0; j < S->m[k]->col; j++){
Sw->data[i][j] += (double)(classes->m[k]->row/(double)X->row) * S->m[k]->data[i][j];
}
}
}
/*
puts("Class scatter matrix Sw");
FindNan(Sw);
PrintMatrix(Sw);
*/
/*Compute the between class scatter matrix Sb*/
NewMatrix(&Sb, X->col, X->col);
for(k = 0; k < lda->mu->row; k++){ /*for each class of object*/
cc = classes->m[k]->row;
for(i = 0; i < Sb->row; i++){
for(j = 0; j < Sb->col; j++){
Sb->data[i][j] += cc * (lda->mu->data[k][i] - mutot->data[i]) * (lda->mu->data[k][j] - mutot->data[j]);
}
}
}
/*
puts("Between class scatter matrix Sb");
FindNan(Sb);
PrintMatrix(Sb); */
/* Computing the LDA projection */
/*puts("Compute Matrix Inversion");*/
MatrixInversion(Sw, &lda->inv_cov);
double ss = 0.f;
for(i = 0; i < lda->inv_cov->row; i++){
for(j = 0; j < lda->inv_cov->col; j++){
ss += square(lda->inv_cov->data[i][j]);
}
if(_isnan_(ss))
break;
}
if(FLOAT_EQ(ss, 0.f, EPSILON) || _isnan_(ss)){
/*Do SVD as pseudoinversion accordin to Liu et al. because matrix is nonsingular
*
* JUN LIU et al, Int. J. Patt. Recogn. Artif. Intell. 21, 1265 (2007). DOI: 10.1142/S0218001407005946
* EFFICIENT PSEUDOINVERSE LINEAR DISCRIMINANT ANALYSIS AND ITS NONLINEAR FORM FOR FACE RECOGNITION
*
*
* Sw`^-1 = Q * G^-1 * Q_T
* Q G AND Q_T come from SVD
*/
MatrixPseudoinversion(Sw, &lda->inv_cov);
/*
NewMatrix(&A_T, Sw->col, Sw->row);
MatrixInversion(Sw, &A_T);
NewMatrix(&A_T_Sw, A_T->row, Sw->col);
MatrixDotProduct(A_T, Sw, A_T_Sw);
initMatrix(&A_T_Sw_inv);
MatrixInversion(A_T_Sw, &A_T_Sw_inv);
MatrixDotProduct(A_T_Sw_inv, A_T, lda->inv_cov);
DelMatrix(&A_T);
DelMatrix(&A_T_Sw);
DelMatrix(&A_T_Sw_inv);
*/
}
/*puts("Inverted Covariance Matrix from Sw");
FindNan(lda->inv_cov);
PrintMatrix(lda->inv_cov);
*/
/*puts("Compute Matrix Dot Product");*/
NewMatrix(&InvSw_Sb, lda->inv_cov->row, Sb->col);
MatrixDotProduct(lda->inv_cov, Sb, InvSw_Sb);
/*puts("InvSw_Sb"); PrintMatrix(InvSw_Sb);*/
/*puts("Compute Eigenvectors");*/
EVectEval(InvSw_Sb, &lda->eval, &lda->evect);
/*EvectEval3(InvSw_Sb, InvSw_Sb->row, &lda->eval, &lda->evect);*/
/*EVectEval(InvSw_Sb, &lda->eval, &lda->evect); */
/* Calculate the new projection in the feature space
*
* and the multivariate normal distribution
*/
/* Remove centering data */
for(k = 0; k < classes->order; k++){
for(i = 0; i < classes->m[k]->row; i++){
for(j = 0; j < classes->m[k]->col; j++){
classes->m[k]->data[i][j] += mutot->data[j];
}
}
}
initMatrix(&X_T);
for(k = 0; k < classes->order; k++){
/*printf("row %d col %d\n", (int)classes->m[k]->row, (int)classes->m[k]->col);*/
AddArrayMatrix(&lda->features, classes->m[k]->row, classes->m[k]->col);
AddArrayMatrix(&lda->mnpdf, classes->m[k]->row, classes->m[k]->col);
}
NewDVector(&evect_, lda->evect->row);
initDVector(&ldfeature);
ResizeMatrix(&lda->fmean, classes->order, lda->evect->col);
ResizeMatrix(&lda->fsdev, classes->order, lda->evect->col);
for(l = 0; l < lda->evect->col; l++){
for(i = 0; i < lda->evect->row; i++){
evect_->data[i] = lda->evect->data[i][l];
}
for(k = 0; k < classes->order; k++){
ResizeMatrix(&X_T, classes->m[k]->col, classes->m[k]->row);
MatrixTranspose(classes->m[k], X_T);
DVectorResize(&ldfeature, classes->m[k]->row);
DVectorMatrixDotProduct(X_T, evect_, ldfeature);
for(i = 0; i < ldfeature->size; i++){
lda->features->m[k]->data[i][l] = ldfeature->data[i];
}
/* Calculate the multivariate normal distribution */
double mean = 0.f, sdev = 0.f;
DVectorMean(ldfeature, &mean);
DVectorSDEV(ldfeature, &sdev);
lda->fmean->data[k][l] = mean;
lda->fsdev->data[k][l] = sdev;
for(i = 0; i < ldfeature->size; i++){
lda->mnpdf->m[k]->data[i][l] = 1./sqrt(2 * pi* sdev) * exp(-square((ldfeature->data[i] - mean)/sdev)/2.f);
}
}
}
DelDVector(&evect_);
DelMatrix(&covmx);
DelDVector(&ldfeature);
DelDVector(&mutot);
DelMatrix(&Sb);
DelMatrix(&InvSw_Sb);
DelArray(&classes);
DelArray(&S);
DelMatrix(&Sw);
DelMatrix(&X_T);
DelMatrix(&X);
}
void LDAPrediction(matrix *mx, LDAMODEL *lda, matrix **pfeatures, matrix **probability, matrix **mnpdf, uivector **classprediction)
{
/* probability function:
* f = mu_class * inv_cov * mx.T - 1/2. * mu_class * inv_cov * mu_class.T + ln(prior_probability_class)
*/
size_t i, j, argmax, id;
matrix *mx_T;
dvector *x, *mu, *C_x_T, *C_mu_T, *ldfeature, *evect_;
NewMatrix(&mx_T, mx->col, mx->row);
MatrixTranspose(mx, mx_T);
NewDVector(&C_x_T, lda->inv_cov->row);
NewDVector(&C_mu_T, lda->inv_cov->row);
ResizeMatrix(probability, mx->row, lda->nclass);
for(i = 0; i < mx_T->col; i++){
x = getMatrixColumn(mx_T, i); /* object k*/
for(j = 0; j < lda->nclass; j++){
mu = getMatrixRow(lda->mu, j); /*each row correspond to a class of objects*/
MatrixDVectorDotProduct(lda->inv_cov, x, C_x_T);
MatrixDVectorDotProduct(lda->inv_cov, mu, C_mu_T);
(*probability)->data[i][j] = DVectorDVectorDotProd(mu, C_x_T) - (0.5 * DVectorDVectorDotProd(mu, C_mu_T)) + log(lda->pprob->data[j]);
DVectorSet(C_x_T, 0.f);
DVectorSet(C_mu_T, 0.f);
DelDVector(&mu);
}
DelDVector(&x);
}
for(i = 0; i < (*probability)->row; i++){
argmax = 0;
for(j = 1; j < (*probability)->col; j++){
if((*probability)->data[i][j] > (*probability)->data[i][argmax]){
argmax = j;
}
else{
continue;
}
}
if(lda->class_start == 0){
UIVectorAppend(classprediction, argmax);
}
else{
UIVectorAppend(classprediction, argmax+1);
}
}
/* Predict the the new projection in the feature space */
ResizeMatrix(mnpdf, mx->row, lda->evect->col);
NewDVector(&ldfeature, mx->row);
for(i = 0; i < lda->evect->col; i++){
evect_ = getMatrixColumn(lda->evect, i);
DVectorMatrixDotProduct(mx_T, evect_, ldfeature);
DelDVector(&evect_);
MatrixAppendCol(pfeatures, ldfeature);
for(j = 0; j < ldfeature->size; j++){
id = (*classprediction)->data[j];
if(lda->class_start == 1)
id -= 1;
(*mnpdf)->data[j][i] = 1./sqrt(2 * pi* lda->fsdev->data[id][i]) * exp(-square((ldfeature->data[j] - lda->fmean->data[id][i])/lda->fsdev->data[id][i])/2.f);
}
DVectorSet(ldfeature, 0.f);
}
DelDVector(&ldfeature);
DelMatrix(&mx_T);
DelDVector(&C_x_T);
DelDVector(&C_mu_T);
}
void *LDARandomGroupCVModel(void *arg_)
{
size_t i, j, k, n, g;
lda_rgcv_th_arg *arg;
matrix *gid; /* randomization and storing id for each random group into a matrix */
/* Matrix for compute the PLS models for groups */
matrix *subX;
uivector *subY;
LDAMODEL *subm;
/*matrix to predict*/
matrix *predictX;
uivector *realY;
dvector *sens, *spec, *ppv, *npv, *acc;
initDVector(&sens);
initDVector(&spec);
initDVector(&ppv);
initDVector(&npv);
initDVector(&acc);
arg = (lda_rgcv_th_arg*) arg_;
NewMatrix(&gid, arg->group, (size_t)ceil(arg->mx->row/(double)arg->group));
/* Divide in group all the Dataset */
MatrixSet(gid, -1);
/* step 1 generate the random groups */
k = 0;
for(i = 0; i < gid->row; i++){
for(j = 0; j < gid->col; j++){
do{
/*n = randInt(0, arg->mx->row);*/
n = (size_t)myrand_r(&arg->srand_init) % (arg->mx->row);
} while(ValInMatrix(gid, n) == 1 && k < (arg->mx->row));
if(k < arg->mx->row){
gid->data[i][j] = n;
k++;
}
else
continue;
}
}
/*
puts("Gid Matrix");
PrintMatrix(gid);
*/
/*
printf("Excuded the group number %u\n", (unsigned int)g);
puts("Sub Model\nX:");
PrintArray(subX);
puts("Y:");
PrintArray(subY);
puts("\n\nPredict Group\nX:");
PrintArray(predictX);
puts("RealY:");
PrintArray(realY);
*/
/*step 2*/
for(g = 0; g < gid->row; g++){ /*For aeach group */
/* Estimate how many objects are inside the sub model without the group "g" */
n = 0;
for(i = 0; i < gid->row; i++){
if(i != g){
for(j = 0; j < gid->col; j++){
if((int)gid->data[i][j] != -1)
n++;
else
continue;
}
}
else
continue;
}
/*Allocate the submodel*/
NewMatrix(&subX, n, arg->mx->col);
NewUIVector(&subY, n);
/* Estimate how many objects are inside the group "g" to predict*/
n = 0;
for(j = 0; j < gid->col; j++){
if((int)gid->data[g][j] != -1)
n++;
else
continue;
}
/*Allocate the */
NewMatrix(&predictX, n, arg->mx->col);
NewUIVector(&realY, n);
/* copy the submodel values */
for(i = 0, k = 0; i < gid->row; i++){
if(i != g){
for(j = 0; j < gid->col; j++){
size_t a = (size_t)gid->data[i][j]; /* get the row index */
if(a != -1){
for(n = 0; n < arg->mx->col; n++){
/*setMatrixValue(subX, k, n, getMatrixValue(arg->mx, a, n));*/
subX->data[k][n] = arg->mx->data[a][n];
}
subY->data[k] = arg->my->data[a];
k++;
}
else{
continue;
}
}
}
else{
continue;
}
}
/* copy the objects to predict into predictmx*/
for(j = 0, k = 0; j < gid->col; j++){
size_t a = (size_t)gid->data[g][j];
if(a != -1){
for(n = 0; n < arg->mx->col; n++){
predictX->data[k][n] = arg->mx->data[a][n];
}
realY->data[k] = arg->my->data[a];
k++;
}
else{
continue;
}
}
NewLDAModel(&subm);
LDA(subX, subY, subm);
LDAError(predictX, realY, subm, &sens, &spec, &ppv, &npv, &acc);
if(arg->sens->size == 0){
DVectorCopy(sens, &arg->sens);
}
else{
for(i = 0; i < sens->size; i++){
arg->sens->data[i] += sens->data[i];
}
}
if(arg->spec->size == 0){
DVectorCopy(spec, &arg->spec);
}
else{
for(i = 0; i < spec->size; i++){
arg->spec->data[i] += spec->data[i];
}
}
if(arg->ppv->size == 0){
DVectorCopy(ppv, &arg->ppv);
}
else{
for(i = 0; i < ppv->size; i++){
arg->ppv->data[i] += ppv->data[i];
}
}
if(arg->npv->size == 0){
DVectorCopy(npv, &arg->npv);
}
else{
for(i = 0; i < npv->size; i++){
arg->npv->data[i] += npv->data[i];
}
}
if(arg->acc->size == 0){
DVectorCopy(acc, &arg->acc);
}
else{
for(i = 0; i < acc->size; i++){
arg->acc->data[i] += acc->data[i];
}
}
DelLDAModel(&subm);
DelMatrix(&subX);
DelUIVector(&subY);
DelMatrix(&predictX);
DelUIVector(&realY);
}
DelDVector(&acc);
DelDVector(&sens);
DelDVector(&spec);
DelDVector(&ppv);
DelDVector(&npv);
DelMatrix(&gid);
return 0;
}
/**
* @brief Used to create and initialise a new instance of the Matrix3d struct
* @return A pointer to the new Matrix3d* instance
*/
Matrix3d* CreateMatrix() {
return NewMatrix(CreateVector(), CreateVector(), CreateVector());
}
void LDALOOCV(matrix* mx, uivector* my, dvector** sens, dvector** spec, dvector** ppv, dvector** npv, dvector **acc, size_t nthreads, ssignal *s)
{
if(mx->row == my->size){
size_t i, j, k, l, th, model;
pthread_t *threads;
lda_loocv_th_arg *arg;
threads = xmalloc(sizeof(pthread_t)*nthreads);
arg = xmalloc(sizeof(lda_loocv_th_arg)*nthreads);
/* initialize threads arguments.. */
for(th = 0; th < nthreads; th++){
NewMatrix(&arg[th].submx, mx->row-1, mx->col);
NewUIVector(&arg[th].submy, my->size-1);
NewMatrix(&arg[th].predmx, 1, mx->col);
NewUIVector(&arg[th].predmy, 1);
initDVector(&arg[th].sens);
initDVector(&arg[th].spec);
initDVector(&arg[th].ppv);
initDVector(&arg[th].npv);
initDVector(&arg[th].acc);
}
for(model = 0; model < mx->row; model += nthreads){ /* we compute mx->row models */
if(s != NULL && (*s) == SIGSCIENTIFICSTOP){
break;
}
else{
/* copy data into subX, subY, predictX and predictY for each thread argument
* and run the thread
*/
for(th = 0; th < nthreads; th++){
if(th+model < mx->row){
l = 0;
for(j = 0; j < mx->row; j++){
if(j != model+th){
for(k = 0; k < mx->col; k++){
/*setMatrixValue(arg[th].submx, l, k, getMatrixValue(mx, j, k));*/
arg[th].submx->data[l][k] = mx->data[j][k];
}
arg[th].submy->data[l] = my->data[j];
l++;
}
else{
for(k = 0; k < mx->col; k++){
arg[th].predmx->data[0][k] = mx->data[j][k];
}
arg[th].predmy->data[0] = my->data[j];
}
}
pthread_create(&threads[th], NULL, LDALOOModel, (void*) &arg[th]);
}
else{
continue;
}
}
/* Wait till threads are complete before main continues. Unless we */
/* wait we run the risk of executing an exit which will terminate */
/* the process and all threads before the threads have completed. */
for(th = 0; th < nthreads; th++){
if(th+model < mx->row){
pthread_join(threads[th], NULL);
}
else{
continue;
}
}
/*Collapse the threads output*/
for(th = 0; th < nthreads; th++){
if((*sens)->size == 0){
DVectorCopy(arg[th].sens, sens);
}
else{
for(i = 0; i < arg[th].sens->size; i++){
(*sens)->data[i] += arg[th].sens->data[i];
}
}
if((*spec)->size == 0){
DVectorCopy(arg[th].spec, spec);
}
else{
for(i = 0; i < arg[th].spec->size; i++){
(*spec)->data[i] += arg[th].spec->data[i];
}
}
if((*ppv)->size == 0){
DVectorCopy(arg[th].ppv, ppv);
}
else{
for(i = 0; i < arg[th].ppv->size; i++){
(*ppv)->data[i] += arg[th].ppv->data[i];
}
}
if((*npv)->size == 0){
DVectorCopy(arg[th].npv, npv);
}
else{
for(i = 0; i < arg[th].npv->size; i++){
(*npv)->data[i] += arg[th].npv->data[i];
}
}
if((*acc)->size == 0){
DVectorCopy(arg[th].acc, acc);
}
else{
for(i = 0; i < arg[th].acc->size; i++){
(*acc)->data[i] += arg[th].acc->data[i];
}
}
}
}
}
/*Delete thread arguments*/
for(th = 0; th < nthreads; th++){
DelMatrix(&arg[th].submx);
DelUIVector(&arg[th].submy);
DelMatrix(&arg[th].predmx);
DelUIVector(&arg[th].predmy);
DelDVector(&arg[th].sens);
DelDVector(&arg[th].spec);
DelDVector(&arg[th].ppv);
DelDVector(&arg[th].npv);
DelDVector(&arg[th].acc);
}
/*Finalize the output by dividing for the number of models*/
for(i = 0; i < (*sens)->size; i++){
(*sens)->data[i] /= mx->row;
(*spec)->data[i] /= mx->row;
(*ppv)->data[i] /= mx->row;
(*npv)->data[i] /= mx->row;
(*acc)->data[i] /= mx->row;
}
xfree(arg);
xfree(threads);
}
else{
fprintf(stderr, "Error!! Unable to compute LDA Leave One Out Validation!!\n");
}
}
void CodonData::FillCodonMatrixFromDNA(const NucleotideData *dnaData){
//first we need to convert the nucleotide data to codons numbered 0-60 or 61 and assign them back to the terminals
//codons are ordered AAA, AAC, AAG, AAT, ACA, ... TTT
short pos1, pos2, pos3;
nChar = dnaData->NChar()/3;
nTax = dnaData->NTax();
if(dnaData->NChar() % 3 != 0) throw ErrorException("Codon datatype specified, but number of nucleotides not divisible by 3!");
NewMatrix(nTax, nChar);
//this will just map from the bitwise format to the index format (A, C, G, T = 0, 1, 2, 3)
//partial ambiguity is mapped to total ambiguity currently
short bitwiseToIndexFormat[16] = {15,0,1,15,2,15,15,15,3,15,15,15,15,15,15,15};
//keep track of the empirical base freqs at the codon positions, for possible use
//in the F1x4 or F3x4 methods of calculating the equilibrium codon freqs
empBaseFreqsPos1[0]=empBaseFreqsPos1[1]=empBaseFreqsPos1[2]=empBaseFreqsPos1[3]=ZERO_POINT_ZERO;
empBaseFreqsPos2[0]=empBaseFreqsPos2[1]=empBaseFreqsPos2[2]=empBaseFreqsPos2[3]=ZERO_POINT_ZERO;
empBaseFreqsPos3[0]=empBaseFreqsPos3[1]=empBaseFreqsPos3[2]=empBaseFreqsPos3[3]=ZERO_POINT_ZERO;
FLOAT_TYPE total = ZERO_POINT_ZERO;
int tax=0, thisCodonNum;
for(int tax=0;tax<NTax();tax++){
bool firstAmbig = true;
for(int cod=0;cod<nChar;cod++){
short p1 = dnaData->Matrix(tax, cod*3);
short p2 = dnaData->Matrix(tax, cod*3+1);
short p3 = dnaData->Matrix(tax, cod*3+2);
pos1 = bitwiseToIndexFormat[p1];
pos2 = bitwiseToIndexFormat[p2];
pos3 = bitwiseToIndexFormat[p3];
thisCodonNum=(pos1)*16 + (pos2)*4 + pos3;
if(pos1==15||pos2==15||pos3==15){//check for gaps or ambiguity
if(pos1+pos2+pos3 != 45){
//warn about gaps or ambiguity in codons
if(firstAmbig){
outman.UserMessageNoCR("Gaps or ambiguity codes found within codon for taxon %s.\n\tCodons coded as missing for that taxon: ", dnaData->TaxonLabel(tax));
firstAmbig = false;
}
outman.UserMessageNoCR("%d ", cod+1);
}
thisCodonNum=64;
}
else{
empBaseFreqsPos1[pos1] += ONE_POINT_ZERO;
empBaseFreqsPos2[pos2] += ONE_POINT_ZERO;
empBaseFreqsPos3[pos3] += ONE_POINT_ZERO;
total += ONE_POINT_ZERO;
}
char prot;
//note that a return code of 20 from the codon lookup indicates a stop codon, but a protein code of 20 generally means total ambiguity
if(thisCodonNum != 64){
prot = code.CodonLookup(thisCodonNum);
if(prot == 20){
string c;
char b[4]={'A','C','G','T'};
c += b[pos1];
c += b[pos2];
c += b[pos3];
throw ErrorException("stop codon %s found at codon site %d (nuc site %d) in taxon %s. Bailing out.", c.c_str(), cod+1, cod*3+1, dnaData->TaxonLabel(tax));
}
}
if(thisCodonNum == 64)//missing or ambiguous
matrix[tax][cod] = maxNumStates;
else
matrix[tax][cod] = code.Map64stateToNonStops(thisCodonNum);
}
if(firstAmbig == false) outman.UserMessage("");
}
for(int b=0;b<4;b++){
empBaseFreqsAllPos[b] = (empBaseFreqsPos1[b] + empBaseFreqsPos2[b] + empBaseFreqsPos3[b]) / (3.0 * total);
empBaseFreqsPos1[b] /= total;
empBaseFreqsPos2[b] /= total;
empBaseFreqsPos3[b] /= total;
}
}
bool PrimitivesTypedValuesUseFunction::runStep(const openfluid::base::SimulationStatus* SimStatus)
{
openfluid::core::Unit* TU;
unsigned int TUID;
unsigned int CurStep;
double RefDouble;
long RefLong;
bool RefBool;
std::string RefString;
unsigned long RefVectorSize = 40;
unsigned long RefMatrixColsNb = 4;
unsigned long RefMatrixRowsNb = 3;
double VarDouble;
long VarLong;
bool VarBool;
std::string VarString;
openfluid::core::VectorValue VarVectorVal;
openfluid::core::MatrixValue VarMatrixVal;
openfluid::core::MapValue VarMapVal;
double NewDouble;
long NewLong;
bool NewBool;
std::string NewString;
unsigned long NewVectorSize = 5;
unsigned long NewMatrixColsNb = RefMatrixColsNb + 1;
unsigned long NewMatrixRowsNb = RefMatrixRowsNb + 1;
DECLARE_UNITS_ORDERED_LOOP(1);
BEGIN_UNITS_ORDERED_LOOP(1,"TestUnits",TU)
TUID = TU->getID();
CurStep = SimStatus->getCurrentStep();
RefDouble = (double)TUID/10;
RefLong = TUID;
RefBool = (TUID%2 == 0);
RefString = Glib::ustring::compose("ID %1",TUID);
NewDouble = TUID*CurStep*0.1;
NewLong = TUID*CurStep*10;
NewBool = ((TUID*CurStep)%2 == 0);
NewString = Glib::ustring::compose("%1 %2x%3","strvalue",TUID,CurStep);
// double
OPENFLUID_GetVariable(TU,"tests.double",CurStep,VarDouble);
if (!openfluid::tools::IsCloseEnough(VarDouble,RefDouble,0.00001))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect double value (tests.double) get by reference");
OPENFLUID_SetVariable(TU,"tests.double",CurStep,NewDouble);
OPENFLUID_GetVariable(TU,"tests.double",CurStep,VarDouble);
if (!openfluid::tools::IsCloseEnough(VarDouble,NewDouble,0.00001))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect double value after update (tests.double)");
if (!OPENFLUID_IsTypedVariableExist(TU,"tests.double",openfluid::core::Value::DOUBLE))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsTypedVariableExist (tests.double, DOUBLE)");
// long
OPENFLUID_GetVariable(TU,"tests.integer",CurStep,VarLong);
if (VarLong != RefLong)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect long value (tests.integer) get by reference");
OPENFLUID_SetVariable(TU,"tests.integer",CurStep,NewLong);
OPENFLUID_GetVariable(TU,"tests.integer",CurStep,VarLong);
if (VarLong != NewLong)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect long value after update (tests.integer)");
if (!OPENFLUID_IsTypedVariableExist(TU,"tests.integer",openfluid::core::Value::INTEGER))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsTypedVariableExist (tests.integer, INTEGER)");
// bool
OPENFLUID_GetVariable(TU,"tests.bool",CurStep,VarBool);
if (VarBool != RefBool)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect bool value (tests.bool) get by reference");
OPENFLUID_SetVariable(TU,"tests.bool",CurStep,NewBool);
OPENFLUID_GetVariable(TU,"tests.bool",CurStep,VarBool);
if (VarBool != NewBool)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect bool value after update (tests.bool)");
if (!OPENFLUID_IsTypedVariableExist(TU,"tests.bool",openfluid::core::Value::BOOLEAN))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsTypedVariableExist (tests.bool, BOOLEAN)");
// string
OPENFLUID_GetVariable(TU,"tests.string",CurStep,VarString);
if (VarString != RefString)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect string value (tests.string) get by reference");
OPENFLUID_SetVariable(TU,"tests.string",CurStep,NewString);
OPENFLUID_GetVariable(TU,"tests.string",CurStep,VarString);
if (VarString != NewString)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect string value after update (tests.string)");
if (!OPENFLUID_IsTypedVariableExist(TU,"tests.string",openfluid::core::Value::STRING))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsTypedVariableExist (tests.string, STRING)");
// vector
OPENFLUID_GetVariable(TU,"tests.vector",CurStep,VarVectorVal);
if (VarVectorVal.getSize() != RefVectorSize)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect vector size get by reference");
openfluid::core::VectorValue NewVect(NewVectorSize,NewDouble);
OPENFLUID_SetVariable(TU,"tests.vector",CurStep,NewVect);
OPENFLUID_GetVariable(TU,"tests.vector",CurStep,VarVectorVal);
if (VarVectorVal.getSize() != NewVectorSize)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect vector size after update");
if (!openfluid::tools::IsCloseEnough(VarVectorVal[0],NewDouble,0.00001))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect vector value at index 0 after update");
if (!openfluid::tools::IsCloseEnough(VarVectorVal[4],NewDouble,0.00001))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect vector value at index 4 after update");
if (!OPENFLUID_IsTypedVariableExist(TU,"tests.vector",openfluid::core::Value::VECTOR))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsTypedVariableExist (tests.vector, VECTOR)");
// old style vector
VarVectorVal.clear();
OPENFLUID_GetVariable(TU,"tests.oldvector",CurStep,VarVectorVal);
if (VarVectorVal.getSize() != RefVectorSize)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect oldvector size get by reference");
OPENFLUID_SetVariable(TU,"tests.oldvector",CurStep,NewVect);
OPENFLUID_GetVariable(TU,"tests.oldvector",CurStep,VarVectorVal);
if (VarVectorVal.getSize() != NewVectorSize)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect oldvector size after update");
if (!openfluid::tools::IsCloseEnough(VarVectorVal[0],NewDouble,0.00001))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect oldvector value at index 0 after update");
if (!openfluid::tools::IsCloseEnough(VarVectorVal[4],NewDouble,0.00001))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect oldvector value at index 4 after update");
if (!OPENFLUID_IsTypedVariableExist(TU,"tests.oldvector",openfluid::core::Value::VECTOR))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsTypedVariableExist (tests.oldvector, VECTOR)");
// matrix
OPENFLUID_GetVariable(TU,"tests.matrix",CurStep,VarMatrixVal);
if (VarMatrixVal.getColsNbr() != RefMatrixColsNb)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect matrix cols nb get by reference");
if (VarMatrixVal.getRowsNbr() != RefMatrixRowsNb)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect matrix rows nb get by reference");
openfluid::core::MatrixValue NewMatrix(NewMatrixColsNb,NewMatrixRowsNb,NewDouble);
OPENFLUID_SetVariable(TU,"tests.matrix",CurStep,NewMatrix);
OPENFLUID_GetVariable(TU,"tests.matrix",CurStep,VarMatrixVal);
if (VarMatrixVal.getColsNbr() != NewMatrixColsNb)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect matrix cols nb after update");
if (VarMatrixVal.getRowsNbr() != NewMatrixRowsNb)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect matrix rows nb after update");
if (!openfluid::tools::IsCloseEnough(VarMatrixVal.get(0,0),NewDouble,0.00001))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect matrix value at index 0,0 after update");
if (!openfluid::tools::IsCloseEnough(VarMatrixVal.get(4,3),NewDouble,0.00001))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect matrix value at index 4,3 after update");
if (!OPENFLUID_IsTypedVariableExist(TU,"tests.matrix",openfluid::core::Value::MATRIX))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsTypedVariableExist (tests.matrix, MATRIX)");
// map
OPENFLUID_GetVariable(TU,"tests.map",CurStep,VarMapVal);
if (VarMapVal.getSize() != 2)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect map size get by reference");
openfluid::core::MapValue NewMap;
NewMap.setString("key1",NewString);
NewMap.setDouble("key2",NewDouble);
NewMap.setBoolean("key3",NewBool);
OPENFLUID_SetVariable(TU,"tests.map",CurStep,NewMap);
OPENFLUID_GetVariable(TU,"tests.map",CurStep,VarMapVal);
if (VarMapVal.getSize() != 3)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect map size after update");
if (VarMapVal.getString("key1") != NewString)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect map value at key key1 after update");
if (!openfluid::tools::IsCloseEnough(VarMapVal.getDouble("key2"),NewDouble,0.00001))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect map value at key key2 after update");
if (VarMapVal.getBoolean("key3") != NewBool)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect map value at key key3 after update");
if (!OPENFLUID_IsTypedVariableExist(TU,"tests.map",openfluid::core::Value::MAP))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsTypedVariableExist (tests.map, MAP)");
// none
if (!OPENFLUID_IsTypedVariableExist(TU,"tests.none",openfluid::core::Value::NONE))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsTypedVariableExist (tests.none, NONE)");
if (!OPENFLUID_IsVariableExist(TU,"tests.none",CurStep,openfluid::core::Value::DOUBLE))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsVariableExist (tests.none, DOUBLE)");
VarDouble = 0.0;
OPENFLUID_GetVariable(TU,"tests.none",CurStep,VarDouble);
if (!openfluid::tools::IsCloseEnough(VarDouble,RefDouble,0.00001))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect double value (tests.none)");
OPENFLUID_SetVariable(TU,"tests.none",CurStep,NewLong);
if (!OPENFLUID_IsVariableExist(TU,"tests.none",CurStep,openfluid::core::Value::INTEGER))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsVariableExist (tests.none, INTEGER)");
VarLong = 0;
OPENFLUID_GetVariable(TU,"tests.none",CurStep,VarLong);
if (VarLong != NewLong)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect long value (tests.none)");
OPENFLUID_SetVariable(TU,"tests.none",CurStep,openfluid::core::NullValue());
if (!OPENFLUID_IsVariableExist(TU,"tests.none",CurStep,openfluid::core::Value::NULLL))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsVariableExist (tests.none, NULL)");
OPENFLUID_SetVariable(TU,"tests.none",CurStep,NewBool);
if (!OPENFLUID_IsVariableExist(TU,"tests.none",CurStep,openfluid::core::Value::BOOLEAN))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsVariableExist (tests.none, BOOLEAN)");
VarBool = false;
OPENFLUID_GetVariable(TU,"tests.none",CurStep,VarBool);
if (VarBool != NewBool)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect boolean value (tests.none)");
OPENFLUID_SetVariable(TU,"tests.none",CurStep,NewString);
if (!OPENFLUID_IsVariableExist(TU,"tests.none",CurStep,openfluid::core::Value::STRING))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsVariableExist (tests.none, STRING)");
VarString= "";
OPENFLUID_GetVariable(TU,"tests.none",CurStep,VarString);
if (VarString != NewString)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect string value (tests.none)");
OPENFLUID_SetVariable(TU,"tests.none",CurStep,NewVect);
if (!OPENFLUID_IsVariableExist(TU,"tests.none",CurStep,openfluid::core::Value::VECTOR))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsVariableExist (tests.none, VECTOR)");
VarVectorVal.clear();
OPENFLUID_GetVariable(TU,"tests.none",CurStep,VarVectorVal);
if (VarVectorVal.size() != NewVect.size())
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect vector size value (tests.none)");
if (!openfluid::tools::IsCloseEnough(VarVectorVal[4],NewDouble,0.00001))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect vector value at index 4 (tests.none)");
OPENFLUID_SetVariable(TU,"tests.none",CurStep,NewMatrix);
if (!OPENFLUID_IsVariableExist(TU,"tests.none",CurStep,openfluid::core::Value::MATRIX))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsVariableExist (tests.none, MATRIX)");
VarMatrixVal.clear();
OPENFLUID_GetVariable(TU,"tests.none",CurStep,VarMatrixVal);
if (VarMatrixVal.size() != NewMatrix.size())
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect matrix size value (tests.none)");
if (!openfluid::tools::IsCloseEnough(VarMatrixVal.get(4,3),NewDouble,0.00001))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect matrix value at index 4,3 (tests.none)");
OPENFLUID_SetVariable(TU,"tests.none",CurStep,NewMap);
if (!OPENFLUID_IsVariableExist(TU,"tests.none",CurStep,openfluid::core::Value::MAP))
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect OPENFLUID_IsVariableExist (tests.none, MAP)");
VarMapVal.clear();
OPENFLUID_GetVariable(TU,"tests.none",CurStep,VarMapVal);
if (VarMapVal.size() != NewMap.size())
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect map size value (tests.none)");
if (VarMapVal.getBoolean("key3") != NewBool)
OPENFLUID_RaiseError("tests.primitivestypedvalues.use","incorrect map value at key key3 (tests.none)");
END_LOOP
return true;
}
SMatrix ReadSparse(char *name, char *probName)
{
FILE *fp;
long n, m, i, j;
long n_rows, tmp;
long numer_lines;
long colnum, colsize, rownum, rowsize;
char buf[100], type[4];
SMatrix M, F;
if (!name || name[0] == 0) {
fp = stdin;
} else {
fp = fopen(name, "r");
}
if (!fp) {
Error("Error opening file\n");
}
fscanf(fp, "%72c", buf);
fscanf(fp, "%8c", probName);
probName[8] = 0;
DumpLine(fp);
for (i=0; i<5; i++) {
fscanf(fp, "%14c", buf);
sscanf(buf, "%ld", &tmp);
if (i == 3)
numer_lines = tmp;
}
DumpLine(fp);
fscanf(fp, "%3c", type);
type[3] = 0;
if (!(type[0] != 'C' && type[1] == 'S' && type[2] == 'A')) {
fprintf(stderr, "Wrong type: %s\n", type);
exit(0);
}
fscanf(fp, "%11c", buf); /* pad */
fscanf(fp, "%14c", buf); sscanf(buf, "%ld", &n_rows);
fscanf(fp, "%14c", buf); sscanf(buf, "%ld", &n);
fscanf(fp, "%14c", buf); sscanf(buf, "%ld", &m);
fscanf(fp, "%14c", buf); sscanf(buf, "%ld", &tmp);
if (tmp != 0)
printf("This is not an assembled matrix!\n");
if (n_rows != n)
printf("Matrix is not symmetric\n");
DumpLine(fp);
fscanf(fp, "%16c", buf);
ParseIntFormat(buf, &colnum, &colsize);
fscanf(fp, "%16c", buf);
ParseIntFormat(buf, &rownum, &rowsize);
fscanf(fp, "%20c", buf);
fscanf(fp, "%20c", buf);
DumpLine(fp); /* format statement */
M = NewMatrix(n, m, 0);
ReadVector(fp, n+1, M.col, colnum, colsize);
ReadVector(fp, m, M.row, rownum, rowsize);
for (i=0; i<numer_lines; i++) /* dump numeric values */
DumpLine(fp);
for (i=0; i<n; i++)
ISort(M, i);
for (i=0; i<=n; i++)
M.startrow[i] = M.col[i];
fclose(fp);
F = LowerToFull(M);
maxm = 0;
for (i=0; i<n; i++)
if (F.col[i+1]-F.col[i] > maxm)
maxm = F.col[i+1]-F.col[i];
if (F.nz) {
for (j=0; j<n; j++)
for (i=F.col[j]; i<F.col[j+1]; i++)
F.nz[i] = Value(F.row[i], j);
}
FreeMatrix(M);
return(F);
}
SMatrix LowerToFull(SMatrix L)
{
SMatrix M;
long *link, *first;
long i, j, nextj, ind = 0;
link = (long *) malloc(L.n*sizeof(long));
first = (long *) malloc(L.n*sizeof(long));
for (i=0; i<L.n; i++) {
link[i] = first[i] = -1;
}
M = NewMatrix(L.n, 2*(L.m-L.n)+L.n, 0);
for (i=0; i<L.n; i++) {
M.col[i] = ind;
for (j=L.col[i]; j<L.col[i+1]; j++) {
if (L.row[j] >= i) {
M.row[ind++] = L.row[j];
}
}
j = link[i];
while (j != -1) {
nextj = link[j];
M.row[ind++] = j;
first[j]++;
if (first[j] < L.col[j+1]) {
AddMember(L.row[first[j]], j);
}
j = nextj;
}
first[i] = L.col[i];
if (L.row[first[i]] == i) {
first[i]++;
} else {
fprintf(stderr, "Missing diagonal: %ld: ", i);
for (j=L.col[i]; j<L.col[i+1]; j++) {
fprintf(stderr, "%ld ", L.row[j]);
}
fprintf(stderr, "\n");
}
if (first[i] < L.col[i+1]) {
AddMember(L.row[first[i]], i);
}
}
M.col[M.n] = ind;
for (i=0; i<=L.n; i++) {
M.startrow[i] = M.col[i];
}
if (ind != M.m) {
printf("Lost some\n");
}
free(link); free(first);
return(M);
}
int main () {
long double h = 0.2;
long double k = 0.04;
long double i;
long double t;
long double t_min = 0;
long double t_max = 0.4;
long double x_min = 0;
long double x_max = 4.0;
long double alpha = 4 / (LM_PI * LM_PI);
long double lambda = alpha * (k / (h * h));
int j = (x_max - x_min) / h;
int p = (t_max - t_min) / k;
int d;
long double xa = -lambda / 2.0;
long double xb = 1 + lambda;
long double xc = -xa;
long double xd = 1 - lambda;
matrix *A = NewMatrix (j, j);
matrix *B = NewMatrix (j, j);
matrix *w = NewMatrix (j, 1);
for (d = 1; d <= j; d++)
{
Mat_SetCell (A, d, d - 1, xa);
Mat_SetCell (A, d, d, xb);
Mat_SetCell (A, d, d + 1, xa);
Mat_SetCell (B, d, d - 1, xc);
Mat_SetCell (B, d, d, xd);
Mat_SetCell (B, d, d + 1, xc);
Mat_SetCell (w, d, 1, f ((d) * h));
}
printf ("A \n");
Mat_Print (A);
printf ("B \n");
Mat_Print (B);
matrix *Ai = Mat_FindInverse (A);
printf ("Ai \n");
Mat_Print (Ai);
matrix *Temp = Mat_Mult (Ai, B);
matrix *w1;
long double results[j + 1][p];
int q = 0;
int s;
int u;
for (t = k; t <= t_max; t += k)
{
for (s = 0; s <= j; s++)
results[s][q] = Mat_GetCell (w, s + 1, 1);
q++;
w1 = Mat_Mult (Temp, w);
Mat_Dispose (w);
w = w1;
}
for (s = 0; s <= j; s++)
results[s][q] = Mat_GetCell (w, s + 1, 1);
printf ("Estimated Answer:\n\n t ");
for (t = t_min; t <= t_max; t += k)
printf ("%8.5Lf ", t);
printf ("\n");
printf ("i\n");
for (s = 0; s < j; s++)
{
printf ("%8.5Lf ", (s + 1) * h);
for (u = 0; u <= p; u++)
{
printf ("%8.5Lf ", results[s][u]);
}
printf ("\n");
}
printf ("\nExact Answer:\n\n t ");
for (t = .4; t <= t_max; t += k)
printf ("%8.5Lf ", t);
printf ("\n");
printf ("i\n");
for (i = x_min + h; i < x_max; i += h)
{
printf ("%Lf ", i);
for (t = .4; t <= t_max; t += k)
{
printf ("%8.5Lf ",
powl (LM_E, -t) * sinl (LM_PI / 2.0 * i) +
powl (LM_E, -t / 4.0) *
sinl (LM_PI / 4.0 * i));
}
printf ("\n");
}
return 0;
}
void NucleotideData::CreateMatrixFromNCL(GarliReader &reader){
NxsCharactersBlock *charblock;
int num=0, numNuc = -1;
do{
charblock = reader.GetCharactersBlock(num);
if(charblock->GetDataType() == NxsCharactersBlock::nucleotide ||
charblock->GetDataType() == NxsCharactersBlock::dna ||
charblock->GetDataType() == NxsCharactersBlock::rna){
if(numNuc < 0) numNuc = num;
else{
throw ErrorException("Multiple characters/data blocks containing nucleotide data found in Nexus datafile!\n\tEither combine the blocks or comment one out.");
}
}
else outman.UserMessage("Ignoring non-nucleotide characters block from Nexus datafile");
num++;
}while(num < reader.NumCharBlocks());
if(numNuc < 0) throw ErrorException("No characters/data blocks containing nucleotide data found in Nexus datafile!");
charblock = reader.GetCharactersBlock(numNuc);
if(charblock->GetNumActiveChar() < charblock->GetNChar()){
outman.UserMessageNoCR("Excluded characters:\n\t");
for(int c=0;c<charblock->GetNCharTotal();c++)
if(charblock->IsExcluded(c)) outman.UserMessageNoCR("%d ", c+1);
outman.UserMessage("");
}
// vector<unsigned> reducedToOrigCharMap = charblock->GetOrigIndexVector();
NxsTaxaBlock *taxablock = reader.GetTaxaBlock();
int numOrigTaxa = charblock->GetNTax();
int numActiveTaxa = charblock->GetNumActiveTaxa();
int numOrigChar = charblock->GetNChar();
int numActiveChar = charblock->GetNumActiveChar();
//int num_chars = reducedToOrigCharMap.size();
//cout << num_chars << endl;
NewMatrix( numActiveTaxa, numActiveChar );
// read in the data, including taxon names
int i=0;
for( int origTaxIndex = 0; origTaxIndex < numOrigTaxa; origTaxIndex++ ) {
if(charblock->IsActiveTaxon(origTaxIndex)){
//internally, blanks in taxon names will be stored as underscores
NxsString tlabel = taxablock->GetTaxonLabel(origTaxIndex);
tlabel.BlanksToUnderscores();
SetTaxonLabel( i, tlabel.c_str());
int j = 0;
for( int origIndex = 0; origIndex < numOrigChar; origIndex++ ) {
if(charblock->IsActiveChar(origIndex)){
unsigned char datum = '\0';
if(charblock->IsGapState(origTaxIndex, origIndex) == true) datum = 15;
else if(charblock->IsMissingState(origTaxIndex, origIndex) == true) datum = 15;
else{
int nstates = charblock->GetNumStates(origTaxIndex, origIndex);
for(int s=0;s<nstates;s++){
datum += CharToBitwiseRepresentation(charblock->GetState(origTaxIndex, origIndex, s));
}
}
SetMatrix( i, j++, datum );
}
}
i++;
}
}
}
void AminoacidData::CreateMatrixFromNCL(GarliReader &reader){
NxsCharactersBlock *charblock;
int num=0, numNuc = -1;
do{
charblock = reader.GetCharactersBlock(num);
if(charblock->GetDataType() == NxsCharactersBlock::protein){
if(numNuc < 0) numNuc = num;
else{
throw ErrorException("Multiple characters/data blocks containing protein data found in Nexus datafile!\n\tEither combine the blocks or comment one out.");
}
}
else outman.UserMessage("Ignoring non-protein characters block from Nexus datafile");
num++;
}while(num < reader.NumCharBlocks());
if(numNuc < 0) throw ErrorException("No characters/data blocks containing protein data found in Nexus datafile!");
charblock = reader.GetCharactersBlock(numNuc);
if(charblock->GetNumActiveChar() < charblock->GetNChar()){
outman.UserMessageNoCR("Excluded characters:\n\t");
for(int c=0;c<charblock->GetNCharTotal();c++)
if(charblock->IsExcluded(c)) outman.UserMessageNoCR("%d ", c+1);
outman.UserMessage("");
}
// vector<unsigned> reducedToOrigCharMap = charblock->GetOrigIndexVector();
NxsTaxaBlock *taxablock = reader.GetTaxaBlock();
int numOrigTaxa = charblock->GetNTax();
int numActiveTaxa = charblock->GetNumActiveTaxa();
int numOrigChar = charblock->GetNChar();
int numActiveChar = charblock->GetNumActiveChar();
//int num_chars = reducedToOrigCharMap.size();
//cout << num_chars << endl;
NewMatrix( numActiveTaxa, numActiveChar );
// read in the data, including taxon names
int i=0;
for( int origTaxIndex = 0; origTaxIndex < numOrigTaxa; origTaxIndex++ ) {
if(charblock->IsActiveTaxon(origTaxIndex)){
//internally, blanks in taxon names will be stored as underscores
NxsString tlabel = taxablock->GetTaxonLabel(origTaxIndex);
tlabel.BlanksToUnderscores();
SetTaxonLabel( i, tlabel.c_str());
int j = 0;
bool firstAmbig = true;
for( int origIndex = 0; origIndex < numOrigChar; origIndex++ ) {
if(charblock->IsActiveChar(origIndex)){
unsigned char datum = '\0';
if(charblock->IsGapState(origTaxIndex, origIndex) == true) datum = 20;
else if(charblock->IsMissingState(origTaxIndex, origIndex) == true) datum = 20;
else{
int nstates = charblock->GetNumStates(origTaxIndex, origIndex);
//assert(nstates == 1);
//need to deal with the possibility of multiple states represented in matrix
//just convert to full ambiguity
if(nstates == 1)
datum = CharToDatum(charblock->GetState(origTaxIndex, origIndex, 0));
else{
if(firstAmbig){
outman.UserMessageNoCR("Partially ambiguous characters of taxon %s converted to full ambiguity:\n\t", TaxonLabel(origTaxIndex));
firstAmbig = false;
}
outman.UserMessageNoCR("%d ", origIndex+1);
datum = CharToDatum('?');
}
}
SetMatrix( i, j++, datum );
}
}
if(firstAmbig == false) outman.UserMessage("");
i++;
}
}
}
