math_native.c

// --------------------------------------------------
//   Project: ProX Programming Language (ProXPL)
//   Author:  ProgrammerKR
//   Created: 2025-12-16
//   Copyright © 2025. ProXentix India Pvt. Ltd.  All rights reserved.
// --------------------------------------------------

/*
 * ProXPL Standard Library - Math Module  
 * Native C implementation of mathematical functions
 */

// CRITICAL FIX: This must be defined BEFORE <math.h> for Windows to see M_E, M_PI
#define _USE_MATH_DEFINES 

#include "common.h"
#include "vm.h"
#include "value.h"
#include "object.h"
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

extern VM vm;

// Helper to define native function in a module
static void defineModuleFn(ObjModule* module, const char* name, NativeFn function) {
    ObjString* nameObj = copyString(name, (int)strlen(name));
    push(&vm, OBJ_VAL(nameObj));
    push(&vm, OBJ_VAL(newNative(function)));
    tableSet(&module->exports, nameObj, peek(&vm, 0));
    pop(&vm);
    pop(&vm);
}

// abs(x) - Absolute value
static Value native_abs(int argCount, Value* args) {
    if (argCount < 1) return NUMBER_VAL(0);
    
    if (IS_NUMBER(args[0])) {
        return NUMBER_VAL(fabs(AS_NUMBER(args[0])));
    }
    return args[0];
}

// ceil(x) - Ceiling function  
static Value native_ceil(int argCount, Value* args) {
    if (argCount < 1 || !IS_NUMBER(args[0])) return NUMBER_VAL(0);
    return NUMBER_VAL(ceil(AS_NUMBER(args[0])));
}

// floor(x) - Floor function
static Value native_floor(int argCount, Value* args) {
    if (argCount < 1 || !IS_NUMBER(args[0])) return NUMBER_VAL(0);
    return NUMBER_VAL(floor(AS_NUMBER(args[0])));
}

// round(x, decimals) - Round to n decimal places
static Value native_round(int argCount, Value* args) {
    if (argCount < 1 || !IS_NUMBER(args[0])) return NUMBER_VAL(0);
    
    double value = AS_NUMBER(args[0]);
    int decimals = 0;
    
    if (argCount >= 2 && IS_NUMBER(args[1])) {
        decimals = (int)AS_NUMBER(args[1]);
    }
    
    double multiplier = pow(10.0, decimals);
    return NUMBER_VAL(round(value * multiplier) / multiplier);
}

// max(...) - Maximum value
static Value native_max(int argCount, Value* args) {
    if (argCount == 0) return NIL_VAL;
    
    double maxVal = IS_NUMBER(args[0]) ? AS_NUMBER(args[0]) : 0;
    for (int i = 1; i < argCount; i++) {
        if (IS_NUMBER(args[i])) {
            double val = AS_NUMBER(args[i]);
            if (val > maxVal) maxVal = val;
        }
    }
    return NUMBER_VAL(maxVal);
}

// min(...) - Minimum value
static Value native_min(int argCount, Value* args) {
    if (argCount == 0) return NIL_VAL;
    
    double minVal = IS_NUMBER(args[0]) ? AS_NUMBER(args[0]) : 0;
    for (int i = 1; i < argCount; i++) {
        if (IS_NUMBER(args[i])) {
            double val = AS_NUMBER(args[i]);
            if (val < minVal) minVal = val;
        }
    }
    return NUMBER_VAL(minVal);
}

// pow(base, exp) - Power function
static Value native_pow(int argCount, Value* args) {
    if (argCount < 2 || !IS_NUMBER(args[0]) || !IS_NUMBER(args[1])) {
        return NUMBER_VAL(0);
    }
    return NUMBER_VAL(pow(AS_NUMBER(args[0]), AS_NUMBER(args[1])));
}

// sqrt(x) - Square root
static Value native_sqrt(int argCount, Value* args) {
    if (argCount < 1 || !IS_NUMBER(args[0])) return NUMBER_VAL(0);
    return NUMBER_VAL(sqrt(AS_NUMBER(args[0])));
}

// Trigonometric functions
static Value native_sin(int argCount, Value* args) {
    if (argCount < 1 || !IS_NUMBER(args[0])) return NUMBER_VAL(0);
    return NUMBER_VAL(sin(AS_NUMBER(args[0])));
}

static Value native_cos(int argCount, Value* args) {
    if (argCount < 1 || !IS_NUMBER(args[0])) return NUMBER_VAL(0);
    return NUMBER_VAL(cos(AS_NUMBER(args[0])));
}

static Value native_tan(int argCount, Value* args) {
    if (argCount < 1 || !IS_NUMBER(args[0])) return NUMBER_VAL(0);
    return NUMBER_VAL(tan(AS_NUMBER(args[0])));
}

static Value native_asin(int argCount, Value* args) {
    if (argCount < 1 || !IS_NUMBER(args[0])) return NUMBER_VAL(0);
    return NUMBER_VAL(asin(AS_NUMBER(args[0])));
}

static Value native_acos(int argCount, Value* args) {
    if (argCount < 1 || !IS_NUMBER(args[0])) return NUMBER_VAL(0);
    return NUMBER_VAL(acos(AS_NUMBER(args[0])));
}

static Value native_atan(int argCount, Value* args) {
    if (argCount < 1 || !IS_NUMBER(args[0])) return NUMBER_VAL(0);
    return NUMBER_VAL(atan(AS_NUMBER(args[0])));
}

// log(x, base) - Logarithm
static Value native_log(int argCount, Value* args) {
    if (argCount < 1 || !IS_NUMBER(args[0])) return NUMBER_VAL(0);
    
    double x = AS_NUMBER(args[0]);
    double base = M_E;
    
    if (argCount >= 2 && IS_NUMBER(args[1])) {
        base = AS_NUMBER(args[1]);
    }
    
    if (base == M_E) {
        return NUMBER_VAL(log(x));
    } else {
        return NUMBER_VAL(log(x) / log(base));
    }
}

// exp(x) - Exponential function
static Value native_exp(int argCount, Value* args) {
    if (argCount < 1 || !IS_NUMBER(args[0])) return NUMBER_VAL(0);
    return NUMBER_VAL(exp(AS_NUMBER(args[0])));
}

// random() - Random number [0, 1)
static Value native_random(int argCount, Value* args) {
    // If no arguments, return float [0.0, 1.0) - Standard behavior
    if (argCount == 0) {
        double random_part = (double)rand() / ((double)RAND_MAX + 1.0);
        return NUMBER_VAL(random_part);
    }

    // If arguments are provided, behave like randint (User request: "no decimals")
    // random(max) -> [0, max]
    // random(min, max) -> [min, max]
    
    double min = 0.0;
    double max = 1.0;

    if (argCount == 1) {
        if (!IS_NUMBER(args[0])) return NUMBER_VAL(0);
        max = AS_NUMBER(args[0]);
    } else if (argCount >= 2) {
        if (!IS_NUMBER(args[0]) || !IS_NUMBER(args[1])) return NUMBER_VAL(0);
        min = AS_NUMBER(args[0]);
        max = AS_NUMBER(args[1]);
    }

    if (min > max) {
        double temp = min;
        min = max;
        max = temp;
    }

    // Return integer
    long long min_int = (long long)min;
    long long max_int = (long long)max;
    long long range = max_int - min_int + 1;
    
    // Safety check for range 0 or negative (though swapped above)
    if (range <= 0) return NUMBER_VAL(min_int);

    return NUMBER_VAL((double)(min_int + (rand() % range)));
}

// randint(min, max) - Random integer in [min, max]
static Value native_randint(int argCount, Value* args) {
    if (argCount < 2 || !IS_NUMBER(args[0]) || !IS_NUMBER(args[1])) {
        return NUMBER_VAL(0);
    }
    
    int min = (int)AS_NUMBER(args[0]);
    int max = (int)AS_NUMBER(args[1]);
    
    if (min > max) {
        int temp = min;
        min = max;
        max = temp;
    }
    
    int range = max - min + 1;
    return NUMBER_VAL(min + (rand() % range));
}

// seed(val)
static Value native_seed(int argCount, Value* args) {
    if (argCount > 0 && IS_NUMBER(args[0])) {
        srand((unsigned int)AS_NUMBER(args[0]));
    } else {
        srand((unsigned int)time(NULL));
    }
    return NIL_VAL;
}

// --------------------------------------------------
// Tensor Functions (Activation & Utilities)
// --------------------------------------------------

// sigmoid(tensor)
static Value native_sigmoid(int argCount, Value* args) {
    if (argCount < 1 || !IS_TENSOR(args[0])) {
        // runtimeError not easily accessible here without passing vm explicitly?
        // We use global vm extern
        // Ideally we should raise error.
        return NIL_VAL; 
    }
    
    ObjTensor* t = AS_TENSOR(args[0]);
    ObjTensor* res = newTensor(t->dimCount, t->dims, NULL);
    push(&vm, OBJ_VAL(res));
    
    for(int i=0; i<t->size; i++) {
        res->data[i] = 1.0 / (1.0 + exp(-t->data[i]));
    }
    
    return pop(&vm);
}

// relu(tensor)
static Value native_relu(int argCount, Value* args) {
    if (argCount < 1 || !IS_TENSOR(args[0])) return NIL_VAL;
    
    ObjTensor* t = AS_TENSOR(args[0]);
    ObjTensor* res = newTensor(t->dimCount, t->dims, NULL);
    push(&vm, OBJ_VAL(res));
    
    for(int i=0; i<t->size; i++) {
        double val = t->data[i];
        res->data[i] = (val > 0) ? val : 0;
    }
    
    return pop(&vm);
}

// tanh(tensor)
static Value native_tanh(int argCount, Value* args) {
    if (argCount < 1) return NIL_VAL;
    
    // Support Scalar tanh too
    if (IS_NUMBER(args[0])) {
        return NUMBER_VAL(tanh(AS_NUMBER(args[0])));
    }
    
    if (!IS_TENSOR(args[0])) return NIL_VAL;
    
    ObjTensor* t = AS_TENSOR(args[0]);
    ObjTensor* res = newTensor(t->dimCount, t->dims, NULL);
    push(&vm, OBJ_VAL(res));
    
    for(int i=0; i<t->size; i++) {
        res->data[i] = tanh(t->data[i]);
    }
    
    return pop(&vm);
}

// transpose(tensor)
static Value native_transpose(int argCount, Value* args) {
     if (argCount < 1 || !IS_TENSOR(args[0])) return NIL_VAL;
     
     ObjTensor* t = AS_TENSOR(args[0]);
     
     if (t->dimCount != 2) {
         // Fallback: Return copy if 1D? Or error?
         // For now return copy to be safe.
         ObjTensor* res = newTensor(t->dimCount, t->dims, NULL);
         push(&vm, OBJ_VAL(res));
         memcpy(res->data, t->data, t->size * sizeof(double));
         return pop(&vm);
     }
     
     // Swap dimensions
     int dims[2];
     dims[0] = t->dims[1];
     dims[1] = t->dims[0];
     
     ObjTensor* res = newTensor(2, dims, NULL);
     push(&vm, OBJ_VAL(res));
     
     int rows = t->dims[0];
     int cols = t->dims[1];
     
     // Transpose data
     for (int i = 0; i < rows; i++) {
         for (int j = 0; j < cols; j++) {
             // src[i, j] -> dst[j, i]
             // src flat: i * cols + j
             // dst flat: j * rows + i
             res->data[j * rows + i] = t->data[i * cols + j];
         }
     }
     
     return pop(&vm);
}

// Create std.native.math module
ObjModule* create_std_math_module() {
    // Initialize random seed once if needed, or rely on user seeding.
    // We can seed on module creation.
    static int seeded = 0;
    if (!seeded) {
        srand((unsigned int)time(NULL));
        seeded = 1;
    }

    ObjString* name = copyString("std.native.math", 15);
    push(&vm, OBJ_VAL(name));
    ObjModule* module = newModule(name);
    push(&vm, OBJ_VAL(module));
    
    defineModuleFn(module, "abs", native_abs);
    defineModuleFn(module, "ceil", native_ceil);
    defineModuleFn(module, "floor", native_floor);
    defineModuleFn(module, "round", native_round);
    defineModuleFn(module, "max", native_max);
    defineModuleFn(module, "min", native_min);
    defineModuleFn(module, "pow", native_pow);
    defineModuleFn(module, "sqrt", native_sqrt);
    defineModuleFn(module, "sin", native_sin);
    defineModuleFn(module, "cos", native_cos);
    defineModuleFn(module, "tan", native_tan);
    defineModuleFn(module, "asin", native_asin);
    defineModuleFn(module, "acos", native_acos);
    defineModuleFn(module, "atan", native_atan);
    defineModuleFn(module, "log", native_log);
    defineModuleFn(module, "exp", native_exp);
    defineModuleFn(module, "random", native_random);
    defineModuleFn(module, "randint", native_randint);
    defineModuleFn(module, "seed", native_seed);
    defineModuleFn(module, "sigmoid", native_sigmoid);
    defineModuleFn(module, "relu", native_relu);
    defineModuleFn(module, "tanh", native_tanh);
    defineModuleFn(module, "transpose", native_transpose);

    pop(&vm); // module
    pop(&vm); // name
    return module;
}

// Register math functions as globals (for benchmarks/ease of use)
void register_math_globals(VM* pVM) {
    defineNative(pVM, "abs", native_abs);
    defineNative(pVM, "ceil", native_ceil);
    defineNative(pVM, "floor", native_floor);
    defineNative(pVM, "round", native_round);
    defineNative(pVM, "max", native_max);
    defineNative(pVM, "min", native_min);
    defineNative(pVM, "pow", native_pow);
    defineNative(pVM, "sqrt", native_sqrt);
    defineNative(pVM, "sin", native_sin);
    defineNative(pVM, "cos", native_cos);
    defineNative(pVM, "tan", native_tan);
    defineNative(pVM, "asin", native_asin);
    defineNative(pVM, "acos", native_acos);
    defineNative(pVM, "atan", native_atan);
    defineNative(pVM, "log", native_log);
    defineNative(pVM, "exp", native_exp);
    defineNative(pVM, "random", native_random);
    defineNative(pVM, "randint", native_randint);
    defineNative(pVM, "seed", native_seed);
    defineNative(pVM, "sigmoid", native_sigmoid);
    defineNative(pVM, "relu", native_relu);
    defineNative(pVM, "tanh", native_tanh);
    defineNative(pVM, "transpose", native_transpose);
}