#ifndef MICRO_LA

#define MICRO_LA

#define MICRO_LA_MAJOR 0

#define MICRO_LA_MINOR 1

#ifdef __cplusplus

extern "C" {

#ifndef MICRO_LA_DEF

#define MICRO_LA_DEF static inline

#ifndef MICRO_LA_ASSERT

#include <assert.h>

#define MICRO_LA_ASSERT assert

#ifndef MICRO_LA_MALLOC

#include <stdlib.h>

#define MICRO_LA_MALLOC malloc

#ifndef MICRO_LA_FREE

#define MICRO_LA_FREE free

#define MICRO_LA_OK 0

#define _MICRO_LA_ERROR_MAX -1

#if __STDC_VERSION__ >= 201112L // >= C11

typedef union {

struct { double a; double b; double c; double d; };

struct { double r; double i; double j; double k; };

struct { double first; double second; double third; double fourth; };

double v[4];

} Quaternion;

typedef struct {

double a;

double b;

double c;

double d;

} Quaternion;

MICRO_LA_DEF Quaternion micro_la_quaternion_prod(Quaternion p, Quaternion q);

MICRO_LA_DEF Quaternion micro_la_quaternion_recip(Quaternion p);

MICRO_LA_DEF Quaternion micro_la_quaternion_rotate(Quaternion p, double angle);

#ifndef PI

#define PI 3.14159265358979323846f

#ifndef EULER

#define EULER 2.7182818284590452353f

MICRO_LA_DEF float micro_floorf(float x)

{

if (x >= 0.0f)

return (float)((int)x);

int i = (int)x;

float f = (float)i;

// If x is negative and not already a whole integer,

// the cast truncated "up" toward zero, so we subtract 1.

if (f > x)

return f - 1.0f;

return f;

}

MICRO_LA_DEF float micro_sqrtf(float x)

{

if (x <= 0) return 0;

// Initial guess (the closer the better, but x/2 works)

float guess = x;

// 5 iterations is usually enough for float precision

for (int i = 0; i < 5; i++) {

guess = 0.5f * (guess + x / guess);

}

return guess;

}

MICRO_LA_DEF float micro_sin(float x)

{

// Fast range reduction for large x, to map x to [-PI, PI]

x = x - (2.0f * PI) * micro_floorf((x + PI) / (2.0f * PI));

// Taylor Series (7 terms for high precision)

float x2 = x * x;

float term = x;

float sum = x;

// We calculate terms iteratively to avoid large factorial divisions

term *= -x2 / (2 * 3); sum += term; // x^3

term *= -x2 / (4 * 5); sum += term; // x^5

term *= -x2 / (6 * 7); sum += term; // x^7

term *= -x2 / (8 * 9); sum += term; // x^9

return sum;

}

MICRO_LA_DEF float micro_cos(float x)

{

return micro_sin(x + 1.57079632f); // x + PI/2

}

MICRO_LA_DEF float micro_tan(float x)

{

return micro_sin(x) / micro_cos(x);

}

MICRO_LA_DEF float micro_arctan(float x)

{

// 1. Handle range reduction to |x| <= 1

if (x > 1.0f) return (PI / 2.0f) - micro_arctan(1.0f / x);

if (x < -1.0f) return (-PI / 2.0f) - micro_arctan(1.0f / x);

// 2. Taylor series: x - x^3/3 + x^5/5 - x^7/7 + x^9/9

float x2 = x * x;

float x_pow = x;

float sum = x;

x_pow *= -x2; sum += x_pow / 3.0f;

x_pow *= -x2; sum += x_pow / 5.0f;

x_pow *= -x2; sum += x_pow / 7.0f;

x_pow *= -x2; sum += x_pow / 9.0f;

return sum;

}

MICRO_LA_DEF float micro_arccos(float x)

{

// Clamp input to valid range [-1, 1] to avoid NaN

if (x <= -1.0f) return PI;

if (x >= 1.0f) return 0.0f;

// Use the arctan identity for better stability

float val = micro_sqrtf(1.0f - x * x) / (1.0f + x);

return 2.0f * micro_arctan(val);

}

MICRO_LA_DEF float micro_arcsin(float x)

{

// Clamp to valid domain [-1, 1]

if (x >= 1.0f) return PI / 2.0f;

if (x <= -1.0f) return -PI / 2.0f;

// Use the arctan identity: arcsin(x) = arctan(x / sqrt(1-x^2))

float denom = micro_sqrtf(1.0f - x * x);

return micro_arctan(x / denom);

}

#ifndef micro_la_abs

#define micro_la_abs(x) ((x) > 0) ? (x) : -(x)

#define MICRO_LA_LCG_MAGIC1 1664525 // a

#define MICRO_LA_LCG_MAGIC2 1013904223 // c

#define MICRO_LA_LCG_MAGIC3 (1<<31) // m

static inline unsigned int micro_la_lcg(const unsigned int seed)

{

return (MICRO_LA_LCG_MAGIC1 * seed + MICRO_LA_LCG_MAGIC2) % MICRO_LA_LCG_MAGIC3;

}

MICRO_LA_DEF unsigned int micro_la_rand(void)

{

static unsigned int seed = 6969;

seed = micro_la_lcg(seed);

return seed;

}

#define Vec2_IMPL(type, suffix) \

MICRO_LA_DEF Vec2##suffix \

Vec2##suffix##_scale(Vec2##suffix vec, \

Vec2##suffix scale) \

{ \

return (Vec2##suffix) { \

.x = vec.x * scale.x, .y = vec.y * scale.y, \

}; \

} \

\

MICRO_LA_DEF Vec2##suffix \

Vec2##suffix##_translate(Vec2##suffix vec, \

Vec2##suffix translation) \

{ \

return (Vec2##suffix) { \

.x = vec.x + translation.x, \

.y = vec.y + translation.y, \

}; \

} \

\

MICRO_LA_DEF Vec2##suffix \

Vec2##suffix##_rotate(Vec2##suffix vec, \

double angle) \

{ \

Quaternion vec_quaternion = \

(Quaternion){ .a = 0, .b = vec.x, .c = vec.y, .d = 0};\

Quaternion rotated_quaternion = \

micro_la_quaternion_rotate(vec_quaternion, angle); \

return (Vec2##suffix) { \

.x = rotated_quaternion.b, .y = rotated_quaternion.c, \

}; \

} \

\

MICRO_LA_DEF float \

Vec2##suffix##_dot(Vec2##suffix a, Vec2##suffix b) \

{ \

return a.x * b.x + a.y * b.y; \

} \

\

MICRO_LA_DEF float \

Vec2##suffix##_cross(Vec2##suffix a, Vec2##suffix b) \

{ \

return (a.x * b.y) - (a.y * b.x); \

} \

\

MICRO_LA_DEF void \

Vec2##suffix##_add(Vec2##suffix *a, Vec2##suffix b) \

{ \

a->x += b.x; \

a->y += b.y; \

} \

\

MICRO_LA_DEF void \

Vec2##suffix##_sub(Vec2##suffix *a, Vec2##suffix b) \

{ \

a->x -= b.x; \

a->y -= b.y; \

} \

\

MICRO_LA_DEF bool \

Vec2##suffix##_eq(Vec2##suffix a, Vec2##suffix b) \

{ \

return (a.x == b.x && a.y == b.y); \

} \

\

MICRO_LA_DEF float \

Vec2##suffix##_length(Vec2##suffix a) \

{ \

return micro_sqrtf(a.x * a.x + a.y*a.y); \

}

#define Vec3_IMPL(type, suffix) \

MICRO_LA_DEF Vec3##suffix \

Vec3##suffix##_scale(Vec3##suffix vec, \

Vec3##suffix scale) \

{ \

return (Vec3##suffix) { \

.x = vec.x * scale.x, .y = vec.y * scale.y, \

.z = vec.z * scale.z, \

}; \

} \

\

MICRO_LA_DEF Vec3##suffix \

Vec3##suffix##_translate(Vec3##suffix vec, \

Vec3##suffix translation) \

{ \

return (Vec3##suffix) { \

.x = vec.x + translation.x, \

.y = vec.y + translation.y, \

.z = vec.z + translation.z, \

}; \

} \

\

MICRO_LA_DEF Vec3##suffix \

Vec3##suffix##_rotate(Vec3##suffix vec, \

double angle) \

{ \

Quaternion vec_quaternion = \

(Quaternion){ .a = 0, .b = vec.x, .c = vec.y, .d = vec.z};\

Quaternion rotated_quaternion = \

micro_la_quaternion_rotate(vec_quaternion, angle); \

return (Vec3##suffix) { \

.x = rotated_quaternion.b, .y = rotated_quaternion.c, \

.z = rotated_quaternion.d, \

}; \

} \

\

MICRO_LA_DEF float \

Vec3##suffix##_dot(Vec3##suffix a, Vec3##suffix b) \

{ \

return a.x * b.x + a.y * b.y + a.z * b.z; \

} \

\

MICRO_LA_DEF Vec3##suffix \

Vec3##suffix##_cross(Vec3##suffix a, Vec3##suffix b) \

{ \

Vec3##suffix result; \

result.x = (a.y * b.z) - (a.z * b.y); \

result.y = (a.z * b.x) - (a.x * b.z); \

result.z = (a.x * b.y) - (a.y * b.x); \

return result; \

} \

\

MICRO_LA_DEF void \

Vec3##suffix##_add(Vec3##suffix *a, Vec3##suffix b) \

{ \

a->x += b.x; \

a->y += b.y; \

a->z += b.z; \

} \

\

MICRO_LA_DEF void \

Vec3##suffix##_sub(Vec3##suffix *a, Vec3##suffix b) \

{ \

a->x -= b.x; \

a->y -= b.y; \

a->z -= b.z; \

} \

\

MICRO_LA_DEF bool \

Vec3##suffix##_eq(Vec3##suffix a, Vec3##suffix b) \

{ \

return (a.x == b.x && a.y == b.y && a.z == b.z); \

} \

\

MICRO_LA_DEF float \

Vec3##suffix##_length(Vec3##suffix a) \

{ \

return micro_sqrtf(a.x * a.x + a.y*a.y + a.z * a.z); \

}

#define Vec4_IMPL(type, suffix) \

MICRO_LA_DEF Vec4##suffix \

Vec4##suffix##_scale(Vec4##suffix vec, \

Vec4##suffix scale) \

{ \

return (Vec4##suffix) { \

.a = vec.a * scale.a, .b = vec.b * scale.b, \

.c = vec.c * scale.c, .d = vec.d * scale.d, \

}; \

} \

\

MICRO_LA_DEF Vec4##suffix \

Vec4##suffix##_translate(Vec4##suffix vec, \

Vec4##suffix translation) \

{ \

return (Vec4##suffix) { \

.a = vec.a + translation.a, \

.b = vec.b + translation.b, \

.c = vec.c + translation.c, \

.d = vec.d + translation.d, \

}; \

} \

\

MICRO_LA_DEF float \

Vec4##suffix##_dot(Vec4##suffix a, Vec4##suffix b) \

{ \

return a.a * b.a + a.b * b.b + a.c * b.c + a.d * b.d; \

} \

\

MICRO_LA_DEF void \

Vec4##suffix##_add(Vec4##suffix *a, Vec4##suffix b) \

{ \

a->a += b.a; \

a->b += b.b; \

a->c += b.c; \

a->d += b.d; \

} \

\

MICRO_LA_DEF void \

Vec4##suffix##_sub(Vec4##suffix *a, Vec4##suffix b) \

{ \

a->a -= b.a; \

a->b -= b.b; \

a->c -= b.c; \

a->d -= b.d; \

} \

\

MICRO_LA_DEF bool \

Vec4##suffix##_eq(Vec4##suffix a, Vec4##suffix b) \

{ \

return (a.a == b.a && a.b == b.b && a.c == b.c && a.d == b.d); \

} \

\

MICRO_LA_DEF float \

Vec4##suffix##_length(Vec4##suffix a) \

{ \

return micro_sqrtf(a.a * a.a + a.b*a.b + a.c * a.c + a.d * a.d); \

}

#define MAT_AT(m, row, col) (m).elements[(row) * (m).cols + (col)]

#define Mat_IMPL(type, suffix) \

MICRO_LA_DEF Mat##suffix \

Mat##suffix##_init(unsigned int rows, unsigned int cols) \

{ \

return (Mat##suffix) { \

.rows = rows, \

.cols = cols, \

.elements = MICRO_LA_MALLOC(rows * cols), \

}; \

} \

\

MICRO_LA_DEF void \

Mat##suffix##_free(Mat##suffix *mat) \

{ \

if (!mat || !mat->elements) return; \

MICRO_LA_FREE(mat->elements); \

mat->elements = NULL; \

} \

\

MICRO_LA_DEF void \

Mat##suffix##_copy(Mat##suffix *a, Mat##suffix b) \

{ \

for (unsigned int row = 0; row < a->rows; ++row) \

for (unsigned int col = 0; col < a->cols; ++col) \

MAT_AT(*a, row, col) = MAT_AT(b, row, col); \

} \

\

MICRO_LA_DEF void \

Mat##suffix##_add(Mat##suffix *a, Mat##suffix b) \

{ \

for (unsigned int row = 0; row < a->rows; ++row) \

for (unsigned int col = 0; col < a->cols; ++col) \

MAT_AT(*a, row, col) += MAT_AT(b, row, col); \

} \

\

MICRO_LA_DEF void \

Mat##suffix##_sub(Mat##suffix *a, Mat##suffix b) \

{ \

for (unsigned int row = 0; row < a->rows; ++row) \

for (unsigned int col = 0; col < a->cols; ++col) \

MAT_AT(*a, row, col) -= MAT_AT(b, row, col); \

} \

\

MICRO_LA_DEF void \

Mat##suffix##_fill(Mat##suffix *a, type value) \

{ \

for (unsigned int row = 0; row < a->rows; ++row) \

for (unsigned int col = 0; col < a->cols; ++col) \

MAT_AT(*a, row, col) = value; \

} \

\

MICRO_LA_DEF void \

Mat##suffix##_rand(Mat##suffix *a) \

{ \

for (unsigned int row = 0; row < a->rows; ++row) \

for (unsigned int col = 0; col < a->cols; ++col) \

MAT_AT(*a, row, col) = (type)micro_la_rand(); \

} \

\

MICRO_LA_DEF void \

Mat##suffix##_mul(Mat##suffix *dest, Mat##suffix a, Mat##suffix b) \

{ \

MICRO_LA_ASSERT(a.cols == b.rows); \

MICRO_LA_ASSERT(dst.rows == a.rows); \

MICRO_LA_ASSERT(dst.cols == b.cols); \

\

for (unsigned int row = 0; row < a.rows; ++row) \

for (unsigned int col = 0; col < a.cols; ++col) \

{ \

MAT_AT(*dest, row, col) = 0; \

for (unsigned int k = 0; k < a.cols; ++k) \

MAT_AT(*dest, row, col) += \

MAT_AT(a, row, k) * MAT_AT(b, k, col); \

} \

}

#define Rect_IMPL(type, suffix) \

MICRO_LA_DEF Rect##suffix \

Rect##suffix##_scale(Rect##suffix rect, \

Vec2f scale) \

{ \

return (Rect##suffix) { \

.a_x = rect.a_x * scale.x, .a_y = rect.a_y * scale.y, \

.b_x = rect.b_x * scale.x, .b_y = rect.b_y * scale.y, \

.c_x = rect.c_x * scale.x, .c_y = rect.c_y * scale.y, \

.d_x = rect.d_x * scale.x, .d_y = rect.d_y * scale.y, \

}; \

} \

\

MICRO_LA_DEF Rect##suffix \

Rect##suffix##_translate(Rect##suffix rect, \

Vec2f translation) \

{ \

return (Rect##suffix) { \

.a_x = rect.a_x * translation.x, \

.a_y = rect.a_y * translation.y, \

.b_x = rect.b_x * translation.x, \

.b_y = rect.b_y * translation.y, \

.c_x = rect.c_x * translation.x, \

.c_y = rect.c_y * translation.y, \

.d_x = rect.d_x * translation.x, \

.d_y = rect.d_y * translation.y, \

}; \

} \

\

MICRO_LA_DEF float \

Rect##suffix##_area(Rect##suffix rect) \

{ \

float delta_base_x = rect.a_x - rect.b_x; \

float delta_base_y = rect.a_y - rect.b_y; \

float delta_height_x = rect.b_x - rect.c_x; \

float delta_height_y = rect.b_y - rect.c_y; \

float base = micro_sqrtf(delta_base_x * delta_base_x \

+ delta_base_y * delta_base_y); \

float height = micro_sqrtf(delta_height_x * delta_height_x \

+ delta_height_y * delta_height_y); \

return base * height; \

}

#define Circle_IMPL(type, suffix) \

MICRO_LA_DEF Circle##suffix \

Circle##suffix##_scale(Circle##suffix circle, \

float scale) \

{ \

return (Circle##suffix) { \

.c_x = circle.c_x, .c_y = circle.c_y, \

.r = circle.r * scale, \

}; \

} \

\

MICRO_LA_DEF Circle##suffix \

Circle##suffix##_translate(Circle##suffix circle, \

Vec2f translation) \

{ \

return (Circle##suffix) { \

.c_x = circle.c_x + translation.x, \

.c_y = circle.c_y + translation.y, \

.r = circle.r, \

}; \

} \

\

MICRO_LA_DEF float \

Circle##suffix##_circumference(Circle##suffix circle) \

{ \

return 2 * PI * circle.r; \

} \

\

MICRO_LA_DEF float \

Circle##suffix##_area(Circle##suffix circle) \

{ \

return PI * circle.r * circle.r; \

}

#define Triangle_IMPL(type, suffix) \

MICRO_LA_DEF Triangle##suffix \

Triangle##suffix##_scale(Triangle##suffix triangle, \

Vec2f scale) \

{ \

return (Triangle##suffix) { \

.a_x = triangle.a_x * scale.x, \

.a_y = triangle.a_y * scale.y, \

.b_x = triangle.b_x * scale.x, \

.b_y = triangle.b_y * scale.y, \

.c_x = triangle.c_x * scale.x, \

.c_y = triangle.c_y * scale.y, \

}; \

} \

\

MICRO_LA_DEF Triangle##suffix \

Triangle##suffix##_translate(Triangle##suffix triangle, \

Vec2f translation) \

{ \

return (Triangle##suffix) { \

.a_x = triangle.a_x * translation.x, \

.a_y = triangle.a_y * translation.y, \

.b_x = triangle.b_x * translation.x, \

.b_y = triangle.b_y * translation.y, \

.c_x = triangle.c_x * translation.x, \

.c_y = triangle.c_y * translation.y, \

}; \

} \

\

MICRO_LA_DEF float \

Triangle##suffix##_area(Triangle##suffix triangle) \

{ \

return (triangle.b_x - triangle.a_x) \

* (triangle.c_y - triangle.a_y) \

- (triangle.c_x - triangle.a_x) \

* (triangle.b_x - triangle.a_y); \

}

#if __STDC_VERSION__ >= 201112L // >= C11

#define Vec2_DEF(type, suffix) \

typedef union { \

struct { type x; type y; }; \

struct { type a; type b; }; \

struct { type first; type second; }; \

type v[2]; \

} Vec2##suffix; \

Vec2_IMPL(type, suffix)

#define Vec3_DEF(type, suffix) \

typedef union { \

struct { type x; type y; type z; }; \

struct { type a; type b; type c; }; \

struct { type first; type second; type third; }; \

type v[3]; \

} Vec3##suffix; \

Vec3_IMPL(type, suffix)

#define Vec4_DEF(type, suffix) \

typedef union { \

struct { type a; type b; type c; type d; }; \

struct { type r; type i; type j; type k; }; \

struct { type first; type second; type third; type fourth; }; \

type v[4]; \

} Vec4##suffix; \

Vec4_IMPL(type, suffix)

#define Rect_DEF(type, suffix) \

typedef union { \

struct { \

type a_x; type a_y; \

type b_x; type b_y; \

type c_x; type c_y; \

type d_x; type d_y; \

}; \

type v[8]; \

} Rect##suffix; \

Rect_IMPL(type, suffix)

#define Circle_DEF(type, suffix) \

typedef union { \

struct { type c_x; type c_y; type r; }; \

struct { type center_x; type center_y; type radius; }; \

type v[3]; \

} Circle##suffix; \

Circle_IMPL(type, suffix)

#define Triangle_DEF(type, suffix) \

typedef union { \

struct { \

type a_x; type a_y; \

type b_x; type b_y; \

type c_x; type c_y; \

}; \

type v[6]; \

} Triangle##suffix; \

Triangle_IMPL(type, suffix)

#else // < C11

#define Vec2_DEF(type, suffix) \

typedef struct { \

type x; \

type y; \

} Vec2##suffix; \

Vec2_IMPL(type, suffix)

#define Vec3_DEF(type, suffix) \

typedef struct { \

type x; \

type y; \

type z; \

} Vec3##suffix; \

Vec3_IMPL(type, suffix)

#define Vec4_DEF(type, suffix) \

typedef struct { \

type a; \

type b; \

type c; \

type d; \

} Vec4##suffix; \

Vec4_IMPL(type, suffix)

#define Rect_DEF(type, suffix) \

typedef struct { \

type a_x; type a_y; \

type b_x; type b_y; \

type c_x; type c_y; \

type d_x; type d_y; \

} Rect##suffix; \

Rect_IMPL(type, suffix)

#define Circle_DEF(type, suffix) \

typedef struct { \

type c_x; type c_y; \

type r; \

} Circle##suffix; \

Circle_IMPL(type, suffix)

#define Triangle_DEF(type, suffix) \

typedef struct { \

type a_x; type a_y; \

type b_x; type b_y; \

type c_x; type c_y; \

} Triangle##suffix; \

Triangle_IMPL(type, suffix)

#endif // __STDC_VERSION__ >= 201112L // C11

#define Mat_DEF(type, suffix) \

typedef struct { \

unsigned int cols; \

unsigned int rows; \

type *elements; \

} Mat##suffix; \

Mat_IMPL(type, suffix)

Vec2_DEF(int, i)

Vec2_DEF(float, f)

Vec3_DEF(int, i)

Vec3_DEF(float, f)

Vec4_DEF(int, i)

Vec4_DEF(float, f)

Mat_DEF(int, i)

Mat_DEF(float, f)

Rect_DEF(int, i)

Rect_DEF(float, f)

Circle_DEF(int, i)

Circle_DEF(float, f)

Triangle_DEF(int, i)

Triangle_DEF(float, f)

MICRO_LA_DEF Quaternion micro_la_quaternion_prod(Quaternion p, Quaternion q)

{

return (Quaternion) {

.a = p.a * q.a - p.b * q.b - p.c * q.c - p.d * q.d,

.b = p.a * q.b + p.b * q.a + p.c * q.d - p.d * q.c,

.c = p.a * q.c - p.b * q.d + p.c * q.a + p.d * q.b,

.d = p.a * q.d + p.b * q.c - p.c * q.b + p.d * q.a,

};

}

MICRO_LA_DEF Quaternion micro_la_quaternion_recip(Quaternion p)

{

double q = p.a * p.a + p.b * p.b + p.c * p.c + p.d * p.d;

return (Quaternion) {

.a = p.a / q,

.b = -p.b / q,

.c = -p.c / q,

.d = -p.d / q

};

}

MICRO_LA_DEF Quaternion

micro_la_quaternion_rotate(Quaternion vec_quaternion, double angle)

{

Quaternion rot_quaternion =

(Quaternion){ .a = micro_cos(angle / 2), .b = 0, .c = 0, .d = micro_sin(angle / 2)};

Quaternion rot_quaternion_recip =

micro_la_quaternion_recip(rot_quaternion);

Quaternion first_prod =

micro_la_quaternion_prod(rot_quaternion, vec_quaternion);

return micro_la_quaternion_prod(first_prod, rot_quaternion_recip);

}

#ifdef __cplusplus

}

#endif // MICRO_LA