kis_num_parser.cpp File Reference

#include "kis_num_parser.h"
#include <qnumeric.h>
#include <qmath.h>
#include <QVector>
#include <QRegularExpression>
#include <QStringList>
#include <QVariant>
#include <QLocale>
#include <iostream>

Go to the source code of this file.

Namespaces
namespace	KisNumericParser
	the namespace contains functions to transform math expression written as QString in numbers.

Functions
QString	extractSubExprLevel1 (QString &expr, char &nextOp, bool &noProblem)
	extractSubExprLevel1 extract from an expression the part of an expression that need to be treated recursively before computing level 1 operations (+, -).
QString	extractSubExprLevel2 (QString &expr, char &nextOp, bool &noProblem)
	extractSubExprLevel2 extract from an expression the part of an expression that need to be treated recursively before computing level 2 operations (*, /).
const QRegularExpression	funcExpr ("^(-)?([a-zA-Z]*[0-9]*)?\\‍((.+)\\‍)$")
const QRegularExpression	funcExprInteger ("^(-)?\\‍((.+)\\‍)$")
const QRegularExpression	integerExpr ("^(-)?([0-9]+)$")
const QRegularExpression	numberExpr ("^(-)?([0-9]+\\.?[0-9]*(e[0-9]*)?)$")
int	KisNumericParser::parseIntegerMathExpr (QString const &expr, bool *noProblem=0)
	parse an expression to an int.
double	KisNumericParser::parseSimpleMathExpr (QString const &expr, bool *noProblem=0)
	parse an expression to a double.
double	treatFuncs (QString const &expr, bool &noProblem)
	treatFuncs treat the last level of recursion: parenthesis and functions.
double	treatFuncsInt (QString const &expr, bool &noProblem)
	treatFuncs treat the last level of recursion: parenthesis
double	treatLevel1 (const QString &expr, bool &noProblem)
	treatLevel1 treat an expression at the first level of recursion.
double	treatLevel1Int (QString const &expr, bool &noProblem)
	treatLevel1 treat an expression at the first level of recursion.
double	treatLevel2 (QString const &expr, bool &noProblem)
	treatLevel2 treat a subexpression at the second level of recursion.
double	treatLevel2Int (const QString &expr, bool &noProblem)
	treatLevel2 treat a subexpression at the second level of recursion.
double	treatLevel3 (const QString &expr, bool &noProblem)
	treatLevel3 treat a subexpression at the third level of recursion.

Variables
const QVector< char >	opLevel1 = {'+', '-'}
const QVector< char >	opLevel2 = {'*', '/'}
const QStringList	supportedFuncs = {"", "cos", "sin", "tan", "acos", "asin", "atan", "exp", "ln", "log10", "abs"}

Function Documentation

extractSubExprLevel1()

QString extractSubExprLevel1 ( QString & expr, char & nextOp, bool & noProblem )

inline

extractSubExprLevel1 extract from an expression the part of an expression that need to be treated recursively before computing level 1 operations (+, -).

Parameters

expr	The expression to treat, the part returned will be removed.
nextOp	This reference, in case of success, will hold the first level operation identified as separator ('+' or '-')
noProblem	A reference to a bool, set to true if there was no problem, false otherwise.

Returns

The first part of the expression that doesn't contain first level operations not nested within parenthesis.

Definition at line 94 of file kis_num_parser.cpp.

                                                                                    {
 
    QString ret;
 
    int subCount = 0;
 
    bool lastMetIsNumber = false;
 
    for(int i = 0; i < expr.size(); i++){
 
    if (expr.at(i) == '(') {
        subCount++;
    }
 
    if (expr.at(i) == ')') {
        subCount--;
    }
 
    if (subCount < 0) {
        noProblem = false;
        return ret;
    }
 
    if(i == expr.size()-1 && subCount == 0){
        ret = expr;
        expr.clear();
        break;
    }
 
    if( (expr.at(i) == '+' || expr.at(i) == '-') &&
            subCount == 0) {
 
        if (expr.at(i) == '-' &&
                i < expr.size()-1) {
 
            bool cond = !expr.at(i+1).isSpace();
 
            if (cond && !lastMetIsNumber) {
                continue;
            }
 
        }
 
        ret = expr.mid(0, i).trimmed();
        nextOp = expr.at(i).toLatin1();
        expr = expr.mid(i+1);
        break;
 
    }
 
    if (expr.at(i).isDigit()) {
        lastMetIsNumber = true;
    } else if (expr.at(i) != '.' &&
              !expr.at(i).isSpace()) {
        lastMetIsNumber = false;
    }
 
    }
 
    noProblem = true;
    return ret;
}

extractSubExprLevel2()

QString extractSubExprLevel2 ( QString & expr, char & nextOp, bool & noProblem )

inline

extractSubExprLevel2 extract from an expression the part of an expression that need to be treated recursively before computing level 2 operations (*, /).

Parameters

expr	The expression to treat, the part returned will be removed.
nextOp	This reference, in case of success, will hold the first level operation identified as separator ('*' or '/')
noProblem	A reference to a bool, set to true if there was no problem, false otherwise.

Returns

The first part of the expression that doesn't contain second level operations not nested within parenthesis.

Definition at line 165 of file kis_num_parser.cpp.

                                                                                    {
 
    QString ret;
 
    int subCount = 0;
 
    for(int i = 0; i < expr.size(); i++){
 
    if (expr.at(i) == '(') {
        subCount++;
    }
 
    if (expr.at(i) == ')') {
        subCount--;
    }
 
    if (subCount < 0) {
        noProblem = false;
        return ret;
    }
 
    if(i == expr.size()-1 && subCount == 0){
        ret = expr;
        expr.clear();
        break;
    }
 
    if( (expr.at(i) == '*' || expr.at(i) == '/') &&
            subCount == 0) {
 
        ret = expr.mid(0, i).trimmed();
        nextOp = expr.at(i).toLatin1();
        expr = expr.mid(i+1);
        break;
 
    }
 
    }
 
    noProblem = true;
    return ret;
}

funcExpr()

const QRegularExpression funcExpr

(

"^(-)?([a-zA-Z]*[0-9]*)?\\‍((.+)\\‍)$"

)

funcExprInteger()

const QRegularExpression funcExprInteger

(

"^(-)?\\‍((.+)\\‍)$"

)

integerExpr()

const QRegularExpression integerExpr

(

"^(-)?([0-9]+)$"

)

numberExpr()

const QRegularExpression numberExpr

(

"^(-)?([0-9]+\\.?[0-9]*(e[0-9]*)?)$"

)

treatFuncs()

double treatFuncs	(	QString const &	expr,
		bool &	noProblem )

treatFuncs treat the last level of recursion: parenthesis and functions.

Parameters

expr	The expression to parse.
noProblem	A reference to a bool set to true if no problem happened, false otherwise.

Returns

The value of the parsed subexpression or 0 in case of error.

The expression should not contain operators not nested anymore. The subexpressions within parenthesis will be treated by recalling the level 1 function.

Definition at line 362 of file kis_num_parser.cpp.

{
 
    noProblem = true;
 
    QRegularExpression funcExp = funcExpr; //copy the expression in the current execution stack, to avoid errors for example when multiple thread call this function.
    QRegularExpression numExp = numberExpr;
    QRegularExpressionMatch match;
 
    if (expr.trimmed().contains(funcExp, &match)) {
 
        int sign = match.captured(1).isEmpty() ? 1 : -1;
        QString func = match.captured(2).toLower();
        QString subExpr = match.captured(3);
 
        double val = treatLevel1(subExpr, noProblem);
 
        if (!noProblem) {
            return 0.0;
        }
 
        if (func.isEmpty()) {
            return sign*val;
        }
 
        if (!supportedFuncs.contains(func)) {
            noProblem = false;
            return 0.0;
        }
 
        //trigonometry is done in degree
        if (func == "cos") {
            val = qCos(val/180*qAcos(-1));
        } else if (func == "sin") {
            val = qSin(val/180*qAcos(-1));
        } else if (func == "tan") {
            val = qTan(val/180*qAcos(-1));
        } else if(func == "acos") {
            val = qAcos(val)*180/qAcos(-1);
        } else if (func == "asin") {
            val = qAsin(val)*180/qAcos(-1);
        } else if (func == "atan") {
            val = qAtan(val)*180/qAcos(-1);
        } else if (func == "exp") {
            val = qExp(val);
        } else if (func == "ln") {
            val = qLn(val);
        } else if (func == "log10") {
            val = qLn(val)/qLn(10.0);
        } else if (func == "abs") {
            val = qAbs(val);
        }
 
        return sign*val;
    } else if(expr.trimmed().contains(numExp)) {
        return expr.toDouble(&noProblem);
    }
 
    double val = QLocale().toDouble(expr, &noProblem);
 
    if(noProblem) {
        return val;
    }
 
    noProblem = false;
    return 0.0;
 
}

References funcExpr(), numberExpr(), sign(), supportedFuncs, and treatLevel1().

treatFuncsInt()

double treatFuncsInt	(	QString const &	expr,
		bool &	noProblem )

treatFuncs treat the last level of recursion: parenthesis

Parameters

expr	The expression to parse.
noProblem	A reference to a bool set to true if no problem happened, false otherwise.

Returns

The value of the parsed subexpression or 0 in case of error.

The expression should not contain operators not nested anymore. The subexpressions within parenthesis will be treated by recalling the level 1 function.

Definition at line 533 of file kis_num_parser.cpp.

{
 
    noProblem = true;
 
    QRegularExpression funcExpInteger = funcExprInteger;
    QRegularExpression numberExp = numberExpr;
    QRegularExpressionMatch match;
 
    if (expr.trimmed().contains(funcExpInteger, &match)) {
 
        int sign = match.captured(1).isEmpty() ? 1 : -1;
        QString subExpr = match.captured(2);
 
        double val = treatLevel1Int(subExpr, noProblem);
 
        if (!noProblem) {
            return 0;
        }
 
        return sign*val;
 
    } else if(expr.trimmed().contains(numberExp)) {
        double value = QVariant(expr).toDouble(&noProblem);
        return value;
    }
 
    noProblem = false;
    return 0;
 
}

References funcExprInteger(), numberExpr(), sign(), treatLevel1Int(), and value().

treatLevel1()

double treatLevel1	(	const QString &	expr,
		bool &	noProblem )

treatLevel1 treat an expression at the first level of recursion.

Parameters

expr	The expression to treat.
noProblem	A reference to a bool set to true if no problem happened, false otherwise.

Returns

The value of the parsed expression or subexpression or 0 in case of error.

Definition at line 214 of file kis_num_parser.cpp.

{
 
    noProblem = true;
 
    QString exprDestructible = expr;
 
    char nextOp = '+';
    double result = 0.0;
 
    while (!exprDestructible.isEmpty()) {
 
        double sign = (nextOp == '-') ? -1 : 1;
        QString part = extractSubExprLevel1(exprDestructible, nextOp, noProblem);
 
        if (!noProblem) {
        return 0.0;
        }
 
        if (sign > 0) {
        result += treatLevel2(part, noProblem);
        } else {
        result -= treatLevel2(part, noProblem);
        }
 
        if(!noProblem){
        return 0.0;
        }
    }
 
    return result;
 
}

References extractSubExprLevel1(), part(), sign(), and treatLevel2().

treatLevel1Int()

double treatLevel1Int	(	QString const &	expr,
		bool &	noProblem )

treatLevel1 treat an expression at the first level of recursion.

Parameters

expr	The expression to treat.
noProblem	A reference to a bool set to true if no problem happened, false otherwise.

Returns

The value of the parsed expression or subexpression or 0 in case of error.

Definition at line 438 of file kis_num_parser.cpp.

{
 
    noProblem = true;
 
    QString exprDestructible = expr;
 
    char nextOp = '+';
    double result = 0.0;
 
    while (!exprDestructible.isEmpty()) {
 
    double sign = (nextOp == '-') ? -1 : 1;
    QString part = extractSubExprLevel1(exprDestructible, nextOp, noProblem);
 
    if( !noProblem) {
        return 0.0;
    }
 
    if (sign > 0) {
        result += treatLevel2Int(part, noProblem);
    } else {
        result -= treatLevel2Int(part, noProblem);
    }
 
    if(!noProblem){
        return 0.0;
    }
    }
 
    return result;
 
}

References extractSubExprLevel1(), part(), sign(), and treatLevel2Int().

treatLevel2()

double treatLevel2	(	QString const &	expr,
		bool &	noProblem )

treatLevel2 treat a subexpression at the second level of recursion.

Parameters

expr	The subexpression to treat.
noProblem	A reference to a bool set to true if no problem happened, false otherwise.

Returns

The value of the parsed subexpression or 0 in case of error.

The expression should not contain first level operations not nested in parenthesis.

Definition at line 256 of file kis_num_parser.cpp.

{
 
    noProblem = true;
 
    QString exprDestructible = expr;
 
    char nextOp = '*';
 
    QString part = extractSubExprLevel2(exprDestructible, nextOp, noProblem);
 
    double result = treatLevel3(part, noProblem);
 
    while (!exprDestructible.isEmpty()) {
 
        if (!noProblem) {
        return 0.0;
        }
 
        bool needToMultiply = (nextOp == '*');
        part = extractSubExprLevel2(exprDestructible, nextOp, noProblem);
 
        if (!noProblem) {
        return 0.0;
        }
 
        if (needToMultiply) {
        result *= treatLevel3(part, noProblem);
        } else {
        result /= treatLevel3(part, noProblem);
        }
    }
 
    return result;
}

References extractSubExprLevel2(), part(), and treatLevel3().

treatLevel2Int()

double treatLevel2Int	(	const QString &	expr,
		bool &	noProblem )

treatLevel2 treat a subexpression at the second level of recursion.

Parameters

expr	The subexpression to treat.
noProblem	A reference to a bool set to true if no problem happened, false otherwise.

Returns

The value of the parsed subexpression or 0 in case of error.

The expression should not contain first level operations not nested in parenthesis.

Definition at line 480 of file kis_num_parser.cpp.

{
 
    noProblem = true;
 
    QString exprDestructible = expr;
 
    char nextOp = '*';
 
    QString part = extractSubExprLevel2(exprDestructible, nextOp, noProblem);
 
    double result = treatFuncsInt(part, noProblem);
 
    while (!exprDestructible.isEmpty()) {
 
    if (!noProblem) {
        return 0.0;
    }
 
    bool needToMultiply = (nextOp == '*');
    part = extractSubExprLevel2(exprDestructible, nextOp, noProblem);
 
    if (!noProblem) {
        return 0.0;
    }
 
    if (needToMultiply) {
        result *= treatFuncsInt(part, noProblem);
    } else {
 
        double val = treatFuncsInt(part, noProblem);
 
        if(std::isinf(result/val) || qIsNaN(result/val)){
        noProblem = false;
        return 0.0;
        }
 
        result /= val;
    }
    }
 
    return result;
 
}

References extractSubExprLevel2(), part(), and treatFuncsInt().

treatLevel3()

double treatLevel3	(	const QString &	expr,
		bool &	noProblem )

treatLevel3 treat a subexpression at the third level of recursion.

Parameters

expr	The subexpression to treat.
noProblem	A reference to a bool set to true if no problem happened, false otherwise.

Returns

The value of the parsed subexpression or 0 in case of error.

The expression should not contain first or second level operations not nested in parenthesis.

Definition at line 300 of file kis_num_parser.cpp.

{
 
    noProblem = true;
 
    int indexPower = -1;
    int indexCount = 0;
    int subLevels = 0;
 
    for (int i = 0; i < expr.size(); i++) {
        if (expr.at(i) == '(') {
            subLevels++;
        } else if(expr.at(i) == ')') {
            subLevels--;
            if (subLevels < 0) {
                noProblem = false;
                return 0.0;
            }
        } else if (expr.at(i) == '^') {
            if (subLevels == 0) {
                indexPower = i;
                indexCount++;
            }
        }
    }
 
    if (indexCount > 1 || indexPower + 1 >= expr.size()) {
        noProblem = false;
        return 0.0;
    }
 
    if (indexPower > -1) {
 
        QStringList subExprs;
        subExprs << expr.mid(0,indexPower);
        subExprs << expr.mid(indexPower+1);
 
        bool noProb1 = true;
        bool noProb2 = true;
 
        double base = treatFuncs(subExprs[0], noProb1);
        double power = treatFuncs(subExprs[1], noProb2);
 
        return qPow(base, power);
 
    } else {
        return treatFuncs(expr, noProblem);
    }
 
    noProblem = false;
    return 0.0;
 
}

References treatFuncs().

Variable Documentation

opLevel1

const QVector<char> opLevel1 = {'+', '-'}

Definition at line 21 of file kis_num_parser.cpp.

{'+', '-'};

opLevel2

const QVector<char> opLevel2 = {'*', '/'}

Definition at line 22 of file kis_num_parser.cpp.

{'*', '/'};

supportedFuncs

const QStringList supportedFuncs = {"", "cos", "sin", "tan", "acos", "asin", "atan", "exp", "ln", "log10", "abs"}

Definition at line 24 of file kis_num_parser.cpp.

{"", "cos", "sin", "tan", "acos", "asin", "atan", "exp", "ln", "log10", "abs"};