Solving math equations from a text field

I am trying to increase the performance of the update(); function below. The numbers inside the mathNumber variable will come from an NSString created from a text field. Even though I'm using five numbers I would like it to be able to run any amount that the user inserts into a text field. What are some ways I could speed up the code in update(); with C and/or Objective-C? I also would like it to work on the Mac and iPhone.

typedef struct {
    float *left;
    float *right;
    float *equals;
    int operation;
} MathVariable;

#define MULTIPLY 1
#define DIVIDE 2
#define ADD 3
#define SUBTRACT 4

MathVariable *mathVariable;
float *mathPointer;
float newNumber;

void init();
void update开发者_StackOverflow社区();
float solution(float *left, float *right, int *operation);

void init()
{
    float *mathNumber = (float *) malloc(sizeof(float) * 9);

    mathNumber[0] =-1.0;
    mathNumber[1] =-2.0;
    mathNumber[2] = 3.0;
    mathNumber[3] = 4.0;
    mathNumber[4] = 5.0;
    mathNumber[5] = 0.0;
    mathNumber[6] = 0.0;
    mathNumber[7] = 0.0;
    mathNumber[8] = 0.0;

    mathVariable = (MathVariable *) malloc(sizeof(MathVariable) * 4);

    mathVariable[0].equals = &mathPointer[5];
    mathVariable[0].left = &mathPointer[2];
    mathVariable[0].operation = MULTIPLY;
    mathVariable[0].right = &mathPointer[3];

    mathVariable[1].equals = &mathPointer[6];
    mathVariable[1].left = &mathPointer[1];
    mathVariable[1].operation = SUBTRACT;
    mathVariable[1].right = &mathPointer[5];

    mathVariable[2].equals = &mathPointer[7];
    mathVariable[2].left = &mathPointer[0];
    mathVariable[2].operation = ADD;
    mathVariable[2].right = &mathPointer[6];

    mathVariable[3].equals = &mathPointer[8];
    mathVariable[3].left = &mathPointer[7];
    mathVariable[3].operation = MULTIPLY;
    mathVariable[3].right = &mathPointer[4];

    return self;
}

// This is updated with a timer
void update()
{   
    int i;

    for (i = 0; i < 4; i++)
    {
        *mathVariable[i].equals = solution(mathVariable[i].left, mathVariable[i].right, &mathVariable[i].operation);
    }

    // Below is the equivalent of: newNumber = (-1.0 + (-2.0 - 3.0 * 4.0)) * 5.0;
    // newNumber should equal -75
    newNumber = mathPointer[8];
}

float solution(float *left, float *right, int *operation)
{
    if ((*operation) == MULTIPLY)
    {
        return (*left) * (*right);
    }
    else if ((*operation) == DIVIDE)
    {
        return (*left) / (*right);
    }
    else if ((*operation) == ADD)
    {
        return (*left) + (*right);
    }
    else if ((*operation) == SUBTRACT)
    {
        return (*left) - (*right);
    }
    else
    {
        return 0.0;
    }
}

EDIT:

I first must say thank you for all of your kind posts. This is the first forum I've gotten people that don't tell me I'm a complete idiot. Sorry about the return self; I didn't realize this was an objective-C forum too (thus why I hastily used C). I have my own parser which is slow but I'm not concerned with its speed. All I want is to speed up the update() function since it slows everything down and 90% of the objects use it. Also, I'm try to get it to work faster with iOS devices since I can't compile anything in the text boxes. If you have any other advice on making update() faster I thank you.

Thanks again, Jonathan

EDIT 2:

Well I got it to run faster by changing it from:

int i;

for (i = 0; i < 4; i++)
{
*mathVariable[i].equals = solution(*mathVariable[i].left, *mathVariable[i].right, mathVariable[i].operation);
}

To:

*mathVariable[0].equals = solution(*mathVariable[0].left, *mathVariable[0].right, mathVariable[0].operation);
*mathVariable[1].equals = solution(*mathVariable[1].left, *mathVariable[1].right, mathVariable[1].operation);
*mathVariable[2].equals = solution(*mathVariable[2].left, *mathVariable[2].right, mathVariable[2].operation);
*mathVariable[3].equals = solution(*mathVariable[3].left, *mathVariable[3].right, mathVariable[3].operation);

Is there any other way to increment it as fast as the preloaded numbers in the array like above?

Your code is a mix of styles, and contains some unwarranted uses of pointers (e.g. when passing operation to solution). It is unclear why you are passing the floats by reference, but maybe you intend that these change be changed and the expression reevaluated?

Below are some changes both to tidy and incidentally speed it up - the cost of any of this is not high and you may be guilt of premature optimization. As @Dave commented there are libraries to do parsing for you, but if you're targeting simple math expressions an operator precedence stack-based parser/evaluator is easy enough to code.

Suggestion 1: use enum - cleaner:

typedef enum { MULTIPLY, DIVIDE, ADD, SUBTRACT } BinaryOp;

typedef struct
{
    float *left;
    float *right;
    float *equals;
    BinaryOp operation;
} MathVariable;

Suggestion 2: use switch - cleaner and probably faster as well:

float solution(float left, float right, int operation)
{
    switch(operation)
    {
        case MULTIPLY:
            return left * right;
        case DIVIDE:
            return left / right;
        case ADD:
            return left + right;
        case SUBTRACT:
            return left - right;
        default:
            return 0.0;
    }
}

Note I also removed passing pointers, the call is now:

*mathVariable[i].equals = solution(*mathVariable[i].left,
                                   *mathVariable[i].right,
                                   mathVariable[i].operation);

Now an OO person will probably object (:-)) to the switch (or the if/else) and argue each node (your MathVariable) should be an instance which knows how to perform its own operation. A C person might suggest you use function pointers in the node so they can perform their own operation. All this is design and you'll have to figure that out yourself.