/** Read block from file located on a exFAT file system.
*
* @param block Pointer to a block pointer for storing result.
* @param bs Buffer holding the boot sector of the file system.
* @param service_id Service ID of the file system.
* @param fcl First cluster used by the file. Can be zero if the file
* is empty.
* @param clp If not NULL, address where the cluster containing bn
* will be stored.
* stored
* @param bn Block number.
* @param flags Flags passed to libblock.
*
* @return EOK on success or a negative error code.
*/
int
exfat_block_get_by_clst(block_t **block, exfat_bs_t *bs,
service_id_t service_id, bool fragmented, exfat_cluster_t fcl,
exfat_cluster_t *clp, aoff64_t bn, int flags)
{
uint32_t clusters;
uint32_t max_clusters;
exfat_cluster_t c;
int rc;
if (fcl < EXFAT_CLST_FIRST || fcl > DATA_CNT(bs) + 2)
return ELIMIT;
if (!fragmented) {
rc = block_get(block, service_id, DATA_FS(bs) +
(fcl - EXFAT_CLST_FIRST)*SPC(bs) + bn, flags);
} else {
max_clusters = bn / SPC(bs);
rc = exfat_cluster_walk(bs, service_id, fcl, &c, &clusters, max_clusters);
if (rc != EOK)
return rc;
assert(clusters == max_clusters);
rc = block_get(block, service_id, DATA_FS(bs) +
(c - EXFAT_CLST_FIRST) * SPC(bs) + (bn % SPC(bs)), flags);
if (clp)
*clp = c;
}
return rc;
}
fileData::fileData(WIN32_FIND_DATAA& fd, const char* _path)
{
dwFileAttributes = fd.dwFileAttributes;
ftCreationTime = fd.ftCreationTime;
ftLastAccessTime = fd.ftLastAccessTime;
ftLastWriteTime = fd.ftLastWriteTime;
fileSize = (((ULONGLONG)fd.nFileSizeHigh) << 32) + fd.nFileSizeLow;
cFileName = SPC(cc(fd.cFileName));
path = SPC(cc(_path));
FileTimetoString(fd.ftCreationTime, creationTime);
}
int maildir_search_start_str_chset(struct maildir_searchengine *engine,
const char *string,
const char *chset)
{
#define SPC(s) ((s) == ' '|| (s) == '\t' || (s) == '\r' || (s) == '\n')
unicode_char *ucptr;
size_t ucsize;
unicode_convert_handle_t h=unicode_convert_tou_init(chset, &ucptr,
&ucsize, 1);
size_t i, j;
int rc;
if (h == NULL)
return -1;
if (unicode_convert(h, string, strlen(string)))
{
unicode_convert_deinit(h, NULL);
return -1;
}
if (unicode_convert_deinit(h, NULL))
return -1;
for (i=j=0; ucptr[i]; )
{
while (SPC(ucptr[i]))
++i;
if (!ucptr[i])
break;
while (ucptr[i])
{
ucptr[j]=unicode_lc(ucptr[i]);
++j;
if (SPC(ucptr[i]))
break;
++i;
}
}
while (j > 0 && SPC(ucptr[j-1]))
--j;
ucptr[j]=0;
rc=maildir_search_start_unicode(engine, ucptr);
free(ucptr);
return rc;
}
void Expression2PresentationMMLUnits::writeMathMLBox(std::ostream & out, const std::string & a, const std::string & b,
const std::string & color, unsigned int l) const
{
out << SPC(l) << "<mstyle background=\"" << color << "\"><mfrac linethickness=\"0\">" << std::endl;
out << a;
out << SPC(l + 1) << "<mstyle scriptlevel=\"+1\">" << std::endl;
out << SPC(l + 2) << b << std::endl;
out << SPC(l + 1) << "</mstyle>" << std::endl;
out << SPC(l) << "</mfrac></mstyle>" << std::endl;
//formating is done so that it looks best when a is already indented nicely while b
//is just a one line string
}
void CFunction::writeMathML(std::ostream & out,
const std::vector<std::vector<std::string> > & env,
bool expand, bool fullExpand,
unsigned C_INT32 l) const
{
if (expand && mpRoot)
{
bool flag = false; //TODO include check if parantheses are necessary
if (flag) out << SPC(l) << "<mfenced>" << std::endl;
mpRoot->writeMathML(out, env, fullExpand, l + 1);
if (flag) out << SPC(l) << "</mfenced>" << std::endl;
}
else //no expand
{
out << SPC(l) << "<mrow>" << std::endl;
out << SPC(l + 1) << CMathMl::fixName(getObjectName()) << std::endl;
out << SPC(l + 1) << "<mfenced>" << std::endl;
unsigned C_INT32 i, imax = getVariables().size();
for (i = 0; i < imax; ++i)
{
out << SPC(l + 2) << env[i][0] << std::endl;
}
out << SPC(l + 1) << "</mfenced>" << std::endl;
out << SPC(l) << "</mrow>" << std::endl;
}
}
/** Read block from file located on a FAT file system.
*
* @param block Pointer to a block pointer for storing result.
* @param bs Buffer holding the boot sector of the file system.
* @param nodep FAT node.
* @param bn Block number.
* @param flags Flags passed to libblock.
*
* @return EOK on success or a negative error code.
*/
int
fat_block_get(block_t **block, struct fat_bs *bs, fat_node_t *nodep,
aoff64_t bn, int flags)
{
fat_cluster_t firstc = nodep->firstc;
fat_cluster_t currc;
aoff64_t relbn = bn;
int rc;
if (!nodep->size)
return ELIMIT;
if (!FAT_IS_FAT32(bs) && nodep->firstc == FAT_CLST_ROOT)
goto fall_through;
if (((((nodep->size - 1) / BPS(bs)) / SPC(bs)) == bn / SPC(bs)) &&
nodep->lastc_cached_valid) {
/*
* This is a request to read a block within the last cluster
* when fortunately we have the last cluster number cached.
*/
return block_get(block, nodep->idx->service_id,
CLBN2PBN(bs, nodep->lastc_cached_value, bn), flags);
}
if (nodep->currc_cached_valid && bn >= nodep->currc_cached_bn) {
/*
* We can start with the cluster cached by the previous call to
* fat_block_get().
*/
firstc = nodep->currc_cached_value;
relbn -= (nodep->currc_cached_bn / SPC(bs)) * SPC(bs);
}
fall_through:
rc = _fat_block_get(block, bs, nodep->idx->service_id, firstc,
&currc, relbn, flags);
if (rc != EOK)
return rc;
/*
* Update the "current" cluster cache.
*/
nodep->currc_cached_valid = true;
nodep->currc_cached_bn = bn;
nodep->currc_cached_value = currc;
return rc;
}
int fat_directory_expand(fat_directory_t *di)
{
int rc;
fat_cluster_t mcl, lcl;
if (!FAT_IS_FAT32(di->bs) && di->nodep->firstc == FAT_CLST_ROOT) {
/* Can't grow the root directory on FAT12/16. */
return ENOSPC;
}
rc = fat_alloc_clusters(di->bs, di->nodep->idx->service_id, 1, &mcl,
&lcl);
if (rc != EOK)
return rc;
rc = fat_zero_cluster(di->bs, di->nodep->idx->service_id, mcl);
if (rc != EOK) {
(void) fat_free_clusters(di->bs, di->nodep->idx->service_id,
mcl);
return rc;
}
rc = fat_append_clusters(di->bs, di->nodep, mcl, lcl);
if (rc != EOK) {
(void) fat_free_clusters(di->bs, di->nodep->idx->service_id,
mcl);
return rc;
}
di->nodep->size += BPS(di->bs) * SPC(di->bs);
di->nodep->dirty = true; /* need to sync node */
di->blocks = di->nodep->size / BPS(di->bs);
return EOK;
}
void CEvaluationNodeObject::writeMathML(std::ostream & out,
const std::vector<std::vector<std::string> > & /* env */,
bool /* expand */,
unsigned C_INT32 l) const
{
out << SPC(l) << CMathMl::getMMLName(mpObject) << std::endl;
}
void CMMLOutput::writeLHS_ModelValue(std::ostream & out,
const std::string & valueName, size_t l)
{
out << SPC(l + 0) << "<mfrac>" << std::endl;
out << SPC(l + 1) << "<mrow>" << std::endl;
out << SPC(l + 2) << "<mo>d</mo>" << std::endl;
out << SPC(l + 2) << "<mi>" << CMathMl::fixName(valueName) << "</mi>" << std::endl;
out << SPC(l + 1) << "</mrow>" << std::endl;
out << SPC(l + 1) << "<mrow>" << std::endl;
out << SPC(l + 2) << "<mo>d</mo><mi>t</mi>" << std::endl;
out << SPC(l + 1) << "</mrow>" << std::endl;
out << SPC(l + 0) << "</mfrac>" << std::endl;
}
void Expression2PresentationMMLUnits::writeMathMLBox(std::ostream & out, const std::string & a, const std::string & b, const std::string & c,
const std::string & color, size_t l) const
{
out << SPC(l) << "<mstyle background=\"" << color << "\"><mtable rowspacing=\"0.1 ex\">" << std::endl;
out << SPC(l + 1) << "<mtr><mtd>" << std::endl;
out << a;
out << SPC(l + 1) << "</mtd></mtr>" << std::endl;
out << SPC(l + 1) << "<mtr><mtd><mstyle scriptlevel=\"+1\">" << std::endl;
out << SPC(l + 2) << b << std::endl;
out << SPC(l + 1) << "</mstyle></mtd></mtr>" << std::endl;
out << SPC(l + 1) << "<mtr><mtd><mstyle scriptlevel=\"+1\">" << std::endl;
out << SPC(l + 2) << c << std::endl;
out << SPC(l + 1) << "</mstyle></mtd></mtr>" << std::endl;
out << SPC(l) << "</mtable></mstyle>" << std::endl;
//formating is done so that it looks best when a is already indented nicely while b
//is just a one line string
}
void CMMLOutput::writeRHS_ModelEntity(std::ostream & out,
const CModelEntity* pEntity,
bool expandFull, size_t l)
{
if (!pEntity)
{
out << SPC(l + 0) << "Error: invalid model entity" << std::endl;
return;
}
if (!pEntity->getExpressionPtr())
{
out << SPC(l + 0) << "Error: no expression" << std::endl;
return;
}
out << SPC(l + 0) << "<mrow>" << std::endl;
pEntity->getExpressionPtr()->writeMathML(out, expandFull, l + 1);
out << SPC(l + 0) << "</mrow>" << std::endl;
}
void CArrayAnnotation::printRecursively(std::ostream & ostream, size_t level,
CCopasiAbstractArray::index_type & index,
const std::vector<std::vector<std::string> > & display) const
{
size_t indent = 2 * (dimensionality() - 1 - level);
if (level == 0) //only vector
{
ostream << SPC(indent) << "Rows: " << getDimensionDescription(level) << "\n";
size_t imax = size()[0];
for (index[0] = 0; index[0] < imax; ++index[0])
ostream << SPC(indent) << display[0][index[0]] << "\t" << (*array())[index] << "\n";
}
else if (level == 1) //matrix
{
ostream << SPC(indent) << "Rows: " << getDimensionDescription(level - 1) << "\n";
ostream << SPC(indent) << "Columns: " << getDimensionDescription(level) << "\n";
size_t imax = size()[0];
size_t jmax = size()[1];
ostream << SPC(indent);
for (index[1] = 0; index[1] < jmax; ++index[1])
ostream << "\t" << display[1][index[1]];
ostream << "\n";
for (index[0] = 0; index[0] < imax; ++index[0])
{
ostream << SPC(indent) << display[0][index[0]];
for (index[1] = 0; index[1] < jmax; ++index[1])
ostream << "\t" << (*array())[index];
ostream << "\n";
}
}
else //dimensionality > 2
{
size_t i, imax = size()[level];
for (i = 0; i < imax; ++i)
{
ostream << SPC(indent) << getDimensionDescription(level) << ": " << display[level][i] << "\n";
index[level] = i;
printRecursively(ostream, level - 1, index, display);
}
}
}
/** Fill the gap between EOF and a new file position.
*
* @param bs Buffer holding the boot sector for nodep.
* @param nodep FAT node with the gap.
* @param mcl First cluster in an independent cluster chain that will
* be later appended to the end of the node's own cluster
* chain. If pos is still in the last allocated cluster,
* this argument is ignored.
* @param pos Position in the last node block.
*
* @return EOK on success or a negative error code.
*/
int
fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, aoff64_t pos)
{
block_t *b;
aoff64_t o, boundary;
int rc;
boundary = ROUND_UP(nodep->size, BPS(bs) * SPC(bs));
/* zero out already allocated space */
for (o = nodep->size; o < pos && o < boundary;
o = ALIGN_DOWN(o + BPS(bs), BPS(bs))) {
int flags = (o % BPS(bs) == 0) ?
BLOCK_FLAGS_NOREAD : BLOCK_FLAGS_NONE;
rc = fat_block_get(&b, bs, nodep, o / BPS(bs), flags);
if (rc != EOK)
return rc;
memset(b->data + o % BPS(bs), 0, BPS(bs) - o % BPS(bs));
b->dirty = true; /* need to sync node */
rc = block_put(b);
if (rc != EOK)
return rc;
}
if (o >= pos)
return EOK;
/* zero out the initial part of the new cluster chain */
for (o = boundary; o < pos; o += BPS(bs)) {
rc = _fat_block_get(&b, bs, nodep->idx->service_id, mcl,
NULL, (o - boundary) / BPS(bs), BLOCK_FLAGS_NOREAD);
if (rc != EOK)
return rc;
memset(b->data, 0, min(BPS(bs), pos - o));
b->dirty = true; /* need to sync node */
rc = block_put(b);
if (rc != EOK)
return rc;
}
return EOK;
}
/** Read block from file located on a exFAT file system.
*
* @param block Pointer to a block pointer for storing result.
* @param bs Buffer holding the boot sector of the file system.
* @param nodep FAT node.
* @param bn Block number.
* @param flags Flags passed to libblock.
*
* @return EOK on success or a negative error code.
*/
int
exfat_block_get(block_t **block, exfat_bs_t *bs, exfat_node_t *nodep,
aoff64_t bn, int flags)
{
exfat_cluster_t firstc = nodep->firstc;
exfat_cluster_t currc = 0;
aoff64_t relbn = bn;
int rc;
if (!nodep->size)
return ELIMIT;
if (nodep->fragmented) {
if (((((nodep->size - 1) / BPS(bs)) / SPC(bs)) == bn / SPC(bs)) &&
nodep->lastc_cached_valid) {
/*
* This is a request to read a block within the last cluster
* when fortunately we have the last cluster number cached.
*/
return block_get(block, nodep->idx->service_id, DATA_FS(bs) +
(nodep->lastc_cached_value-EXFAT_CLST_FIRST)*SPC(bs) +
(bn % SPC(bs)), flags);
}
if (nodep->currc_cached_valid && bn >= nodep->currc_cached_bn) {
/*
* We can start with the cluster cached by the previous call to
* fat_block_get().
*/
firstc = nodep->currc_cached_value;
relbn -= (nodep->currc_cached_bn / SPC(bs)) * SPC(bs);
}
}
rc = exfat_block_get_by_clst(block, bs, nodep->idx->service_id,
nodep->fragmented, firstc, &currc, relbn, flags);
if (rc != EOK)
return rc;
/*
* Update the "current" cluster cache.
*/
nodep->currc_cached_valid = true;
nodep->currc_cached_bn = bn;
nodep->currc_cached_value = currc;
return rc;
}
int
exfat_zero_cluster(exfat_bs_t *bs, service_id_t service_id, exfat_cluster_t c)
{
size_t i;
block_t *b;
int rc;
for (i = 0; i < SPC(bs); i++) {
rc = exfat_block_get_by_clst(&b, bs, service_id, false, c, NULL,
i, BLOCK_FLAGS_NOREAD);
if (rc != EOK)
return rc;
memset(b->data, 0, BPS(bs));
b->dirty = true;
rc = block_put(b);
if (rc != EOK)
return rc;
}
return EOK;
}
/** Read block from file located on a FAT file system.
*
* @param block Pointer to a block pointer for storing result.
* @param bs Buffer holding the boot sector of the file system.
* @param service_id Service ID handle of the file system.
* @param fcl First cluster used by the file. Can be zero if the file
* is empty.
* @param clp If not NULL, address where the cluster containing bn
* will be stored.
* stored
* @param bn Block number.
* @param flags Flags passed to libblock.
*
* @return EOK on success or a negative error code.
*/
int
_fat_block_get(block_t **block, fat_bs_t *bs, service_id_t service_id,
fat_cluster_t fcl, fat_cluster_t *clp, aoff64_t bn, int flags)
{
uint32_t clusters;
uint32_t max_clusters;
fat_cluster_t c;
int rc;
/*
* This function can only operate on non-zero length files.
*/
if (fcl == FAT_CLST_RES0)
return ELIMIT;
if (!FAT_IS_FAT32(bs) && fcl == FAT_CLST_ROOT) {
/* root directory special case */
assert(bn < RDS(bs));
rc = block_get(block, service_id,
RSCNT(bs) + FATCNT(bs) * SF(bs) + bn, flags);
return rc;
}
max_clusters = bn / SPC(bs);
rc = fat_cluster_walk(bs, service_id, fcl, &c, &clusters, max_clusters);
if (rc != EOK)
return rc;
assert(clusters == max_clusters);
rc = block_get(block, service_id, CLBN2PBN(bs, c, bn), flags);
if (clp)
*clp = c;
return rc;
}
void CFunction::writeMathML(std::ostream & out, unsigned C_INT32 l) const
{
//out << "<math>" << std::endl;
out << SPC(l) << "<mrow>" << std::endl;
out << SPC(l + 1) << CMathMl::fixName(getObjectName()) << std::endl;
out << SPC(l + 1) << "<mfenced>" << std::endl;
unsigned C_INT32 i, imax = getVariables().size();
for (i = 0; i < imax; ++i)
{
out << SPC(l + 2) << "<mi>" << getVariables()[i]->getObjectName() << "</mi>" << std::endl;
}
out << SPC(l + 1) << "</mfenced>" << std::endl;
out << SPC(l) << "</mrow>" << std::endl;
//out << "</math>" << std::endl;
}
void CEvaluationNodeLogical::writeMathML(std::ostream & out,
const std::vector<std::vector<std::string> > & env,
bool expand,
unsigned C_INT32 l) const
{
if (const_cast<CEvaluationNodeLogical *>(this)->compile(NULL))
{
std::string data = "";
bool flag = false;
switch ((SubType)CEvaluationNode::subType(this->getType()))
{
case AND:
data = " and ";
break;
case OR:
data = " or ";
break;
case XOR:
data = " xor ";
break;
case EQ:
data = "=";
break;
case GE:
data = ">=";
break;
case GT:
data = ">";
break;
case LE:
data = "<=";
break;
case LT:
data = "<";
break;
case NE:
data = "≠";
break;
default:
/*
*
*/
data = "@";
break;
}
out << SPC(l) << "<mrow>" << std::endl;
flag = ((*mpLeft < *(CEvaluationNode *)this));
if (flag) out << SPC(l + 1) << "<mfenced>" << std::endl;
mpLeft->writeMathML(out, env, expand, l + 1);
if (flag) out << SPC(l + 1) << "</mfenced>" << std::endl;
out << SPC(l + 1) << "<mo>" << data << "</mo>" << std::endl;
flag = ((*(CEvaluationNode *)this < *mpRight));
if (!flag) out << SPC(l + 1) << "<mfenced>" << std::endl;
mpRight->writeMathML(out, env, expand, l + 1);
if (!flag) out << SPC(l + 1) << "</mfenced>" << std::endl;
out << SPC(l) << "</mrow>" << std::endl;
}
}
void CMMLOutput::writeLHS(std::ostream & out,
const std::string & metabName,
const std::string & compName, size_t l)
{
out << SPC(l + 0) << "<mfrac>" << std::endl;
out << SPC(l + 1) << "<mrow>" << std::endl;
out << SPC(l + 2) << "<mo>d</mo>" << std::endl;
out << SPC(l + 2) << "<mfenced>" << std::endl;
out << SPC(l + 3) << "<mrow>" << std::endl;
//out << SPC(l + 4) << "<mi>" << CMathMl::fixName(metabName) << "</mi>" << std::endl;
out << SPC(l + 4) << "<mi>[" << CMathMl::fixName(metabName) << "]</mi>" << std::endl;
out << SPC(l + 4) << "<mo>" << "·" << "</mo>" << std::endl;
out << SPC(l + 4) << "<msub><mi>V</mi><mi>" << CMathMl::fixName(compName) << "</mi></msub>" << std::endl;
out << SPC(l + 3) << "</mrow>" << std::endl;
out << SPC(l + 2) << "</mfenced>" << std::endl;
out << SPC(l + 1) << "</mrow>" << std::endl;
out << SPC(l + 1) << "<mrow>" << std::endl;
out << SPC(l + 2) << "<mo>d</mo><mi>t</mi>" << std::endl;
out << SPC(l + 1) << "</mrow>" << std::endl;
out << SPC(l + 0) << "</mfrac>" << std::endl;
}
void CMMLOutput::writeDifferentialEquations(std::ostream & mml, CModel * model, bool localParameterNumbers, bool expand, bool expandFull)
{
bool hasContents = false;
//mml.str("");
size_t l = 0;
mml << SPC(l) << "<mtable>" << std::endl;
//write equations for compartments
size_t i, imax = model->getCompartments().size();
for (i = 0; i < imax; i++)
{
if (model->getCompartments()[i]->getStatus() == CModelEntity::ODE)
{
mml << SPC(l + 1) << "<mtr>" << std::endl;
//first column (lhs)
mml << SPC(l + 2) << "<mtd>" << std::endl;
mml << SPC(l + 3) << "<mfrac>" << std::endl;
mml << SPC(l + 4) << "<mrow>" << std::endl;
mml << SPC(l + 5) << "<mo>d</mo>" << std::endl;
mml << SPC(l + 5) << "<msub><mi>V</mi><mi>"
<< CMathMl::fixName(model->getCompartments()[i]->getObjectName())
<< "</mi></msub>" << std::endl;
mml << SPC(l + 4) << "</mrow>" << std::endl;
mml << SPC(l + 3) << "<mrow>" << std::endl;
mml << SPC(l + 2) << "<mo>d</mo><mi>t</mi>" << std::endl;
mml << SPC(l + 1) << "</mrow>" << std::endl;
mml << SPC(l + 0) << "</mfrac>" << std::endl;
mml << SPC(l + 2) << "</mtd>" << std::endl;
//second column ("=")
mml << SPC(l + 2) << "<mtd>" << std::endl;
mml << SPC(l + 3) << "<mo>=</mo>" << std::endl;
mml << SPC(l + 2) << "</mtd>" << std::endl;
//third column (rhs)
mml << SPC(l + 2) << "<mtd columnalign='left'>" << std::endl;
writeRHS_ModelEntity(mml, model->getCompartments()[i],
expandFull, l + 3);
mml << SPC(l + 2) << "</mtd>" << std::endl;
mml << SPC(l + 1) << "</mtr>" << std::endl;
}
else if (model->getCompartments()[i]->getStatus() == CModelEntity::ASSIGNMENT)
{
mml << SPC(l + 1) << "<mtr>" << std::endl;
//first column (lhs)
mml << SPC(l + 2) << "<mtd>" << std::endl;
mml << SPC(l + 3) << "<msub><mi>V</mi><mi>"
<< CMathMl::fixName(model->getCompartments()[i]->getObjectName())
<< "</mi></msub>" << std::endl;
mml << SPC(l + 2) << "</mtd>" << std::endl;
//second column ("=")
mml << SPC(l + 2) << "<mtd>" << std::endl;
mml << SPC(l + 3) << "<mo>=</mo>" << std::endl;
mml << SPC(l + 2) << "</mtd>" << std::endl;
//third column (rhs)
mml << SPC(l + 2) << "<mtd columnalign='left'>" << std::endl;
writeRHS_ModelEntity(mml, model->getCompartments()[i],
expandFull, l + 3);
mml << SPC(l + 2) << "</mtd>" << std::endl;
mml << SPC(l + 1) << "</mtr>" << std::endl;
}
}
//write equations for metabs
imax = model->getMetabolites().size();
for (i = 0; i < imax; i++)
{
if (model->getMetabolites()[i]->getStatus() == CModelEntity::REACTIONS)
{
std::set<std::string> reacKeys = listReactionsForMetab(model, model->getMetabolites()[i]->getKey());
std::set<std::string>::const_iterator it, itEnd = reacKeys.end();
for (it = reacKeys.begin(); it != itEnd; ++it)
{
hasContents = true;
mml << SPC(l + 1) << "<mtr>" << std::endl;
//first column (lhs)
mml << SPC(l + 2) << "<mtd>" << std::endl;
if (it == reacKeys.begin())
writeLHS(mml, model->getMetabolites()[i]->getObjectDisplayName(),
model->getMetabolites()[i]->getCompartment()->getObjectName(), l + 3);
mml << SPC(l + 2) << "</mtd>" << std::endl;
//second column ("=")
mml << SPC(l + 2) << "<mtd>" << std::endl;
if (it == reacKeys.begin())
mml << SPC(l + 3) << "<mo>=</mo>" << std::endl;
mml << SPC(l + 2) << "</mtd>" << std::endl;
//third column (rhs)
mml << SPC(l + 2) << "<mtd columnalign='left'>" << std::endl;
writeRHS(mml, model->getMetabolites()[i],
dynamic_cast<CReaction*>(CCopasiRootContainer::getKeyFactory()->get(*it)) ,
localParameterNumbers, expand, expandFull, l + 3);
mml << SPC(l + 2) << "</mtd>" << std::endl;
mml << SPC(l + 1) << "</mtr>" << std::endl;
}
}
else if (model->getMetabolites()[i]->getStatus() == CModelEntity::ODE)
{
mml << SPC(l + 1) << "<mtr>" << std::endl;
//first column (lhs)
mml << SPC(l + 2) << "<mtd>" << std::endl;
writeLHS(mml, model->getMetabolites()[i]->getObjectDisplayName(),
model->getMetabolites()[i]->getCompartment()->getObjectName(), l + 3);
mml << SPC(l + 2) << "</mtd>" << std::endl;
//second column ("=")
mml << SPC(l + 2) << "<mtd>" << std::endl;
mml << SPC(l + 3) << "<mo>=</mo>" << std::endl;
mml << SPC(l + 2) << "</mtd>" << std::endl;
//third column (rhs)
mml << SPC(l + 2) << "<mtd columnalign='left'>" << std::endl;
std::string compName = model->getMetabolites()[i]->getCompartment()->getObjectName();
mml << SPC(l + 3) << "<msub><mi>V</mi><mi>" << CMathMl::fixName(compName)
<< "</mi></msub>" << std::endl;
mml << SPC(l + 3) << "<mo>" << "·" << "</mo>" << std::endl;
writeRHS_ModelEntity(mml, model->getMetabolites()[i],
expandFull, l + 3);
mml << SPC(l + 2) << "</mtd>" << std::endl;
mml << SPC(l + 1) << "</mtr>" << std::endl;
}
else if (model->getMetabolites()[i]->getStatus() == CModelEntity::ASSIGNMENT)
{
mml << SPC(l + 1) << "<mtr>" << std::endl;
//first column (lhs)
mml << SPC(l + 2) << "<mtd>" << std::endl;
mml << SPC(l + 3) << "<mi>" << CMathMl::fixName("[" + model->getMetabolites()[i]->getObjectName() + "]") << "</mi>" << std::endl;
mml << SPC(l + 2) << "</mtd>" << std::endl;
//second column ("=")
mml << SPC(l + 2) << "<mtd>" << std::endl;
mml << SPC(l + 3) << "<mo>=</mo>" << std::endl;
mml << SPC(l + 2) << "</mtd>" << std::endl;
//third column (rhs)
mml << SPC(l + 2) << "<mtd columnalign='left'>" << std::endl;
writeRHS_ModelEntity(mml, model->getMetabolites()[i],
expandFull, l + 3);
mml << SPC(l + 2) << "</mtd>" << std::endl;
mml << SPC(l + 1) << "</mtr>" << std::endl;
}
}
//write differential equations for model values
imax = model->getModelValues().size();
for (i = 0; i < imax; ++i)
if (model->getModelValues()[i]->getStatus() == CModelEntity::ODE)
{
hasContents = true;
mml << SPC(l + 1) << "<mtr>" << std::endl;
//first column (lhs)
mml << SPC(l + 2) << "<mtd columnalign='right'>" << std::endl;
writeLHS_ModelValue(mml, model->getModelValues()[i]->getObjectName(), l + 3);
mml << SPC(l + 2) << "</mtd>" << std::endl;
//second column ("=")
mml << SPC(l + 2) << "<mtd>" << std::endl;
mml << SPC(l + 3) << "<mo>=</mo>" << std::endl;
mml << SPC(l + 2) << "</mtd>" << std::endl;
//third column (rhs)
mml << SPC(l + 2) << "<mtd columnalign='left'>" << std::endl;
writeRHS_ModelEntity(mml, model->getModelValues()[i],
expandFull, l + 3);
mml << SPC(l + 2) << "</mtd>" << std::endl;
mml << SPC(l + 1) << "</mtr>" << std::endl;
}
//write assignment rules
imax = model->getModelValues().size();
for (i = 0; i < imax; ++i)
if (model->getModelValues()[i]->getStatus() == CModelEntity::ASSIGNMENT)
{
hasContents = true;
mml << SPC(l + 1) << "<mtr>" << std::endl;
//first column (lhs)
mml << SPC(l + 2) << "<mtd columnalign='right'>" << std::endl;
mml << SPC(l + 3) << "<mi>" << CMathMl::fixName(model->getModelValues()[i]->getObjectName()) << "</mi>" << std::endl;
//writeLHS_ModelValue(mml, model->getModelValues()[i]->getObjectName(), l + 3);
mml << SPC(l + 2) << "</mtd>" << std::endl;
//second column ("=")
mml << SPC(l + 2) << "<mtd>" << std::endl;
mml << SPC(l + 3) << "<mo>=</mo>" << std::endl;
mml << SPC(l + 2) << "</mtd>" << std::endl;
//third column (rhs)
mml << SPC(l + 2) << "<mtd columnalign='left'>" << std::endl;
writeRHS_ModelEntity(mml, model->getModelValues()[i],
expandFull, l + 3);
mml << SPC(l + 2) << "</mtd>" << std::endl;
mml << SPC(l + 1) << "</mtr>" << std::endl;
}
mml << SPC(l) << "</mtable>" << std::endl;
}
void btDbvtBroadphase::collide(btDispatcher* dispatcher)
{
/*printf("---------------------------------------------------------\n");
printf("m_sets[0].m_leaves=%d\n",m_sets[0].m_leaves);
printf("m_sets[1].m_leaves=%d\n",m_sets[1].m_leaves);
printf("numPairs = %d\n",getOverlappingPairCache()->getNumOverlappingPairs());
{
int i;
for (i=0;i<getOverlappingPairCache()->getNumOverlappingPairs();i++)
{
printf("pair[%d]=(%d,%d),",i,getOverlappingPairCache()->getOverlappingPairArray()[i].m_pProxy0->getUid(),
getOverlappingPairCache()->getOverlappingPairArray()[i].m_pProxy1->getUid());
}
printf("\n");
}
*/
SPC(m_profiling.m_total);
/* optimize */
m_sets[0].optimizeIncremental(1 + (m_sets[0].m_leaves * m_dupdates) / 100);
if (m_fixedleft)
{
const int count = 1 + (m_sets[1].m_leaves * m_fupdates) / 100;
m_sets[1].optimizeIncremental(1 + (m_sets[1].m_leaves * m_fupdates) / 100);
m_fixedleft = btMax<int>(0, m_fixedleft - count);
}
/* dynamic -> fixed set */
m_stageCurrent = (m_stageCurrent + 1) % STAGECOUNT;
btDbvtProxy* current = m_stageRoots[m_stageCurrent];
if (current)
{
#if DBVT_BP_ACCURATESLEEPING
btDbvtTreeCollider collider(this);
#endif
do
{
btDbvtProxy* next = current->links[1];
listremove(current, m_stageRoots[current->stage]);
listappend(current, m_stageRoots[STAGECOUNT]);
#if DBVT_BP_ACCURATESLEEPING
m_paircache->removeOverlappingPairsContainingProxy(current, dispatcher);
collider.proxy = current;
btDbvt::collideTV(m_sets[0].m_root, current->aabb, collider);
btDbvt::collideTV(m_sets[1].m_root, current->aabb, collider);
#endif
m_sets[0].remove(current->leaf);
ATTRIBUTE_ALIGNED16(btDbvtVolume)
curAabb = btDbvtVolume::FromMM(current->m_aabbMin, current->m_aabbMax);
current->leaf = m_sets[1].insert(curAabb, current);
current->stage = STAGECOUNT;
current = next;
} while (current);
m_fixedleft = m_sets[1].m_leaves;
m_needcleanup = true;
}
/* collide dynamics */
{
btDbvtTreeCollider collider(this);
if (m_deferedcollide)
{
SPC(m_profiling.m_fdcollide);
m_sets[0].collideTTpersistentStack(m_sets[0].m_root, m_sets[1].m_root, collider);
}
if (m_deferedcollide)
{
SPC(m_profiling.m_ddcollide);
m_sets[0].collideTTpersistentStack(m_sets[0].m_root, m_sets[0].m_root, collider);
}
}
/* clean up */
if (m_needcleanup)
{
SPC(m_profiling.m_cleanup);
btBroadphasePairArray& pairs = m_paircache->getOverlappingPairArray();
if (pairs.size() > 0)
{
int ni = btMin(pairs.size(), btMax<int>(m_newpairs, (pairs.size() * m_cupdates) / 100));
for (int i = 0; i < ni; ++i)
{
btBroadphasePair& p = pairs[(m_cid + i) % pairs.size()];
btDbvtProxy* pa = (btDbvtProxy*)p.m_pProxy0;
btDbvtProxy* pb = (btDbvtProxy*)p.m_pProxy1;
if (!Intersect(pa->leaf->volume, pb->leaf->volume))
{
#if DBVT_BP_SORTPAIRS
if (pa->m_uniqueId > pb->m_uniqueId)
btSwap(pa, pb);
#endif
m_paircache->removeOverlappingPair(pa, pb, dispatcher);
--ni;
--i;
}
}
if (pairs.size() > 0)
m_cid = (m_cid + ni) % pairs.size();
else
m_cid = 0;
}
}
++m_pid;
m_newpairs = 1;
m_needcleanup = false;
if (m_updates_call > 0)
{
m_updates_ratio = m_updates_done / (btScalar)m_updates_call;
}
else
{
m_updates_ratio = 0;
}
m_updates_done /= 2;
m_updates_call /= 2;
}
void CMMLOutput::writeRHS(std::ostream & out,
const CMetab* pMetab, const CReaction* pReac,
bool numbers, bool expand, bool expandFull,
size_t l)
{
if (!pMetab)
{
out << SPC(l + 0) << "Error: invalid metabolite" << std::endl;
return;
}
if (!pReac)
{
out << SPC(l + 0) << "Error: invalid reaction" << std::endl;
return;
}
const CCopasiVector < CChemEqElement > & balances = pReac->getChemEq().getBalances();
C_FLOAT64 balance = 0;
size_t i, imax = balances.size();
for (i = 0; i < imax; ++i)
{
if (balances[i]->getMetaboliteKey() == pMetab->getKey())
{
balance = balances[i]->getMultiplicity();
break;
}
}
if (0 == balance) return;
out << SPC(l + 0) << "<mrow>" << std::endl;
//balance
if (balance == 1.0)
{
out << SPC(l + 1) << "<mo>" << "+" << "</mo>" << std::endl;
}
else if (balance == -1.0)
{
out << SPC(l + 1) << "<mo>" << "-" << "</mo>" << std::endl;
}
else if (balance < 0.0)
{
out << SPC(l + 1) << "<mo>" << "-" << "</mo><mn>" << -balance << "</mn>"
<< "<mo>" << "·" << "</mo>" << std::endl;
}
else // >0
{
out << SPC(l + 1) << "<mo>" << "+" << "</mo><mn>" << balance << "</mn>"
<< "<mo>" << "·" << "</mo>" << std::endl;
}
//compartment volume?
if (pReac->getCompartmentNumber() == 1)
{
std::string compName = pMetab->getCompartment()->getObjectName();
out << SPC(l + 1) << "<msub><mi>V</mi><mi>" << CMathMl::fixName(compName)
<< "</mi></msub>" << std::endl;
out << SPC(l + 1) << "<mo>" << "·" << "</mo>" << std::endl;
}
//kinetic function
if (pReac->getFunction())
{
std::vector<std::vector<std::string> > params;
createParameterMapping(pReac, params, numbers);
if (expand) out << SPC(l + 1) << "<mfenced>" << std::endl;
out << pReac->getFunction()->writeMathML(params, expand, expandFull);
if (expand) out << SPC(l + 1) << "</mfenced>" << std::endl;
}
out << SPC(l + 0) << "</mrow>" << std::endl;
}
void CEvaluationNodeDelay::writeMathML(std::ostream & out,
const std::vector<std::vector<std::string> > & env,
bool expand,
unsigned C_INT32 l) const
{
switch (mType & 0x00FFFFFF)
{
case DELAY:
out << SPC(l) << "<mrow>" << std::endl;
out << SPC(l + 1) << "<mi>" << mData << "</mi>" << std::endl;
out << SPC(l + 1) << "<mo> ⁡ </mo>" << std::endl;
out << SPC(l + 1) << "<mrow>" << std::endl;
out << SPC(l + 2) << "<mo> (</mo>" << std::endl;
out << SPC(l + 2) << "<mrow>" << std::endl;
mpDelayedObject->writeMathML(out, env, expand, l + 3);
out << SPC(l + 3) << "<mo> , </mo>" << std::endl;
mpDeltaT->writeMathML(out, env, expand, l + 3);
out << SPC(l + 2) << "</mrow>" << std::endl;
out << SPC(l + 2) << "<mo>) </mo>" << std::endl;
out << SPC(l + 1) << "</mrow>" << std::endl;
out << SPC(l) << "</mrow>" << std::endl;
break;
default:
break;
}
return;
}
void CEvaluationNodeCall::writeMathML(std::ostream & out,
const std::vector<std::vector<std::string> > & env,
bool expand,
unsigned C_INT32 l) const
{
switch (mType & 0x00FFFFFF)
{
case FUNCTION:
{
if (!expand || !mpFunction)
{
out << SPC(l) << "<mrow>" << std::endl;
out << SPC(l + 1) << "<mi>" << mData << "</mi>" << std::endl;
out << SPC(l + 1) << "<mo> ⁡ </mo>" << std::endl;
out << SPC(l + 1) << "<mrow>" << std::endl;
out << SPC(l + 2) << "<mo> (</mo>" << std::endl;
out << SPC(l + 2) << "<mrow>" << std::endl;
std::vector< CEvaluationNode * >::const_iterator it = mCallNodes.begin();
std::vector< CEvaluationNode * >::const_iterator end = mCallNodes.end();
if (it != end)(*it++)->writeMathML(out, env, expand, l + 3);
for (; it != end; ++it)
{
out << SPC(l + 3) << "<mo> , </mo>" << std::endl;
(*it)->writeMathML(out, env, expand, l + 3);
}
out << SPC(l + 2) << "</mrow>" << std::endl;
out << SPC(l + 2) << "<mo>) </mo>" << std::endl;
out << SPC(l + 1) << "</mrow>" << std::endl;
out << SPC(l) << "</mrow>" << std::endl;
}
else
{
//construct the environment for the nested function
std::vector<std::vector<std::string> > env2;
std::vector< CEvaluationNode * >::const_iterator it = mCallNodes.begin();
std::vector< CEvaluationNode * >::const_iterator end = mCallNodes.end();
for (; it != end; ++it)
{
std::ostringstream oss;
(*it)->writeMathML(oss, env, expand, l + 3);
std::vector<std::string> tmpvector; tmpvector.push_back(oss.str());
env2.push_back(tmpvector);
}
out << SPC(l) << "<mfenced>" << std::endl;
mpFunction->writeMathML(out, env2, expand, expand, l + 1);
out << SPC(l) << "</mfenced>" << std::endl;
}
}
break;
case EXPRESSION:
break;
default:
break;
}
return;
}
DCLARG *dclarg(char *inp_, char *dft_, int cmd_arg, int cpy_dft)
{
DCLARG *arg_ = 0;
struct FAB fab;
struct NAM nam, nam2;
int len, /* (misc) string length */
use_dna2 = FALSE; /* TRUE if 'dna2[]' is default */
char rsa [NAM$C_MAXRSS], /* resultant string (SYS$SEARCH)*/
esa [NAM$C_MAXRSS], /* expanded string (SYS$PARSE) */
dna [NAM$C_MAXRSS], /* next 'sfld' default string */
dna2 [NAM$C_MAXRSS], /* next 'mfld' default if list */
dna3 [NAM$C_MAXRSS], /* next 'mfld' default if single*/
cmdtok [NAM$C_MAXRSS],
*i_ = inp_, /* beginning of item to parse */
*j_, /* end+1 of item to parse */
*k_; /* miscellaneous pointer */
if (!dft_) dft_ = "";
strcpy (dna, dft_);
strcpy (dna2,dft_);
strcpy (dna3,dft_);
dclarg_init ();
for (;;)
{
SPC(i_); /* Ignore blanks between tokens */
j_ = i_;
if (*i_ == EOS)
return (first_);
/*
* Options begin with "/", and are followed by:
* (a) an optional alphanumeric+'_' name, then
* (b) an optional (if name given) "="
* (c) an option-value if "=", perhaps enclosed in
* "(" and ")".
*
* SET-commands may use an "=" without a preceding "/"
* (e.g., "SET PROTECTION=(OWN:RE)").
*/
else if (isopt(*i_))
{
if (*i_ == '/')
{
i_++;
SPC(i_);
i_ = dclarg_keyw (i_);
k_ = i_;
SPC(k_);
if (isopt2(*k_)) i_ = k_;
}
if (isopt2(*i_))
{
i_++;
SPC(i_);
if (*i_ == '(')
{
while (*i_ && (*i_ != ')')) i_++;
if (*i_ == ')') i_++;
}
else
i_ = dclarg_spec (i_, "-");
}
status = 0;
STRNCPY(esa, j_, i_ - j_);
arg_ = dclarg_make (arg_, esa, FROM, (struct NAM *)0);
}
/*
* File names contain a mixture of ".", ":", ";", alphanumeric
* characters, and "[", "]" to delimit directories. Many
* DCL-oriented programs permit a list of filenames separated
* by comma to indicate that the directory defaults. Finally,
* wildcard characters "*" and "%" are used.
*
* Perform enough parsing here to pass along the defaults to
* the calling program.
*/
else if (dclarg_name(*i_))
{
i_ = dclarg_spec (i_, 0);
if (cmd_arg > 0)
{
STRNCPY(cmdtok, j_, i_ - j_);
arg_ = dclarg_make (arg_, cmdtok, FROM, (struct NAM *)0);
}
else
{
if (mfld <= 0) mfld = 1, sfld = 0;
rmsinit_fab (&fab, &nam,
(sfld ? dna
: (use_dna2 ? dna2
: dna3)), 0);
fab.fab$l_fna = j_;
fab.fab$b_fns = i_-j_;
rmsinit_nam (&nam, rsa, esa);
status = sys$parse(&fab);
/*
* If we're referring to a directory that doesn't exist,
* the parse will return a directory-not-found (something
* that we'd normally expect from sys$search). That
* breaks the "create" command.
*/
if (status == RMS$_DNF)
status = 0;
/*
* Use the most recent name as a default name for the next
* parse:
*/
STRNCPY(dna, esa, nam.nam$b_esl);
nam2 = nam; /* Save to use in 'dclarg_make' */
/*
* If this was the first item in any list, (sfld==0),
* obtain the parsed string, and the first-found from a
* search for the defaults 'dna3' and 'dna2', respectively.
*/
if (sfld == 0)
{
dclarg__copy (dna3, &nam, cpy_dft);
if (cpy_dft)
{
sys$search (&fab);
dclarg__copy (dna2, &nam, cpy_dft);
}
use_dna2 = FALSE;
}
/*
* Make a new DCLARG-entry:
*/
arg_ = dclarg_make (arg_,
(nam.nam$b_esl ? dna : j_), FROM, &nam2);
}
}
else
{
while (!dclarg_name(*i_) && !isopt(*i_)) i_++;
status = -1;
arg_ = dclarg_make (arg_, err_parm, FROM, (struct NAM *)0);
}
SPC(i_);
if (*i_ == ',')
{
use_dna2 = cpy_dft; /* COPY-output inherits 1st input */
i_++; sfld++;
SPC(i_);
j_ = i_;
while (isspace(*i_) || *i_ == ',') i_++;
if (j_ != i_ || isopt(*i_))
{
status = -1;
arg_ = dclarg_make (arg_, err_null, FROM, (struct NAM *)0);
}
}
else if (!isopt(*i_))
{
strcpy (dna, dft_);
if (cmd_arg <= 0)
{
mfld++;
sfld = 0;
}
}
if (cmd_arg > 0)
cmd_arg--; /* (On zero, look for filenames) */
}
}
