Quantity dot(OSQuantityVector lVector, const OSQuantityVector& rVector) {
Unit lUnits(lVector.units()), rUnits(rVector.units());
OptionalTemperatureUnit ltu = lUnits.optionalCast<TemperatureUnit>();
OptionalTemperatureUnit rtu = rUnits.optionalCast<TemperatureUnit>();
Unit resultUnits;
if (ltu && rtu) {
resultUnits = ltu.get() * rtu.get();
}
else {
resultUnits = lUnits * rUnits;
}
ScaleOpReturnType resultScale = lVector.scale() * rVector.scale();
lVector *= resultScale.second;
DoubleVector lValues(lVector.values()), rValues(rVector.values());
double resultValue = dot(createVector(lValues),createVector(rValues));
return Quantity(resultValue,resultUnits);
}
void MatrixStorage<ValueType>::convertCSR2CSC(
LAMAArray<IndexType>& colIA,
LAMAArray<IndexType>& colJA,
LAMAArray<ValueType>& colValues,
const IndexType numColumns,
const LAMAArray<IndexType>& rowIA,
const LAMAArray<IndexType>& rowJA,
const LAMAArray<ValueType>& rowValues,
const ContextPtr loc )
{
// ContextPtr loc = ContextFactory::getContext( Context::Host );
const IndexType numRows = rowIA.size() - 1;
const IndexType numValues = rowJA.size();
LAMA_ASSERT_EQUAL_DEBUG( rowJA.size(), rowValues.size() )
LAMA_INTERFACE_FN_T( convertCSR2CSC, loc, CSRUtils, Transpose, ValueType )
LAMA_LOG_INFO( logger,
"MatrixStorage::CSR2CSC of matrix " << numRows << " x " << numColumns << ", #nnz = " << numValues << " on " << *loc )
LAMA_REGION( "Storage.CSR2CSC" )
WriteOnlyAccess<IndexType> cIA( colIA, loc, numColumns + 1 );
WriteOnlyAccess<IndexType> cJA( colJA, loc, numValues );
WriteOnlyAccess<ValueType> cValues( colValues, loc, numValues );
ReadAccess<IndexType> rIA( rowIA, loc );
ReadAccess<IndexType> rJA( rowJA, loc );
ReadAccess<ValueType> rValues( rowValues, loc );
LAMA_CONTEXT_ACCESS( loc )
convertCSR2CSC( cIA.get(), cJA.get(), cValues.get(), rIA.get(), rJA.get(), rValues.get(), numRows, numColumns,
numValues );
}
void SchnyderLayout::schnyderEmbedding(
GraphCopy& GC,
GridLayout &gridLayout,
adjEntry adjExternal)
{
NodeArray<int> &xcoord = gridLayout.x();
NodeArray<int> &ycoord = gridLayout.y();
node v;
List<node> L; // (un)contraction order
GraphCopy T = GraphCopy(GC); // the realizer tree (reverse direction of edges!!!)
EdgeArray<int> rValues(T); // the realizer values
// choose outer face a,b,c
adjEntry adja;
if (adjExternal != 0) {
edge eG = adjExternal->theEdge();
edge eGC = GC.copy(eG);
adja = (adjExternal == eG->adjSource()) ? eGC->adjSource() : eGC->adjTarget();
}
else {
adja = GC.firstEdge()->adjSource();
}
adjEntry adjb = adja->faceCyclePred();
adjEntry adjc = adjb->faceCyclePred();
node a = adja->theNode();
node b = adjb->theNode();
node c = adjc->theNode();
node a_in_T = T.copy(GC.original(a));
node b_in_T = T.copy(GC.original(b));
node c_in_T = T.copy(GC.original(c));
contract(GC, a, b, c, L);
realizer(GC, L, a, b, c, rValues, T);
NodeArray<int> t1(T);
NodeArray<int> t2(T);
NodeArray<int> val(T, 1);
NodeArray<int> P1(T);
NodeArray<int> P3(T);
NodeArray<int> v1(T);
NodeArray<int> v2(T);
subtreeSizes(rValues, 1, a_in_T, t1);
subtreeSizes(rValues, 2, b_in_T, t2);
prefixSum(rValues, 1, a_in_T, val, P1);
prefixSum(rValues, 3, c_in_T, val, P3);
// now Pi = depth of all nodes in Tree T(i) (depth[root] = 1)
prefixSum(rValues, 2, b_in_T, t1, v1);
// special treatment for a
v1[a_in_T] = t1[a_in_T];
/*
* v1[v] now is the sum of the
* "count of nodes in t1" minus the "subtree size for node x"
* for every node x on a path from b to v in t2
*/
prefixSum(rValues, 3, c_in_T, t1, val);
// special treatment for a
val[a_in_T] = t1[a_in_T];
/*
* val[v] now is the sum of the
* "count of nodes in t1" minus the "subtree size for node x"
* for every node x on a path from c to v in t3
*/
// r1[v]=v1[v]+val[v]-t1[v] is the number of nodes in region 1 from v
forall_nodes(v, T) {
// calc v1'
v1[v] += val[v] - t1[v] - P3[v];
}
//**********************************************************************************************************************
int CorrAxesCommand::calcPearson(map<string, vector<float> >& axes, ofstream& out) {
try {
//find average of each axis - X
vector<float> averageAxes; averageAxes.resize(numaxes, 0.0);
for (map<string, vector<float> >::iterator it = axes.begin(); it != axes.end(); it++) {
vector<float> temp = it->second;
for (int i = 0; i < temp.size(); i++) {
averageAxes[i] += temp[i];
}
}
for (int i = 0; i < averageAxes.size(); i++) { averageAxes[i] = averageAxes[i] / (float) axes.size(); }
//for each otu
for (int i = 0; i < lookupFloat[0]->getNumBins(); i++) {
if (metadatafile == "") { out << i+1; }
else { out << metadataLabels[i]; }
//find the averages this otu - Y
float sumOtu = 0.0;
for (int j = 0; j < lookupFloat.size(); j++) {
sumOtu += lookupFloat[j]->getAbundance(i);
}
float Ybar = sumOtu / (float) lookupFloat.size();
vector<float> rValues(averageAxes.size());
//find r value for each axis
for (int k = 0; k < averageAxes.size(); k++) {
double r = 0.0;
double numerator = 0.0;
double denomTerm1 = 0.0;
double denomTerm2 = 0.0;
for (int j = 0; j < lookupFloat.size(); j++) {
float Yi = lookupFloat[j]->getAbundance(i);
float Xi = axes[lookupFloat[j]->getGroup()][k];
numerator += ((Xi - averageAxes[k]) * (Yi - Ybar));
denomTerm1 += ((Xi - averageAxes[k]) * (Xi - averageAxes[k]));
denomTerm2 += ((Yi - Ybar) * (Yi - Ybar));
}
double denom = (sqrt(denomTerm1) * sqrt(denomTerm2));
r = numerator / denom;
if (isnan(r) || isinf(r)) { r = 0.0; }
rValues[k] = r;
out << '\t' << r;
//signifigance calc - http://faculty.vassar.edu/lowry/ch4apx.html
double temp = (1- (r*r)) / (double) (lookupFloat.size()-2);
temp = sqrt(temp);
double sig = r / temp;
if (isnan(sig) || isinf(sig)) { sig = 0.0; }
out << '\t' << sig;
}
double sum = 0;
for(int k=0;k<rValues.size();k++){
sum += rValues[k] * rValues[k];
}
out << '\t' << sqrt(sum) << endl;
}
return 0;
}
catch(exception& e) {
m->errorOut(e, "CorrAxesCommand", "calcPearson");
exit(1);
}
}
