void Excitation::CalcCustomExcitation(double f0, int nTS, string signal)
{
if (dT==0) return;
if (nTS<=0) return;
Length = (unsigned int)(nTS);
// cerr << "Operator::CalcSinusExcitation: Length of the excite signal: " << ExciteLength << " timesteps" << endl;
delete[] Signal_volt;
delete[] Signal_curr;
Signal_volt = new FDTD_FLOAT[Length+1];
Signal_curr = new FDTD_FLOAT[Length+1];
Signal_volt[0]=0.0;
Signal_curr[0]=0.0;
FunctionParser fParse;
fParse.AddConstant("pi", 3.14159265358979323846);
fParse.AddConstant("e", 2.71828182845904523536);
fParse.Parse(signal,"t");
if (fParse.GetParseErrorType()!=FunctionParser::FP_NO_ERROR)
{
cerr << "Operator::CalcCustomExcitation: Function Parser error: " << fParse.ErrorMsg() << endl;
exit(1);
}
double vars[1];
for (unsigned int n=1; n<Length+1; ++n)
{
vars[0] = (n-1)*dT;
Signal_volt[n] = fParse.Eval(vars);
vars[0] += 0.5*dT;
Signal_curr[n] = fParse.Eval(vars);
}
m_f_max = f0;
m_foi = f0;
SetNyquistNum( CalcNyquistNum(f0,dT) );
}
void VectorialFunction::parse()
{
clear();
for(Uint i = 0; i < m_functions.size(); ++i)
{
FunctionParser* ptr = new FunctionParser();
ptr->AddConstant("pi", Consts::pi());
m_parsers.push_back(ptr);
// CFinfo << "Parsing Function: \'" << m_functions[i] << "\' Vars: \'" << m_vars << "\'\n" << CFendl;
ptr->Parse(m_functions[i],m_vars);
if ( ptr->GetParseErrorType() != FunctionParser::FP_NO_ERROR )
{
std::string msg("ParseError in VectorialFunction::parse(): ");
msg += " Error [" +std::string(ptr->ErrorMsg()) + "]";
msg += " Function [" + m_functions[i] + "]";
msg += " Vars: [" + m_vars + "]";
throw common::ParsingFailed (FromHere(),msg);
}
}
m_result.resize(m_functions.size());
m_is_parsed = true;
}
//-------------------------------------------------------------------------------------------------
double BenchFParser::DoBenchmark(const std::string& sExpr, long iCount)
{
double fRes (0);
double fSum (0);
FunctionParser Parser;
Parser.AddConstant("pi", (double)M_PI);
Parser.AddConstant("e", (double)M_E);
if (Parser.Parse(sExpr.c_str(), "a,b,c,x,y,z,w") >= 0)
{
StopTimerAndReport(Parser.ErrorMsg());
return m_fTime1;
}
else
{
double vals[] = {
1.1,
2.2,
3.3,
2.123456,
3.123456,
4.123456,
5.123456
};
fRes = Parser.Eval(vals);
StartTimer();
for (int j = 0; j < iCount; ++j)
{
fSum += Parser.Eval(vals);
std::swap(vals[0], vals[1]);
std::swap(vals[3], vals[4]);
}
StopTimer(fRes, fSum, iCount);
}
return m_fTime1;
}
//-------------------------------------------------------------------------------------------------
double BenchFParser::DoBenchmark(const std::string& sExpr, long iCount)
{
double fRes = 0.0;
double fSum = 0.0;
FunctionParser Parser;
Parser.AddConstant("pi", (double)M_PI);
Parser.AddConstant("e", (double)M_E);
if (Parser.Parse(sExpr.c_str(), "a,b,c,x,y,z,w") >= 0)
{
StopTimerAndReport(Parser.ErrorMsg());
return m_fTime1;
}
else
{
double vals[] = {
1.1,
2.2,
3.3,
2.123456,
3.123456,
4.123456,
5.123456
};
//Prime the I and D caches for the expression
{
double d0 = 0.0;
double d1 = 0.0;
for (std::size_t i = 0; i < priming_rounds; ++i)
{
if (i & 1)
d0 += Parser.Eval(vals);
else
d1 += Parser.Eval(vals);
}
if (
(d0 == std::numeric_limits<double>::infinity()) &&
(d1 == std::numeric_limits<double>::infinity())
)
{
printf("\n");
}
}
fRes = Parser.Eval(vals);
StartTimer();
for (int j = 0; j < iCount; ++j)
{
fSum += Parser.Eval(vals);
std::swap(vals[0], vals[1]);
std::swap(vals[3], vals[4]);
}
StopTimer(fRes, fSum, iCount);
}
return m_fTime1;
}
double ScrSpinBox::valueFromText ( const QString & text ) const
{
//Get all our units strings
//CB: Replaced by new CommonStrings versions
// QString trStrPT=unitGetStrFromIndex(SC_PT);
// QString trStrMM=unitGetStrFromIndex(SC_MM);
// QString trStrIN=unitGetStrFromIndex(SC_IN);
// QString trStrP =unitGetStrFromIndex(SC_P);
// QString trStrCM=unitGetStrFromIndex(SC_CM);
// QString trStrC =unitGetStrFromIndex(SC_C);
// QString strPT=unitGetUntranslatedStrFromIndex(SC_PT);
// QString strMM=unitGetUntranslatedStrFromIndex(SC_MM);
// QString strIN=unitGetUntranslatedStrFromIndex(SC_IN);
// QString strP =unitGetUntranslatedStrFromIndex(SC_P);
// QString strCM=unitGetUntranslatedStrFromIndex(SC_CM);
// QString strC =unitGetUntranslatedStrFromIndex(SC_C);
//Get a copy for use
QString ts = text.trimmed();
//Find our suffix
QString su(unitGetStrFromIndex(m_unitIndex));
//Replace our pica XpY.Z format with (X*12+Y.Z)pt
if (CommonStrings::trStrP.localeAwareCompare(CommonStrings::strP)!=0)
ts.replace(CommonStrings::trStrP, CommonStrings::strP);
QRegExp rxP;
if (m_unitIndex==SC_PICAS)
rxP.setPattern("\\b(\\d+)"+CommonStrings::strP+"?(\\d+\\.?\\d*)?\\b");
else
rxP.setPattern("\\b(\\d+)"+CommonStrings::strP+"(\\d+\\.?\\d*)?\\b");
int posP = 0;
while (posP >= 0)
{
// qDebug() << "#";
posP = rxP.indexIn(ts, posP);
if (posP >= 0)
{
// qDebug() << rxP.cap(1);
// qDebug() << rxP.cap(2);
QString replacement = QString("%1%2").arg(rxP.cap(1).toDouble()*(static_cast<double>(unitGetBaseFromIndex(SC_PICAS))) + rxP.cap(2).toDouble()).arg(CommonStrings::strPT);
ts.replace(posP, rxP.cap(0).length(), replacement);
// qDebug() << ts;
}
}
// qDebug() << "##" << ts;
ts.replace(",", ".");
ts.replace("%", "");
ts.replace("°", "");
ts.replace(FinishTag, "");
ts = ts.trimmed();
if (ts.endsWith(su))
ts = ts.left(ts.length()-su.length());
int pos = ts.length();
while (pos > 0)
{
pos = ts.lastIndexOf(".", pos);
if (pos >= 0)
{
if (pos < static_cast<int>(ts.length()))
{
if (!ts[pos+1].isDigit())
ts.insert(pos+1, "0 ");
}
pos--;
}
}
if (ts.endsWith("."))
ts.append("0");
//CB FParser doesn't handle unicode well/at all.
//So, instead of just getting the translated strings and
//sticking them in as variables in the parser, if they are
//not the same as the untranslated version, then we replace them.
//We lose the ability for now to have some strings in languages
//that might use them in variables.
//To return to previous functionality, remove the follow replacement ifs,
//S&R in the trStr* assignments trStrPT->strPT and remove the current str* ones.
//IE, send the translated strings through to the regexp.
if (CommonStrings::trStrPT.localeAwareCompare(CommonStrings::strPT)!=0)
ts.replace(CommonStrings::trStrPT, CommonStrings::strPT);
if (CommonStrings::trStrMM.localeAwareCompare(CommonStrings::strMM)!=0)
ts.replace(CommonStrings::trStrMM, CommonStrings::strMM);
if (CommonStrings::trStrIN.localeAwareCompare(CommonStrings::strIN)!=0)
ts.replace(CommonStrings::trStrIN, CommonStrings::strIN);
if (CommonStrings::trStrCM.localeAwareCompare(CommonStrings::strCM)!=0)
ts.replace(CommonStrings::trStrCM, CommonStrings::strCM);
if (CommonStrings::trStrC.localeAwareCompare(CommonStrings::trStrC)!=0)
ts.replace(CommonStrings::trStrC, CommonStrings::strC);
//Replace in our typed text all of the units strings with *unitstring
QRegExp rx("\\b(\\d+)\\s*("+CommonStrings::strPT+"|"+CommonStrings::strMM+"|"+CommonStrings::strC+"|"+CommonStrings::strCM+"|"+CommonStrings::strIN+")\\b");
pos = 0;
while (pos >= 0) {
pos = rx.indexIn(ts, pos);
if (pos >= 0) {
QString replacement = rx.cap(1) + "*" + rx.cap(2);
ts.replace(pos, rx.cap(0).length(), replacement);
}
}
//Add in the fparser constants using our unit strings, and the conversion factors.
FunctionParser fp;
// setFPConstants(fp);
fp.AddConstant(CommonStrings::strPT.toStdString(), value2value(1.0, SC_PT, m_unitIndex));
fp.AddConstant(CommonStrings::strMM.toStdString(), value2value(1.0, SC_MM, m_unitIndex));
fp.AddConstant(CommonStrings::strIN.toStdString(), value2value(1.0, SC_IN, m_unitIndex));
fp.AddConstant(CommonStrings::strP.toStdString(), value2value(1.0, SC_P, m_unitIndex));
fp.AddConstant(CommonStrings::strCM.toStdString(), value2value(1.0, SC_CM, m_unitIndex));
fp.AddConstant(CommonStrings::strC.toStdString(), value2value(1.0, SC_C, m_unitIndex));
fp.AddConstant("old", value());
if (m_constants)
{
QMap<QString, double>::ConstIterator itend = m_constants->constEnd();
QMap<QString, double>::ConstIterator it = m_constants->constBegin();
while(it != itend)
{
fp.AddConstant(it.key().toStdString(), it.value() * unitGetRatioFromIndex(m_unitIndex));
++it;
}
}
int ret = fp.Parse(ts.toStdString(), "", true);
// qDebug() << "fp return =" << ret;
if (ret >= 0)
return 0;
double erg = fp.Eval(NULL);
// qDebug() << "fp value =" << erg;
return erg;
}