spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

...
char[] hallo = "Hallo Welt";
int i = hallo.findFirst('l');
...

C-/C++-Quelltext

/**
 * Calculate the term-string
 */
public double calculate(string term)
{
string[] lxdTerm;   // Our lexed term string
string[] output;// The shunting yard string

// At first we have to lex the term
if (!lexStr(term, lxdTerm))
{

    throw new Exception("Syntax Error!\n");
}

// Transform the string with the Shunting Yard Algo
// in the reverse ploish notation
if (!shuntingYard(lxdTerm, output))
{

    throw new Exception("Syntax Error!\n");
}

// Calculte the reversed polish notation string
double result = calcShunt(output);

return result;
}

C-/C++-Quelltext

enum MATH_ASSOCIATION { LEFT_ASSOC, RIGHT_ASSOC };

struct MATH_OPERATION
{
char[] op;
int parameter;
MATH_ASSOCIATION assoc;
int preced;
double function(double[]) calc;
};

C-/C++-Quelltext

struct MATH_FUNCTION
{
char[] functionName;
char[] description;
int parameter;
double function(double[]) func;
};

C-/C++-Quelltext

static const MATH_OPERATION[char] operations; // All internal operations
public MATH_FUNCTION[char[]] functions; // All functions for runtime

static this()
{
operations = [
             '(' : MATH_OPERATION("(", 0, MATH_ASSOCIATION.LEFT_ASSOC, -1, null),
             ')' : MATH_OPERATION(")", 0, MATH_ASSOCIATION.LEFT_ASSOC, -1, null),
             '+' : MATH_OPERATION("+", 2, MATH_ASSOCIATION.LEFT_ASSOC, 1, &add),
             '-' : MATH_OPERATION("-", 2, MATH_ASSOCIATION.LEFT_ASSOC, 1, &sub),
             '*' : MATH_OPERATION("*", 2, MATH_ASSOCIATION.LEFT_ASSOC, 2, &mul),
             '/' : MATH_OPERATION("/", 2, MATH_ASSOCIATION.LEFT_ASSOC, 2, &div),
             '!' : MATH_OPERATION("!", 1, MATH_ASSOCIATION.RIGHT_ASSOC, 3, &fak),
             '^' : MATH_OPERATION("^", 2, MATH_ASSOCIATION.RIGHT_ASSOC, 3, &pow)
             ];

functions["sin"] = MATH_FUNCTION("sin", "Return the sinus-value of param.", 1, &sin);
functions["cos"] = MATH_FUNCTION("cos", "Return the sinus-value of param.", 1, &cos);
functions["tan"] = MATH_FUNCTION("tan", "Return the sinus-value of param.", 1, &cos);
functions["max"] = MATH_FUNCTION("max", "Return the higher value of param.", 2, &max);
functions["min"] = MATH_FUNCTION("min", "Return the lower value of param.", 2, &min);
}

/* operation functions */
double add(double[] p)
{
return p[0]+  p[1];
}
double sub(double[] p)
{
return p[0] - p[1];
}
double mul(double[] p)
{
return p[0] * p[1];
}
double div(double[] p)
{
return p[0] / p[1];
}
double fak(double[] p)
{
int result = cast(int)p[0];
for (int i = result-1; 0 < i; --i) result *= i;
return result;
}
double pow(double[] p)
{
return std.math.pow(p[0], p[1]);
}
double sin(double[] p)
{
return std.math.sin(*p);
}
double cos(double[] p)
{
return std.math.cos(*p);
}
double tan(double[] p)
{
return std.math.tan(*p);
}
double max(double[] p)
{
return (p[0] < p[1]) ? p[1] : p[0];
}
double min(double[] p)
{
return (p[0] < p[1]) ? p[0] : p[1];
}

C-/C++-Quelltext

/**
 * helper methods, which check the input
 */
bool isOperation(char c)
{
if (c == '*' || c == '/' || c == '-' || c == '+' || c == '%'
        || c == '(' || c == ')' || c == '^' || c == '!')
{
    return true;
}
else
{
    return false;
}
}

bool isNumber(char c)
{
switch (c)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '.':
    return true;
default:
    return false;
}
}

bool isNumber(char[] str)
{
bool isDotIn = false;
foreach (i, c; str)
{
    if (c=='.')
    {
        if (isDotIn) return false;
        else isDotIn = true;
    }
    if (!isNumber(c)) return false;
}
return true;
}

bool isFunction(char[] str)
{
foreach (c; str)
{
    if (!isFunction(c)) return false;
}
return true;
}

bool isFunction(char c)
{
if (isNumber(c) || isOperation(c) || c=='(' || c==')') return false;
return true;
}

C-/C++-Quelltext

bool lexStr(string term, ref string[] lxdTerm)
{
char[] tmpNr;
char c;
int i = 0;
while (i<term.length)
{
    c = term[i];
    if (c != ' ')
    {

        if (isOperation(c) || c == ',')
        {
            lxdTerm ~= [c];
        }

        else if (isNumber(c))
        {
            int firstNr = i;
            while (i<term.length-1 && isNumber(term[++i])) {}
            if (!isNumber(term[i])) --i;
            lxdTerm ~= term[firstNr..i+1];
        }

        else // it should be a function
        {
            int firstC = i;
            while (i<term.length-1 && isFunction(term[++i])) {}
            if (term[i] != '(') return false;
            if (i-1<=0) return false;
            lxdTerm ~= term[firstC..i];
            --i;
        }
    }
    i++;
}
return true;
}

C-/C++-Quelltext

/**
 * The shunting yard algorithm transfer the term into
 * the reversed polish notation
 */
bool shuntingYard(char[][] lxdTerm, ref string[] output)
{
MATH_OPERATION[] opStack;
MATH_OPERATION *pCurOp;

for (int i = 0; i < lxdTerm.length; ++i)
{
    char[] item = lxdTerm[i];

    if (isNumber(item))
    {
        output ~= item;
    }

    else if (item == ",")
    {
        bool pe = false;
        for (int j = opStack.length-1; opStack.length > 0; j--)
        {
            if (opStack[j].op == "(")
            {
                pe = true;
                break;
            }
            else
            {
                output ~= opStack.pushLast().op;
            }
        }
        if (!pe)
        {
            writef("There was an error with the parameter (near pos %d)!\n", i);
            return false;
        }
    }

    else if (isOperation(*item))
    {
        pCurOp = &operations[*item];

        if (pCurOp.op == "(")
        {
            opStack ~= *pCurOp;
        }

        else if (pCurOp.op == ")")
        {
            bool lParent=false;
            /* While '(' isn't found or the length of stack is
               higher than 0 */
            while (opStack.length>0)
            {
                MATH_OPERATION* tmpOp = &opStack[$-1];
                if (tmpOp.op == "(")
                {
                    lParent = true;
                    opStack.pushLast();
                    break;
                }
                else
                {
                    output ~= [tmpOp.op];
                    opStack.pushLast();
                }
            }
            if (!lParent)
            {
                writef("There is missing the left parenthese (position %d)!\n", i);
                return false;
            }
        }
        /* If the precedence of the current operation is lower or equl than
           the last element in the stack we can output the last element of
           the op-stack */
        else if (opStack.length > 0 && pCurOp.preced <= opStack[$-1].preced)
        {
            output ~= opStack[$-1].op;// the op goes to the output
            opStack[$-1] = *pCurOp;     // We set the actual op to the stack
        }
        else
        {
            opStack ~= *pCurOp;
        }
    } // if isOperation

    else if (isFunction(item))
    {
        // now we 'smuggle' our fake operation in the stack
        MATH_FUNCTION *f;   // Our math function
        if ((f = (item in functions))!= null)
        {
            MATH_OPERATION op = {f.functionName, f.parameter, MATH_ASSOCIATION.RIGHT_ASSOC, 3, null};
            opStack ~= op;
        }
        else
        {
            writef("Error: unknown function: %s\n", item);
            delete opStack;
            return false;
        }
    }
}
/* If there any stacks, we will put them to the output (last in - first out) */
foreach_reverse (item; opStack)
{
    output ~= [item.op];
}

delete opStack;
return true;
}

C-/C++-Quelltext

double calcShunt(char[][] term)
{
double[] rStack;// the result-Stack
char[] str;     // actual part of the term

for (int i = 0; term.length > i; i++)
{
    str = term[i];

    // Numbers always go in the result stack
    if (isNumber(str))
    {
        rStack ~= toDouble(str);
    }
    else if (isOperation(*str))
    {
        MATH_OPERATION op = operations[*str];
        double[] param;
        for (int j = op.parameter; j!=0; j--)
        {
            param ~= rStack.pushLast();
        }
        if (op.assoc == MATH_ASSOCIATION.LEFT_ASSOC) param = param.reverse();
        rStack ~= op.calc(param);
    }
    else if (isFunction(str))
    {
        MATH_FUNCTION* f = str in functions;

        // The parameter for the function
        double[] param;
        for (int j = f.parameter; j!=0; j--)
        {
            param ~= rStack.pushLast();
        }
        rStack ~= f.func(param);
    }
    else // Unknown Syntax
    {
        throw new Exception("Unknown Syntax!");
    }
}

return (rStack.length > 0) ? rStack[0] : 0.0;
}