TMapStrI::iterator iterGenes;

size_t iRet;

if ((iterGenes = mapGenes.find(strToken)) == mapGenes.end()) {

iRet = mapGenes.size();

mapGenes[strToken] = iRet;

vecGenes.push_back(strToken);

} else

iRet = iterGenes->second;

return iRet;

size_t i;

if ((i = vecf.size()) > iLast)

return;

vecf.resize(iLast + 1);

for (; i < vecf.size(); ++i)

vecf[i] = CMeta::GetNaN();

size_t i;

i = 0;

do

istm.seekg(1, ios_base::cur);

while ((acBuffer[i++] = istm.get()));

m_Data.Reset();

m_vecstrGenes.clear();

if (m_pPCL && m_fPCLMemory)

delete m_pPCL;

m_pPCL = NULL;

if (m_pMeasure && m_fMeasureMemory)

delete m_pMeasure;

m_pMeasure = NULL;

CMeta::Unmap(m_abData, m_hndlData, m_iData);

m_abData = NULL;

m_hndlData = 0;

m_iData = 0;

if (m_aadData)

delete[] m_aadData;

m_aadData = NULL;

size_t iS, iG;

vecveciGenes.resize(Slim.GetSlims());

for (iS = 0; iS < vecveciGenes.size(); ++iS) {

vecveciGenes[iS].resize(Slim.GetGenes(iS));

for (iG = 0; iG < vecveciGenes[iS].size(); ++iG)

vecveciGenes[iS][iG] = GetGene(Slim.GetGene(iS, iG).GetName());

}

vector <string> vecstrGenes;

size_t iS1, iS2, iG1, iG2, iGene1, iGene2;

vector <vector<size_t>> vecveciGenes;

Reset();

Slim.GetGeneNames(vecstrGenes);

if (!Open(vecstrGenes))

return false;

SlimCache(Slim, vecveciGenes);

for (iS1 = 0; iS1 < Slim.GetSlims(); ++iS1) {

g_CatSleipnir().info("CDat::Open( ) processing slim: %s",

Slim.GetSlim(iS1).c_str());

for (iG1 = 0; iG1 < Slim.GetGenes(iS1); ++iG1) {

iGene1 = vecveciGenes[iS1][iG1];

for (iG2 = (iG1 + 1); iG2 < Slim.GetGenes(iS1); ++iG2)

Set(iGene1, vecveciGenes[iS1][iG2], 1);

for (iS2 = (iS1 + 1); iS2 < Slim.GetSlims(); ++iS2)

for (iG2 = 0; iG2 < Slim.GetGenes(iS2); ++iG2) {

iGene2 = vecveciGenes[iS2][iG2];

if (CMeta::IsNaN(Get(iGene1, iGene2)))

Set(iGene1, iGene2, 0);

}

}

}

return true;

set <string> setstrGenes;

vector <string> vecstrGenes;

size_t iS1, iS2, iG1, iG2, iGene1, iGene2;

vector <vector<size_t>> vecveciGenes;

Reset();

SlimPositives.GetGeneNames(vecstrGenes);

setstrGenes.insert(vecstrGenes.begin(), vecstrGenes.end());

vecstrGenes.clear();

SlimNonnegatives.GetGeneNames(vecstrGenes);

setstrGenes.insert(vecstrGenes.begin(), vecstrGenes.end());

vecstrGenes.clear();

vecstrGenes.resize(setstrGenes.size());

copy(setstrGenes.begin(), setstrGenes.end(), vecstrGenes.begin());

if (!Open(vecstrGenes))

return false;

SlimCache(SlimPositives, vecveciGenes);

for (iS1 = 0; iS1 < SlimPositives.GetSlims(); ++iS1) {

g_CatSleipnir().info("CDat::Open( ) processing slim: %s",

SlimPositives.GetSlim(iS1).c_str());

for (iG1 = 0; iG1 < SlimPositives.GetGenes(iS1); ++iG1) {

iGene1 = vecveciGenes[iS1][iG1];

for (iG2 = (iG1 + 1); iG2 < SlimPositives.GetGenes(iS1); ++iG2)

Set(iGene1, vecveciGenes[iS1][iG2], 1);

}

}

vecveciGenes.clear();

SlimCache(SlimNonnegatives, vecveciGenes);

for (iS1 = 0; iS1 < SlimNonnegatives.GetSlims(); ++iS1) {

g_CatSleipnir().info("CDat::Open( ) processing slim: %s",

SlimNonnegatives.GetSlim(iS1).c_str());

for (iG1 = 0; iG1 < SlimNonnegatives.GetGenes(iS1); ++iG1) {

iGene1 = vecveciGenes[iS1][iG1];

for (iS2 = (iS1 + 1); iS2 < SlimNonnegatives.GetSlims(); ++iS2)

for (iG2 = 0; iG2 < SlimNonnegatives.GetGenes(iS2); ++iG2) {

iGene2 = vecveciGenes[iS2][iG2];

if (CMeta::IsNaN(Get(iGene1, iGene2)))

Set(iGene1, iGene2, 0);

}

}

}

return true;

bool fKnownNegatives, bool fIncident) {

size_t i, j, iOne, iTwo;

vector <size_t> veciGenes;

float d;

Reset();

Open(Genome.GetGeneNames());

for (i = 0; i < vecpOther.size(); ++i)

OpenHelper(vecpOther[i], 1);

if (!fKnownNegatives)

for (i = 0; i < GetGenes(); ++i)

for (j = (i + 1); j < GetGenes(); ++j)

Set(i, j, CMeta::IsNaN(Get(i, j)) ? 0 : CMeta::GetNaN());

veciGenes.resize(DatKnown.GetGenes());

for (i = 0; i < veciGenes.size(); ++i)

veciGenes[i] = GetGene(DatKnown.GetGene(i));

for (i = 0; i < DatKnown.GetGenes(); ++i) {

iOne = veciGenes[i];

for (j = (i + 1); j < DatKnown.GetGenes(); ++j) {

iTwo = veciGenes[j];

if (CMeta::IsNaN(d = DatKnown.Get(i, j))) {

if (fKnownNegatives && CMeta::IsNaN(Get(iOne, iTwo)))

Set(iOne, iTwo, 0);

} else if (fKnownNegatives == !d)

Set(iOne, iTwo, d);

}

}

if (fIncident) {

vector<float> vecfNegatives;

vecfNegatives.resize(GetGenes());

fill(vecfNegatives.begin(), vecfNegatives.end(), false);

for (i = 0; i < vecfNegatives.size(); ++i)

for (j = 0; j < vecpOther.size(); ++j)

if (vecpOther[j]->IsGene(GetGene(i))) {

vecfNegatives[i] = true;

break;

}

for (i = 0; i < vecfNegatives.size(); ++i)

if (DatKnown.GetGene(GetGene(i)) != -1)

vecfNegatives[i] = true;

for (i = 0; i < GetGenes(); ++i) {

if (vecfNegatives[i])

continue;

for (j = (i + 1); j < GetGenes(); ++j)

if (!(vecfNegatives[j] || Get(i, j))) {

Set(i, j, CMeta::GetNaN());

//cerr << "setting to NaN" << endl;

}

}

}

return true;

size_t i;

if (!Open(Dat.GetGeneNames()))

return false;

for (i = 0; i < GetGenes(); ++i)

memcpy(Get(i), Dat.Get(i), (GetGenes() - i - 1) * sizeof(*Get(i)));

return true;

float dPValue, const CGenome &Genome, bool fIncident) {

size_t i, j, k, iOne, iTwo, iOverlap;

float d;

const CGenes *pBig;

const CGenes *pSmall;

Reset();

Open(Genome.GetGeneNames());

for (i = 0; i < vecpPositives.size(); ++i)

OpenHelper(vecpPositives[i], 1);

if (vecpNonnegatives.size()) {

for (i = 0; i < vecpNonnegatives.size(); ++i)

OpenHelper(vecpNonnegatives[i], 0);

if (dPValue > 0)

for (i = 0; i < vecpPositives.size(); ++i) {

iOne = vecpPositives[i]->GetGenes();

for (j = (i + 1); j < vecpPositives.size(); ++j) {

iTwo = vecpPositives[j]->GetGenes();

if (iOne < iTwo) {

pSmall = vecpPositives[i];

pBig = vecpPositives[j];

} else {

pSmall = vecpPositives[j];

pBig = vecpPositives[i];

}

for (iOverlap = k = 0; k < pSmall->GetGenes(); ++k)

if (pBig->IsGene(pSmall->GetGene(k).GetName()))

iOverlap++;

if (CStatistics::HypergeometricCDF(iOverlap, iOne, iTwo, GetGenes()) < dPValue)

OpenHelper(pBig, pSmall, 0);

}

}

for (i = 0; i < GetGenes(); ++i)

for (j = (i + 1); j < GetGenes(); ++j)

if (CMeta::IsNaN(d = Get(i, j)))

Set(i, j, 0);

else if (!d)

Set(i, j, CMeta::GetNaN());

if (fIncident) {

vector<float> vecfNegatives;

vecfNegatives.resize(GetGenes());

fill(vecfNegatives.begin(), vecfNegatives.end(), false);

for (i = 0; i < vecfNegatives.size(); ++i)

for (j = 0; j < vecpNonnegatives.size(); ++j)

if (vecpNonnegatives[j]->IsGene(GetGene(i))) {

vecfNegatives[i] = true;

break;

}

for (i = 0; i < GetGenes(); ++i) {

if (vecfNegatives[i])

continue;

for (j = (i + 1); j < GetGenes(); ++j)

if (!(vecfNegatives[j] || Get(i, j)))

Set(i, j, CMeta::GetNaN());

}

}

}

return true;

vector <size_t> veciGenes;

size_t i, j, iOne, iTwo;

veciGenes.resize(pGenes->GetGenes());

for (i = 0; i < veciGenes.size(); ++i)

veciGenes[i] = GetGene(pGenes->GetGene(i).GetName());

for (i = 0; i < veciGenes.size(); ++i) {

iOne = veciGenes[i];

for (j = (i + 1); j < veciGenes.size(); ++j) {

iTwo = veciGenes[j];

if (CMeta::IsNaN(Get(iOne, iTwo)))

Set(iOne, iTwo, dValue);

}

}

vector <size_t> veciOne, veciTwo;

size_t i, j, iOne, iTwo;

veciOne.resize(pOne->GetGenes());

for (i = 0; i < veciOne.size(); ++i)

veciOne[i] = GetGene(pOne->GetGene(i).GetName());

veciTwo.resize(pTwo->GetGenes());

for (i = 0; i < veciTwo.size(); ++i)

veciTwo[i] = GetGene(pTwo->GetGene(i).GetName());

for (i = 0; i < veciOne.size(); ++i) {

iOne = veciOne[i];

for (j = 0; j < veciTwo.size(); ++j) {

iTwo = veciTwo[j];

if (CMeta::IsNaN(Get(iOne, iTwo)))

Set(iOne, iTwo, dValue);

}

}

bool fZScore, bool fSeek) {

switch (eFormat) {

case EFormatText:

return OpenText(istm, dDefault, fDuplicates);

case EFormatPCL:

return OpenPCL(istm, iSkip, fZScore);

case EFormatSparse:

return OpenSparse(istm);

case EFormatQdab:

return OpenQdab(istm);

default:

break;

}

if (fSeek) {

m_fSeek = true;

}

return OpenBinary(istm, fSeek);

Reset();

m_pPCL = new CPCL();

if (!m_pPCL->Open(istm, iSkip))

return false;

m_pMeasure = new CMeasurePearNorm();

m_fMeasureMemory = true;

if (fZScore) {

size_t iN;

double dAve, dStd;

AveStd(dAve, dStd, iN);

delete m_pMeasure;

m_pMeasure = new CMeasurePearNorm(dAve, dStd);

}

return true;

Reset();

m_pPCL = (CPCL *) &PCL;

m_fPCLMemory = false;

m_pMeasure = pMeasure;

m_fMeasureMemory = fMeasureMemory;

return true;

const char *pc;

char *pcTail;

char *acBuf;

string strToken, strCache, strValue;

TMapStrI mapGenes;

size_t iOne, iTwo, i;

float dScore;

TAAF vecvecfScores;

Reset();

acBuf = new char[c_iBufferSize];

while (istm.peek() != EOF) {

istm.getline(acBuf, c_iBufferSize - 1);

strToken = OpenToken(acBuf, &pc);

if (!strToken.length())

break;

if (strToken == c_acComment)

continue;

if (strToken != strCache) {

strCache = strToken;

iOne = MapGene(mapGenes, m_vecstrGenes, strToken);

}

strToken = OpenToken(pc, &pc);

if (!strToken.length()) {

Reset();

delete[] acBuf;

return false;

}

iTwo = MapGene(mapGenes, m_vecstrGenes, strToken);

strValue = OpenToken(pc);

if (!strValue.length()) {

if (CMeta::IsNaN(dScore = dDefault)) {

Reset();

delete[] acBuf;

return false;

}

} else if (!(dScore = (float) strtod(strValue.c_str(), &pcTail)) &&

(pcTail != (strValue.c_str() + strValue.length()))) {

Reset();

delete[] acBuf;

return false;

}

i = ((iOne > iTwo) ? iOne : iTwo);

if (vecvecfScores.size() <= i)

vecvecfScores.resize(i + 1);

ResizeNaN(vecvecfScores[iOne], i);

ResizeNaN(vecvecfScores[iTwo], i);

if (!CMeta::IsNaN(vecvecfScores[iOne][iTwo]) && (vecvecfScores[iOne][iTwo] != dScore)) {

g_CatSleipnir().error("CDatImpl::OpenText( ) duplicate genes %s, %s (%g:%g)",

strCache.c_str(), strToken.c_str(), vecvecfScores[iOne][iTwo],

dScore);

if (!fDuplicates) {

Reset();

delete[] acBuf;

return false;

}

}

vecvecfScores[iOne][iTwo] = vecvecfScores[iTwo][iOne] = dScore;

}

delete[] acBuf;

m_Data.Initialize(GetGenes());

for (iOne = 0; iOne < GetGenes(); ++iOne)

for (iTwo = (iOne + 1); iTwo < GetGenes(); ++iTwo)

Set(iOne, iTwo, ((iTwo < vecvecfScores[iOne].size()) ?

vecvecfScores[iOne][iTwo] : CMeta::GetNaN()));

return true;

size_t i;

float *adScores;

if (fSeek) {

if (!OpenHeader(istm)) {

cerr << "Error opening header" << endl;

return false;

}

return true;

}

if (!OpenGenes(istm, true, false))

return false;

g_CatSleipnir().debug("Reading genes");

m_Data.Initialize(GetGenes());

adScores = new float[GetGenes() - 1];

for (i = 0; (i + 1) < GetGenes(); ++i) {

istm.read((char *) adScores, sizeof(*adScores) * (GetGenes() - i - 1));

Set(i, adScores);

}

delete[] adScores;

return true;

if (!m_fSeek) {

cerr << "Don't know how you got here" << endl;

}

if (!OpenGenes(istm, true, false)) {

return false;

}

EstimateSeekPositions(istm);

return true;

size_t iTotal, i, j, num_bins, num_bits, iPos;

float *adScores;

unsigned char tmp;

float *bounds;

unsigned char btmpf;

unsigned char btmpb;

unsigned char bufferA;

unsigned char bufferB;

float nan_val;

if (!OpenGenes(istm, true, false))

return false;

m_Data.Initialize(GetGenes());

// read the number of bins

istm.read((char *) &tmp, sizeof(char));

num_bins = (size_t) tmp;

//read the bin boundaries

bounds = new float[num_bins];

istm.read((char *) bounds, sizeof(float) * num_bins);

// number of bits required for each bin representation

num_bits = (size_t) ceil(log(num_bins) / log(2.0));

// add one more bit for NaN case

if (pow(2, num_bits) == num_bins)

++num_bits;

// set nan value

nan_val = pow(2, num_bits) - 1;

// read the data

adScores = new float[GetGenes() - 1];

istm.read((char *) &bufferA, sizeof(bufferA));

istm.read((char *) &bufferB, sizeof(bufferB));

for (iTotal = i = 0; (i + 1) < GetGenes(); ++i) {

for (j = 0; j < (GetGenes() - i - 1); ++j) {

iPos = (iTotal * num_bits) % 8;

// check bit data overflow??

if (iPos + num_bits > 8) {

btmpb = (bufferA << iPos);

btmpf = (bufferB >> (16 - num_bits - iPos)) << (8 - num_bits);

adScores[j] = ((btmpb | btmpf) >> (8 - num_bits));

++iTotal;

bufferA = bufferB;

istm.read((char *) &bufferB, sizeof(bufferB));

} else {

adScores[j] = (((bufferA << iPos) & 0xFF) >> (8 - num_bits));

++iTotal;

if (iPos + num_bits == 8) {

bufferA = bufferB;

istm.read((char *) &bufferB, sizeof(bufferB));

}

}

// check if value added was promised 2^#bits -1 (NaN value)

if (adScores[j] == nan_val)

adScores[j] = CMeta::GetNaN();

}

Set(i, adScores);

}

delete[] adScores;

delete[] bounds;

return true;

size_t i;

uint32_t j;

float d;

if (!OpenGenes(istm, true, false))

return false;

m_Data.Initialize(GetGenes());

for (i = 0; (i + 1) < GetGenes(); ++i) {

for (j = (i + 1); j < GetGenes(); ++j)

Set(i, j, CMeta::GetNaN());

while (true) {

istm.read((char *) &j, sizeof(j));

if (j == -1)

break;

istm.read((char *) &d, sizeof(d));

Set(i, j, d);

}

}

return true;

ifstream ifsm;

bool fBinary;

size_t i;

EFormat eFormat;

for (i = 0; c_asFormats[i].m_szExtension; ++i)

if (!strcmp(szFile + strlen(szFile) - strlen(c_asFormats[i].m_szExtension),

c_asFormats[i].m_szExtension))

break;

eFormat = c_asFormats[i].m_eFormat;

fBinary = (eFormat != EFormatText) && (eFormat != EFormatPCL);

ifsm.open(szFile, fBinary ? ios_base::binary : ios_base::in);

return OpenGenes(ifsm, fBinary, (eFormat == EFormatPCL));

size_t i, iToken;

uint32_t iCount;

string strToken, strCache;

float d;

const char *pc;

char *acBuf;

Reset();

if (fPCL) {

m_pPCL = new CPCL();

if (m_pPCL->Open(istm)) {

m_pMeasure = (IMeasure *) 1;

m_fMeasureMemory = false;

return true;

}

return false;

}

acBuf = new char[c_iBufferSize];

if (fBinary) {

istm.read((char *) &iCount, sizeof(iCount));

if (iCount > c_iGeneLimit) {

delete[] acBuf;

return false;

}

m_vecstrGenes.resize(iCount);

for (i = 0; i < iCount; ++i) {

DabGene(istm, acBuf);

m_vecstrGenes[i] = acBuf;

m_mapstrGenes[acBuf] = i;

}

} else {

set <string> setstrGenes;

set<string>::const_iterator iterGenes;

while (istm.peek() != EOF) {

istm.getline(acBuf, c_iBufferSize - 1);

for (iToken = 0; iToken < 3; ++iToken) {

strToken = OpenToken(acBuf, &pc);

if (!strToken.length())

break;

if (strToken != strCache) {

strCache = strToken;