#include <mathpresso/mathpresso.h>
#include <stdio.h>

int main(int argc, char* argv[]) {
  mathpresso::Context ctx;
  mathpresso::Expression exp;

  // Initialize the context by adding MathPresso built-ins. Without this line
  // functions like round(), sin(), etc won't be available.
  ctx.addBuiltIns();

  // Let the context know the name of the variables we will refer to and
  // their positions in the data pointer. We will use an array of 3 doubles,
  // so index them by using `sizeof(double)`, like a normal C array.
  //
  // The `addVariable()` also contains a third parameter that describes
  // variable flags, use `kVariableRO` to make a certain variable read-only.
  ctx.addVariable("x", 0 * sizeof(double));
  ctx.addVariable("y", 1 * sizeof(double));
  ctx.addVariable("z", 2 * sizeof(double));

  // Compile the expression.
  //
  // The create parameters are:
  //   1. `mathpresso::Context&` - The expression's context / environment.
  //   2. `const char* body` - The expression body.
  //   3. `unsigned int` - Options, just pass `mathpresso::kNoOptions`.
  mathpresso::Error err = exp.compile(ctx, "(x*y) % z", mathpresso::kNoOptions);

  // Handle possible syntax or compilation error.
  if (err != mathpresso::kErrorOk) {
    printf("Expression Error: %u\n", err);
    return 1;
  }

  // To evaluate the expression you need to create the `data` to be passed
  // to the expression and initialize it. Every expression returns `double`,
  // to return more members simply use the passed `data`.
  double data[] = {
    1.2, // 'x' - available at data[0]
    3.8, // 'y' - available at data[1]
    1.3  // 'z' - available at data[2]
  };
  printf("Output: %f\n", exp.evaluate(data));

  return 0;
}

#include <mathpresso/mathpresso.h>
#include <stdio.h>

struct Data {
  inline Data(double x, double y, double z)
    : x(x), y(y), z(z) {}

  double x, y, z;
};

int main(int argc, char* argv[]) {
  mathpresso::Context ctx;
  mathpresso::Expression exp;

  ctx.addBuiltIns();
  ctx.addVariable("x", MATHPRESSO_OFFSET(Data, x));
  ctx.addVariable("y", MATHPRESSO_OFFSET(Data, y));
  ctx.addVariable("z", MATHPRESSO_OFFSET(Data, z));

  mathpresso::Error err = exp.compile(ctx, "(x*y) % z", mathpresso::kNoOptions);
  if (err != mathpresso::kErrorOk) {
    printf("Expression Error: %u\n", err);
    return 1;
  }

  Data data(1.2, 3.8. 1.3);
  printf("Output: %f\n", exp.evaluate(&data));

  return 0;
}

// This is a minimum working example that uses most of MathPresso features. It
// shows how to compile and evaluate expressions and how to handle errors. It
// also shows how to print the generated AST and machine code.
#include <mathpresso/mathpresso.h>
#include <stdio.h>

// The data passed to the expression.
struct Data {
  double x, y, z;
};

// By inheriting `OutputLog` one can create a way how to handle possible errors
// and report them to humans. The most interesting and used message type is
// `kMessageError`, because it signalizes an invalid expression. Other message
// types are used mostly for debugging.
struct MyOutputLog : public mathpresso::OutputLog {
  MyOutputLog() {}
  virtual ~MyOutputLog() {}
  virtual void log(unsigned int type, unsigned int line, unsigned int column, const char* message, size_t size) {
    switch (type) {
      case kMessageError:
        printf("[ERROR]: %s (line %u, column %u)\n", message, line, column);
        break;

      case kMessageWarning:
        printf("[WARNING]: %s (line %u, column %u)\n", message, line, column);
        break;

      case kMessageAstInitial:
        printf("[AST-INITIAL]\n%s", message);
        break;

      case kMessageAstFinal:
        printf("[AST-FINAL]\n%s", message);
        break;

      case kMessageAsm:
        printf("[ASSEMBLY]\n%s", message);
        break;

      default:
        printf("[UNKNOWN]\n%s", message);
        break;
    }
  }
};

int main(int argc, char* argv[]) {
  MyOutputLog outputLog;

  // Create the context, add builtins and define the `Data` layout.
  mathpresso::Context ctx;
  ctx.addBuiltIns();
  ctx.addVariable("x"  , MATHPRESSO_OFFSET(Data, x));
  ctx.addVariable("y"  , MATHPRESSO_OFFSET(Data, y));
  ctx.addVariable("z"  , MATHPRESSO_OFFSET(Data, z));

  // The following options will cause that MathPresso will send everything
  // it does to `OutputLog`.
  unsigned int options =
    mathpresso::kOptionVerbose         | // Enable warnings, not just errors.
    mathpresso::kOptionDebugAst        | // Enable AST dumps.
    mathpresso::kOptionDebugMachineCode; // Enable ASM dumps.

  mathpresso::Expression exp;
  mathpresso::Error err = exp.compile(ctx,
    "-(-(abs(x * y - floor(x)))) * z * (12.9 - 3)", options, &outputLog);

  // Handle possible syntax or compilation error. The OutputLog has already
  // received and printed the reason in a human readable form.
  if (err) {
    printf("ERROR %u\n", err);
    return 1;
  }

  // Evaluate the expression, if compiled.
  Data data = { 12.2, 9.2, -1.9 };
  double result = exp.evaluate(&data);

  printf("RESULT: %f\n", result);
  return 0;
}