#include "math_exfuncinset.h"
#include "math_exintinset.h"
#include "math_fracinset.h"
+#include "math_liminset.h"
#include "math_matrixinset.h"
#include "math_mathmlstream.h"
#include "math_numberinset.h"
// define a function for tests
-typedef bool TestItemFunc(MathInset *);
+typedef bool TestItemFunc(MathInset const *);
// define a function for replacing subexpressions
typedef MathInset * ReplaceArgumentFunc(const MathArray & ar);
}
-MathScriptInset const * asScript(MathArray::const_iterator it)
-{
- if (!it->nucleus())
- return 0;
- if (it->nucleus()->asScriptInset())
- return 0;
- ++it;
- if (!it->nucleus())
- return 0;
- return it->nucleus()->asScriptInset();
-}
-
-
-
// returns sequence of char with same code starting at it up to end
// it might be less, though...
string charSequence
if (!ar[i]->asCharInset())
continue;
string s = charSequence(ar.begin() + i, ar.end());
- ar[i].reset(new MathStringInset(s));
+ ar[i] = MathAtom(new MathStringInset(s));
ar.erase(i + 1, i + s.size());
}
//lyxerr << "\nStrings to: " << ar << "\n";
}
-MathInset * singleItem(MathArray & ar)
+MathInset const * singleItem(MathArray const & ar)
{
return ar.size() == 1 ? ar.begin()->nucleus() : 0;
}
MathDelimInset * del = (*it)->asDelimInset();
if (!del)
continue;
- MathInset * arr = singleItem(del->cell(0));
+ MathInset const * arr = singleItem(del->cell(0));
if (!arr || !arr->asGridInset())
continue;
*it = MathAtom(new MathMatrixInset(*(arr->asGridInset())));
// convert this inset somehow to a string
-bool extractString(MathInset * p, string & str)
+bool extractString(MathInset const * p, string & str)
{
if (!p)
return false;
}
-bool testString(MathInset * p, const string & str)
+bool testString(MathInset const * p, const string & str)
{
string s;
return extractString(p, s) && str == s;
// replace the original stuff by the new inset
ar.erase(it + 1, jt + 1);
- (*it).reset(p);
+ *it = MathAtom(p);
}
}
// create extra script inset and move superscript over
MathScriptInset * q = new MathScriptInset;
q->ensure(true);
- q->up().data_.swap(p->up().data_);
+ std::swap(q->up(), p->up());
p->removeScript(true);
// insert new inset behind
if (!sup || sup->hasDown())
continue;
- // create a proper exp-inset as replacement
- MathExFuncInset * func = new MathExFuncInset("exp");
- func->cell(0) = sup->cell(1);
-
- // clean up
- (*it).reset(func);
+ // create a proper exp-inset as replacement
+ *it = MathAtom(new MathExFuncInset("exp", sup->cell(1)));
ar.erase(it + 1);
}
//lyxerr << "\nExps to: " << ar << "\n";
}
+//
+// extract det(...) from |matrix|
+//
+void extractDets(MathArray & ar)
+{
+ //lyxerr << "\ndet from: " << ar << "\n";
+ for (MathArray::iterator it = ar.begin(); it != ar.end(); ++it) {
+ MathDelimInset * del = (*it)->asDelimInset();
+ if (!del)
+ continue;
+ if (!del->isAbs())
+ continue;
+ *it = MathAtom(new MathExFuncInset("det", del->cell(0)));
+ }
+ //lyxerr << "\ndet to: " << ar << "\n";
+}
+
+
//
// search numbers
//
string s = digitSequence(ar.begin() + i, ar.end());
- ar[i].reset(new MathNumberInset(s));
+ ar[i] = MathAtom(new MathNumberInset(s));
ar.erase(i + 1, i + s.size());
}
//lyxerr << "\nNumbers to: " << ar << "\n";
// search deliminiters
//
-bool testOpenParan(MathInset * p)
+bool testOpenParan(MathInset const * p)
{
return testString(p, "(");
}
-bool testCloseParan(MathInset * p)
+bool testCloseParan(MathInset const * p)
{
return testString(p, ")");
}
MathInset * replaceDelims(const MathArray & ar)
{
- MathDelimInset * del = new MathDelimInset("(", ")");
- del->cell(0) = ar;
- return del;
+ return new MathDelimInset("(", ")", ar);
}
void extractFunctions(MathArray & ar)
{
// we need at least two items...
- if (ar.size() <= 1)
+ if (ar.size() < 2)
return;
//lyxerr << "\nFunctions from: " << ar << "\n";
// is it a function?
if ((*it)->asUnknownInset()) {
// it certainly is if it is well known...
- name = (*it)->asUnknownInset()->name();
+ name = (*it)->name();
} else {
// is this a user defined function?
// it it probably not, if it doesn't have a name.
MathArray::iterator st = extractArgument(p->cell(0), jt, ar.end());
// replace the function name by a real function inset
- (*it).reset(p);
+ *it = MathAtom(p);
// remove the source of the argument from the array
ar.erase(it + 1, st);
// search integrals
//
-bool testSymbol(MathInset * p, string const & name)
+bool testSymbol(MathInset const * p, string const & name)
{
return p->asSymbolInset() && p->asSymbolInset()->name() == name;
}
-bool testIntSymbol(MathInset * p)
+bool testIntSymbol(MathInset const * p)
{
return testSymbol(p, "int");
}
-bool testIntDiff(MathInset * p)
+bool testIntegral(MathInset const * p)
+{
+ return
+ testIntSymbol(p) ||
+ ( p->asScriptInset()
+ && p->asScriptInset()->nuc().size()
+ && testIntSymbol(p->asScriptInset()->nuc().back().nucleus()) );
+}
+
+
+
+bool testIntDiff(MathInset const * p)
{
return testString(p, "d");
}
void extractIntegrals(MathArray & ar)
{
// we need at least three items...
- if (ar.size() <= 2)
+ if (ar.size() < 3)
return;
//lyxerr << "\nIntegrals from: " << ar << "\n";
for (MathArray::size_type i = 0; i + 1 < ar.size(); ++i) {
MathArray::iterator it = ar.begin() + i;
- // is this a integral name?
- if (!testIntSymbol(it->nucleus()))
- continue;
-
// search 'd'
MathArray::iterator jt =
- endNestSearch(it, ar.end(), testIntSymbol, testIntDiff);
+ endNestSearch(it, ar.end(), testIntegral, testIntDiff);
// something sensible found?
if (jt == ar.end())
continue;
- // create a proper inset as replacement
- MathExIntInset * p = new MathExIntInset("int");
-
- // collect subscript if any
- MathArray::iterator st = it + 1;
- if (st != ar.end())
- if (MathScriptInset * sub = (*st)->asScriptInset())
- if (sub->hasDown()) {
- p->cell(2) = sub->down().data_;
- ++st;
- }
-
- // collect superscript if any
- if (st != ar.end())
- if (MathScriptInset * sup = (*st)->asScriptInset())
- if (sup->hasUp()) {
- p->cell(3) = sup->up().data_;
- ++st;
- }
+ // is this a integral name?
+ if (!testIntegral(it->nucleus()))
+ continue;
// core ist part from behind the scripts to the 'd'
- p->cell(0) = MathArray(st, jt);
+ MathExIntInset * p = new MathExIntInset("int");
+
+ // handle scripts if available
+ if (!testIntSymbol(it->nucleus())) {
+ p->cell(2) = it->nucleus()->asScriptInset()->down();
+ p->cell(3) = it->nucleus()->asScriptInset()->up();
+ }
+ p->cell(0) = MathArray(it + 1, jt);
// use the "thing" behind the 'd' as differential
MathArray::iterator tt = extractArgument(p->cell(1), jt + 1, ar.end());
// remove used parts
ar.erase(it + 1, tt);
- (*it).reset(p);
+ *it = MathAtom(p);
}
//lyxerr << "\nIntegrals to: " << ar << "\n";
}
// search sums
//
-bool testSumSymbol(MathInset * p)
+
+bool testEqualSign(MathAtom const & at)
{
- return testSymbol(p, "sum");
+ return testString(at.nucleus(), "=");
}
-bool testEqualSign(MathAtom const & at)
+bool testSumSymbol(MathInset const * p)
{
- return testString(at.nucleus(), "=");
+ return testSymbol(p, "sum");
}
+bool testSum(MathInset const * p)
+{
+ return
+ testSumSymbol(p) ||
+ ( p->asScriptInset()
+ && p->asScriptInset()->nuc().size()
+ && testSumSymbol(p->asScriptInset()->nuc().back().nucleus()) );
+}
+
// replace '\sum' ['_^'] f(x) sequences by a real MathExIntInset
// assume 'extractDelims' ran before
void extractSums(MathArray & ar)
{
// we need at least two items...
- if (ar.size() <= 1)
+ if (ar.size() < 2)
return;
//lyxerr << "\nSums from: " << ar << "\n";
- for (MathArray::size_type i = 0; i + 1< ar.size(); ++i) {
+ for (MathArray::size_type i = 0; i + 1 < ar.size(); ++i) {
MathArray::iterator it = ar.begin() + i;
// is this a sum name?
- if (!testSumSymbol(it->nucleus()))
+ if (!testSum(it->nucleus()))
continue;
// create a proper inset as replacement
MathExIntInset * p = new MathExIntInset("sum");
// collect lower bound and summation index
- MathArray::iterator st = it + 1;
- if (st != ar.end())
- if (MathScriptInset * sub = (*st)->asScriptInset())
- if (sub->hasDown()) {
- // try to figure out the summation index from the subscript
- MathArray & ar = sub->down().data_;
- MathArray::iterator it =
- find_if(ar.begin(), ar.end(), &testEqualSign);
- if (it != ar.end()) {
- // we found a '=', use everything in front of that as index,
- // and everything behind as lower index
- p->cell(1) = MathArray(ar.begin(), it);
- p->cell(2) = MathArray(it + 1, ar.end());
- } else {
- // use everything as summation index, don't use scripts.
- p->cell(1) = ar;
- }
- ++st;
- }
+ MathScriptInset * sub = (*it)->asScriptInset();
+ if (sub && sub->hasDown()) {
+ // try to figure out the summation index from the subscript
+ MathArray & ar = sub->down();
+ MathArray::iterator xt =
+ find_if(ar.begin(), ar.end(), &testEqualSign);
+ if (xt != ar.end()) {
+ // we found a '=', use everything in front of that as index,
+ // and everything behind as lower index
+ p->cell(1) = MathArray(ar.begin(), xt);
+ p->cell(2) = MathArray(xt + 1, ar.end());
+ } else {
+ // use everything as summation index, don't use scripts.
+ p->cell(1) = ar;
+ }
+ }
// collect upper bound
- if (st != ar.end())
- if (MathScriptInset * sup = (*st)->asScriptInset())
- if (sup->hasUp()) {
- p->cell(3) = sup->up().data_;
- ++st;
- }
+ if (sub && sub->hasUp())
+ p->cell(3) = sub->up();
- // use some behind the script as core
- MathArray::iterator tt = extractArgument(p->cell(0), st, ar.end());
+ // use something behind the script as core
+ MathArray::iterator tt = extractArgument(p->cell(0), it + 1, ar.end());
// cleanup
ar.erase(it + 1, tt);
- (*it).reset(p);
+ *it = MathAtom(p);
}
//lyxerr << "\nSums to: " << ar << "\n";
}
}
-bool testDiffFrac(MathInset * p)
+bool testDiffFrac(MathInset const * p)
{
- MathFracInset * f = p->asFracInset();
+ MathFracInset const * f = p->asFracInset();
return f && testDiffArray(f->cell(0)) && testDiffArray(f->cell(1));
}
if (script && script->hasUp()) {
// things like d.../dx^n
int mult = 1;
- if (extractNumber(script->up().data_, mult)) {
+ if (extractNumber(script->up(), mult)) {
//lyxerr << "mult: " << mult << endl;
for (int i = 0; i < mult; ++i)
diff->addDer(MathArray(dt + 1, st));
// cleanup
ar.erase(it + 1, jt);
- (*it).reset(diff);
+ *it = MathAtom(diff);
}
//lyxerr << "\nDiffs to: " << ar << "\n";
}
+//
+// search limits
+//
+
+
+bool testRightArrow(MathAtom const & at)
+{
+ return
+ testSymbol(at.nucleus(), "to") ||
+ testSymbol(at.nucleus(), "rightarrow");
+}
+
+
+
+// replace '\lim_{x->x0} f(x)' sequences by a real MathLimInset
+// assume 'extractDelims' ran before
+void extractLims(MathArray & ar)
+{
+ // we need at least three items...
+ if (ar.size() < 3)
+ return;
+
+ //lyxerr << "\nLimits from: " << ar << "\n";
+ for (MathArray::size_type i = 0; i + 2 < ar.size(); ++i) {
+ MathArray::iterator it = ar.begin() + i;
+
+ // is this a limit function?
+ if (!testSymbol(it->nucleus(), "lim"))
+ continue;
+
+ // the next one must be a subscript (without superscript)
+ MathScriptInset * sub = (*(it + 1))->asScriptInset();
+ if (!sub || !sub->hasDown() || sub->hasUp())
+ continue;
+
+ // and it must contain a -> symbol
+ MathArray & s = sub->down();
+ MathArray::iterator st = find_if(s.begin(), s.end(), &testRightArrow);
+ if (st == s.end())
+ continue;
+
+ // the -> splits the subscript int x and x0
+ MathArray x = MathArray(s.begin(), st);
+ MathArray x0 = MathArray(st + 1, s.end());
+
+ // use something behind the script as core
+ MathArray f;
+ MathArray::iterator tt = extractArgument(f, it + 2, ar.end());
+
+ // cleanup
+ ar.erase(it + 1, tt);
+
+ // create a proper inset as replacement
+ *it = MathAtom(new MathLimInset(f, x, x0));
+ }
+ //lyxerr << "\nLimits to: " << ar << "\n";
+}
+
//
// combine searches
void extractStructure(MathArray & ar)
{
+ extractIntegrals(ar);
+ extractSums(ar);
splitScripts(ar);
extractNumbers(ar);
extractMatrices(ar);
extractDelims(ar);
extractFunctions(ar);
- extractIntegrals(ar);
- extractSums(ar);
+ extractDets(ar);
extractDiff(ar);
extractExps(ar);
+ extractLims(ar);
extractStrings(ar);
}
{
MathArray ar = dat;
extractStrings(ar);
+ wi.firstitem() = true;
for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
- wi.firstitem() = (it == ar.begin());
- MathInset const * p = it->nucleus();
- if (it + 1 != ar.end()) {
- if (MathScriptInset const * q = asScript(it)) {
- q->write2(p, wi);
- ++it;
- continue;
- }
- }
- p->write(wi);
+ (*it)->write(wi);
+ wi.firstitem() = false;
}
}
{
MathArray ar = dat;
extractStructure(ar);
- for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
- MathInset const * p = it->nucleus();
- if (it + 1 != ar.end()) {
- if (MathScriptInset const * q = asScript(it)) {
- q->octavize2(p, os);
- ++it;
- continue;
- }
- }
- p->octavize(os);
- }
+ for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it)
+ (*it)->octavize(os);
}
{
MathArray ar = dat;
extractStructure(ar);
- for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
- MathInset const * p = it->nucleus();
- if (it + 1 != ar.end()) {
- if (MathScriptInset const * q = asScript(it)) {
- q->maplize2(p, os);
- ++it;
- continue;
- }
- }
- p->maplize(os);
- }
+ for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it)
+ (*it)->maplize(os);
+}
+
+
+void mathematicize(MathArray const & dat, MathematicaStream & os)
+{
+ MathArray ar = dat;
+ extractStructure(ar);
+ for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it)
+ (*it)->mathematicize(os);
}
os << ar.begin()->nucleus();
else {
os << MTag("mrow");
- for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
- MathInset const * p = it->nucleus();
- if (it + 1 != ar.end()) {
- if (MathScriptInset const * q = asScript(it)) {
- q->mathmlize2(p, os);
- ++it;
- continue;
- }
- }
- p->mathmlize(os);
- }
+ for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it)
+ (*it)->mathmlize(os);
os << ETag("mrow");
}
}
ms << ar;
string expr = os.str().c_str();
lyxerr << "ar: '" << ar << "'\n";
+ lyxerr << "ms: '" << os.str() << "'\n";
for (int i = 0; i < 100; ++i) { // at most 100 attempts
// try to fix missing '*' the hard way by using mint
MathArrayInset const * mat = at.nucleus()->asArrayInset();
MathArray res;
if (mat->ncols() == 1 && mat->nrows() == 1)
- res.push_back(mat->cell(0));
+ res.append(mat->cell(0));
else {
res.push_back(MathAtom(new MathDelimInset("(", ")")));
res.back()->cell(0).push_back(at);