"  [2 2,2,][2 1,2,3,4,]*  -> [8,12] (matrix multiplication)\n",

    "  [2; 2 2][2; 1 2 3 4]*  -> [8,12] (matrix multiplication)\n",

#include "error.h"

#include "mem.h"

    double newx = evalExprReal(cmd).elem.real;
    cmd += skipUntil(cmd, ',');
    double newy = evalExprReal(cmd).elem.real;

    stack_t s = evalExprRealStack(cmd);
    double newx = (s.rsp - 1)->elem.real;
    double newy = (s.rsp - 0)->elem.real;

    double newxx = evalExprReal(cmd).elem.real;
    cmd += skipUntil(cmd, ',');
    double newxn = evalExprReal(cmd).elem.real;
    cmd += skipUntil(cmd, ',');
    double newyx = evalExprReal(cmd).elem.real;
    cmd += skipUntil(cmd, ',');
    double newyn = evalExprReal(cmd).elem.real;

    stack_t s = evalExprRealStack(cmd);
    if (s.rsp - 4 != s.rbp) DISPERR("expected 4 params");
    double newxx = (s.rsp - 3)->elem.real;
    double newxn = (s.rsp - 2)->elem.real;
    double newyx = (s.rsp - 1)->elem.real;
    double newyn = (s.rsp - 0)->elem.real;

#include "rtconf.h"

  case 'c': // set argc
    m->d.argc[m->d.spi] = (char)POP.elem.real;
    break;

  *++m->s.rsp = (isdigit(*++m->c.rip)) ? handleFnArgs(m)
              : (islower(*m->c.rip))   ? m->e.info.reg[*m->c.rip - 'a']
                                       : *(real_t *)$panic(ERR_CHAR_NOT_FOUND);

  *++m->s.rsp = *++m->c.rip == '0'   ? SET_LAMB((char *)m->c.expr)
              : (isdigit(*m->c.rip)) ? handleFnArgs(m)
              : (islower(*m->c.rip)) ? m->e.info.reg[*m->c.rip - 'a']
                                     : *(real_t *)$panic(ERR_CHAR_NOT_FOUND);

  rpxEnd,     // ','

  rpxUndfned, // ','

}
stack_t evalExprRealStack(char const *restrict a_expr) {
  machine_t m;
  initEvalinfo(&m);
  m.c.expr = m.c.rip = a_expr;
  rpxEval(&m);
  setRRuntimeInfo(m.e.info);
  return m.s;

    { 0.0,               "0;hello"}, // comment
    { 5.0,    "3 4 5 {3 @c $1}! +"}, // @c
}
)
#define eval_expr_real_cond(expr) !isnan(eval_expr_real_return_double(expr))
test_table(
  eval_real_cond, eval_expr_real_cond, (bool, char const *),
  {
    { true,      "1.5 1.5 ="},
    {false,          "0 1 ="},
    { true,          "1s1c>"},
    {false,          "1s1c<"},
    { true, "10 100 90 ig ="},
    {false,          "@n@n="},

#include "main.h"

 * @return elem_t Expression evaluation result

 * @param[in,out] operand_stack Return value

[[gnu::nonnull]] elem_t evalExprComplex(char const *expr) {
  elem_t operand_stack[buf_size] = {};

[[gnu::nonnull]] size_t
evalExprComplexStack(char const *expr, elem_t *operand_stack) {

    if (*expr == '[') {

    switch (*expr) {
    case ' ':
    case '\t':
    case '\n':
      continue;
    case '0' ... '9':
      (++rsp)->rtype = RTYPE_COMP;
      rsp->elem.comp = strtod(expr, (char **)&expr);
      expr--;
      break;
    case '[':

      val.cols = (size_t)strtol(expr, (char **)&expr, 10);
      for (; *expr != ']'; expr += skipUntil(expr, ','))
        *curelem++ = evalExprComplex(expr).elem.comp;
      val.rows = (size_t)(curelem - val.matrix) / val.cols;

      val.cols = (size_t)evalExprComplex(expr).elem.comp;
      expr += skipUntil(expr, ';');
      elem_t stack[buf_size] = {};
      size_t len = evalExprComplexStack(expr, stack);
      for (size_t i = 0; i < len; i++) *curelem++ = stack[i + 1].elem.comp;
      val.rows = len / val.cols;

      expr += skipUntil(expr, ']') - 1;

    }
    if (isspace(*expr)) continue;
    if (*expr == '\0') break;
    switch (*expr) {
    case '0' ... '9':
      (++rsp)->rtype = RTYPE_COMP;
      rsp->elem.comp = strtod(expr, (char **)&expr);
      expr--;
      break;

    case ',': // delimiter

    case ']':
    case '\0':

  return *rsp;

  return (size_t)(rsp - operand_stack);

elem_t evalExprComplex(char const *a_expr) {
  elem_t s[buf_size] = {};
  size_t len = evalExprComplexStack(a_expr, s);
  return s[len];
}

  resultm = evalExprComplex("[2 1,2,3,4,][2 5,6,7,8,]+").elem.matr;

  resultm = evalExprComplex("[2; 1 2 3 4][2; 5 6 7 8]+").elem.matr;

  char const *expr = "[2 1,2,3,4,][2 5,6,7,8,]*";

  char const *expr = "[2; 1 2 3 4][2; 5 6 7 8]*";

  expr = "[2 1,2,3,4,]~";

  expr = "[2; 1 2 3 4]~";

  expr = "[3 5,6,7,] 5 *";

  expr = "[3; 5 6 7] 5 *";

  evalExprComplex("[2 1,2,3,4,][2 5,6,7,8,]+");
  evalExprComplex("[3 4,1,4,6,5,7,3,6,7,]~");
  evalExprComplex("[1 4,5,][2 6,7,]*");
  evalExprComplex("[2 7,6,5,4,] 6 *");
  evalExprComplex("[2 9,0,5,1,] 4 ^");
  evalExprComplex("[2 5,4,3,2,][2 4,8,2,1,]/");

  evalExprComplex("[2; 1 2 3 4 ][2; 5 6 7 8 ]+");
  evalExprComplex("[3; 4 1 4 6 5 7 3 6 7 ]~");
  evalExprComplex("[1; 4 5 ][2; 6 7 ]*");
  evalExprComplex("[2; 7 6 5 4 ] 6 *");
  evalExprComplex("[2; 9 0 5 1 ] 4 ^");
  evalExprComplex("[2; 5 4 3 2 ][2; 4 8 2 1 ]/");

FILES ?= makefile doc/t.typ doc/readme.typ doc/manual.typ

FILES ?= makefile build.zig doc/t.typ doc/readme.typ doc/manual.typ

BROWSER ?= chawan

BROWSER ?= cha

     int col = 6 - ((int)strlen("   Testing " #name) - 2) / 8; \

     int col = 6 - ((int)strlen("   Testing " #name) - 1) / 8; \

[[gnu::nonnull]] stack_t evalExprRealStack(char const *);

- Matrices: Use `[columns elements,]` format (e.g., `[2 1,2,3,4,]` for $mat(1,2;3,4)$)

- Matrices: Use `[column; elements ...]` format (e.g., `[2; 1 2 3 4]` for $mat(1,2;3,4)$)

- `@c` Set the number of arguments consumed by the current expression

#t.example(`... <$3> <$2> <$1> <lambda> !`)

#t.example(`... <$3> <$2> <$1> <lambda ($0)> !`)

    { ; lambda 2, to match type

    { ; lambda 2, base

- Elements separated by commas

- Elements separated by spaces

  - Example: `[2 1,2,3,4,]` creates a 2x2 matrix $mat(1,2;3,4)$

  - Example: `[2; 1 2 3 4]` creates a 2x2 matrix $mat(1,2;3,4)$

  - Example: `[2 5,3m,6i,1s,99,]` create a 2x2 matrix $mat(5,-3;6i,sin(1))$
  - Example: `[3 1,2,3,4,5,]` creates a 1x3 matrix $mat(1,2,3)$

  - Example: `[2; 5 3m 6i 1s 99]` create a 2x2 matrix $mat(5,-3;6i,sin(1))$
  - Example: `[3; 1 2 3 4 5]` creates a 1x3 matrix $mat(1,2,3)$

+ Matrix addition: `[2 1,2,3,4,][2,4,5,6,7,]+` #math.arrow.r $mat(5,7;9,11)$
+ Matrix inverse: `[3 1,1,1m,2m,0,1,0,2,1,]~` #math.arrow.r $mat(-0.5,-0.75,0.25;0.5,0.25,0.25;-1,-0.5,0.5)$

+ Matrix addition: `[2; 1 2 3 4][2; 4 5 6 7]+` #math.arrow.r $mat(5,7;9,11)$
+ Matrix inverse: `[3; 1 1 1m 2m 0 1 0 2 1]~` #math.arrow.r $mat(-0.5,-0.75,0.25;0.5,0.25,0.25;-1,-0.5,0.5)$
+ To Chuch Boolean: `{ {2 @c $1} {2 @c $2} $1 ? } &c`

+ One-shot graph plottor: `rpx -r ":spr\\P,\\Pm,1,1m" -r ":p $1s" -q`

+ One-shot graph plottor: `rpx -r ":spr (\\P 2 /) (\\P 2 /)m 1 1m" -r ":p $1s" -q`