vector3.h

Go to the documentation of this file.

 
#ifndef LIBA_VECTOR3_H
#define LIBA_VECTOR3_H
 
#include "a.h"
#include "math.h"

 
/* clang-format off */
#define A_VECTOR3_C(x, y, z) {a_real_c(x), a_real_c(y), a_real_c(z)}
/* clang-format on */

#define a_vector3_c(x) a_cast_s(a_vector3, x)
#define a_vector3_(_, x) a_cast_s(a_vector3 _, x)
 
typedef struct a_vector3 a_vector3;
 
#if defined(__cplusplus)
namespace a
{
typedef struct a_vector3 vector3;
} /* namespace a */
extern "C" {
#endif /* __cplusplus */
#if !defined A_HAVE_INLINE || defined(LIBA_VECTOR3_C)
#undef A_INTERN
#define A_INTERN A_PUBLIC extern
#endif /* A_HAVE_INLINE */

A_INTERN a_real a_vector3_set_dir(a_vector3 *ctx, a_real x, a_real y, a_real z);
A_INTERN void a_vector3_val(a_vector3 const *ctx, a_real *x, a_real *y, a_real *z);
A_INTERN void a_vector3_set_val(a_vector3 *ctx, a_real x, a_real y, a_real z);
A_INTERN void a_vector3_cyl(a_vector3 const *ctx, a_real *rho, a_real *theta, a_real *z);
A_INTERN void a_vector3_set_cyl(a_vector3 *ctx, a_real rho, a_real theta, a_real z);
A_INTERN void a_vector3_sph(a_vector3 const *ctx, a_real *rho, a_real *theta, a_real *alpha);
A_INTERN void a_vector3_set_sph(a_vector3 *ctx, a_real rho, a_real theta, a_real alpha);

A_INTERN void a_vector3_add(a_vector3 const *lhs, a_vector3 const *rhs, a_vector3 *res);
A_INTERN void a_vector3_sub(a_vector3 const *lhs, a_vector3 const *rhs, a_vector3 *res);
A_INTERN void a_vector3_mul(a_vector3 const *lhs, a_real rhs, a_vector3 *res);
A_INTERN void a_vector3_div(a_vector3 const *lhs, a_real rhs, a_vector3 *res);
A_INTERN void a_vector3_neg(a_vector3 const *ctx, a_vector3 *res);

A_EXTERN a_real a_vector3_unit(a_vector3 *ctx);
A_EXTERN a_real a_vector3_norm(a_vector3 const *ctx);
A_INTERN a_real a_vector3_norm2(a_vector3 const *ctx);
A_EXTERN a_real a_vector3_dist(a_vector3 const *lhs, a_vector3 const *rhs);
A_INTERN a_real a_vector3_dist2(a_vector3 const *lhs, a_vector3 const *rhs);
A_INTERN a_real a_vector3_dot(a_vector3 const *lhs, a_vector3 const *rhs);
A_INTERN void a_vector3_cross(a_vector3 const *lhs, a_vector3 const *rhs, a_vector3 *res);
A_INTERN void a_vector3_outer(a_vector3 const *lhs, a_vector3 const *rhs, a_real res[9]);
A_INTERN a_bool a_vector3_isver(a_vector3 const *lhs, a_vector3 const *rhs);
A_INTERN a_bool a_vector3_ispar(a_vector3 const *lhs, a_vector3 const *rhs);
A_EXTERN a_real a_vector3_angle(a_vector3 const *lhs, a_vector3 const *rhs);

A_EXTERN int a_vector3_basis(a_vector3 const *ctx, a_vector3 *u, a_vector3 *v);

A_EXTERN int a_vector3_decom(a_vector3 const *ctx, a_vector3 const *dir, a_vector3 *u, a_vector3 *v);

A_EXTERN int a_vector3_proj(a_vector3 const *ctx, a_vector3 const *dir, a_vector3 *res);
A_EXTERN int a_vector3_perp(a_vector3 const *ctx, a_vector3 const *dir, a_vector3 *res);
A_EXTERN int a_vector3_refl(a_vector3 const *ctx, a_vector3 const *dir, a_vector3 *res);
A_EXTERN int a_vector3_sym1(a_vector3 const *ctx, a_vector3 const *dir, a_vector3 *res);

A_INTERN void a_vector3_lerp(a_vector3 const *lhs, a_vector3 const *rhs, a_real val, a_vector3 *res);

A_EXTERN void a_vector3_rot_(a_vector3 const *ctx, a_vector3 const *dir, a_real sin, a_real cos, a_vector3 *res);
A_EXTERN void a_vector3_rot(a_vector3 const *ctx, a_vector3 const *dir, a_real angle, a_vector3 *res);
A_EXTERN void a_vector3_rot2d(a_vector3 const *iu, a_vector3 const *iv, a_real angle,
                              a_vector3 *ou, a_vector3 *ov);
 
#if !defined A_HAVE_INLINE || defined(LIBA_VECTOR3_C)
#undef A_INTERN
#define A_INTERN static A_INLINE
#endif /* A_HAVE_INLINE */
#if defined(__cplusplus)
} /* extern "C" */
#endif /* __cplusplus */
 
struct a_point3;
struct a_vector3
{
    a_real x, y, z;
#if defined(__cplusplus)
    A_INLINE void set(a_point3 const &p, a_point3 const &q);
    A_INLINE a_real set_dir(a_real x_, a_real y_, a_real z_)
    {
        return a_vector3_set_dir(this, x_, y_, z_);
    }

    A_INLINE void val(a_real &x_, a_real &y_, a_real &z_) const
    {
        a_vector3_val(this, &x_, &y_, &z_);
    }

    A_INLINE void set_val(a_real x_, a_real y_, a_real z_)
    {
        a_vector3_set_val(this, x_, y_, z_);
    }

    A_INLINE void cyl(a_real &rho, a_real &theta, a_real &z_) const
    {
        a_vector3_cyl(this, &rho, &theta, &z_);
    }

    A_INLINE void set_cyl(a_real rho, a_real theta, a_real z_)
    {
        a_vector3_set_cyl(this, rho, theta, z_);
    }

    A_INLINE void sph(a_real &rho, a_real &theta, a_real &alpha) const
    {
        a_vector3_sph(this, &rho, &theta, &alpha);
    }

    A_INLINE void set_sph(a_real rho, a_real theta, a_real alpha)
    {
        a_vector3_set_sph(this, rho, theta, alpha);
    }

    A_INLINE void add(a_vector3 const &rhs, a_vector3 &res) const
    {
        a_vector3_add(this, &rhs, &res);
    }

    A_INLINE void sub(a_vector3 const &rhs, a_vector3 &res) const
    {
        a_vector3_sub(this, &rhs, &res);
    }

    A_INLINE void mul(a_real rhs, a_vector3 &res) const
    {
        a_vector3_mul(this, rhs, &res);
    }

    A_INLINE void div(a_real rhs, a_vector3 &res) const
    {
        a_vector3_div(this, rhs, &res);
    }

    A_INLINE void neg(a_vector3 &res) const
    {
        a_vector3_neg(this, &res);
    }

    A_INLINE a_real unit() { return a_vector3_unit(this); }
    A_INLINE a_real norm() const { return a_vector3_norm(this); }
    A_INLINE a_real norm2() const { return a_vector3_norm2(this); }
    A_INLINE a_real dist(a_vector3 const &rhs) const
    {
        return a_vector3_dist(this, &rhs);
    }

    A_INLINE a_real dist2(a_vector3 const &rhs) const
    {
        return a_vector3_dist2(this, &rhs);
    }

    A_INLINE a_real dot(a_vector3 const &rhs) const
    {
        return a_vector3_dot(this, &rhs);
    }

    A_INLINE void cross(a_vector3 const &rhs, a_vector3 &res) const
    {
        a_vector3_cross(this, &rhs, &res);
    }

    A_INLINE void outer(a_vector3 const &rhs, a_real res[9]) const
    {
        a_vector3_outer(this, &rhs, res);
    }

    A_INLINE a_bool isver(a_vector3 const &rhs) const
    {
        return a_vector3_isver(this, &rhs);
    }

    A_INLINE a_bool ispar(a_vector3 const &rhs) const
    {
        return a_vector3_ispar(this, &rhs);
    }

    A_INLINE a_real angle(a_vector3 const &rhs) const
    {
        return a_vector3_angle(this, &rhs);
    }

    A_INLINE int basis(a_vector3 &u, a_vector3 &v) const
    {
        return a_vector3_basis(this, &u, &v);
    }

    A_INLINE int decom(a_vector3 const &dir, a_vector3 &u, a_vector3 &v) const
    {
        return a_vector3_decom(this, &dir, &u, &v);
    }

    A_INLINE int proj(a_vector3 const &dir, a_vector3 &res) const
    {
        return a_vector3_proj(this, &dir, &res);
    }

    A_INLINE int perp(a_vector3 const &dir, a_vector3 &res) const
    {
        return a_vector3_perp(this, &dir, &res);
    }

    A_INLINE int refl(a_vector3 const &dir, a_vector3 &res) const
    {
        return a_vector3_refl(this, &dir, &res);
    }

    A_INLINE int sym1(a_vector3 const &dir, a_vector3 &res) const
    {
        return a_vector3_sym1(this, &dir, &res);
    }

    A_INLINE void lerp(a_vector3 const &rhs, a_real val, a_vector3 &res) const
    {
        a_vector3_lerp(this, &rhs, val, &res);
    }

    A_INLINE void rot(a_vector3 const &dir, a_real angle, a_vector3 &res) const
    {
        a_vector3_rot(this, &dir, angle, &res);
    }

    A_INLINE void rot(a_vector3 const &dir, a_real sin, a_real cos, a_vector3 &res) const
    {
        a_vector3_rot_(this, &dir, sin, cos, &res);
    }

    static A_INLINE void rot2d(a_vector3 const &iu, a_vector3 const &iv, a_real angle,
                               a_vector3 &ou, a_vector3 &ov)
    {
        a_vector3_rot2d(&iu, &iv, angle, &ou, &ov);
    }

    friend A_INLINE a_vector3 operator^(a_vector3 const &lhs, a_vector3 const &rhs)
    {
        a_vector3 res;
        a_vector3_cross(&lhs, &rhs, &res);
        return res;
    }

    friend A_INLINE void operator+=(a_vector3 &lhs, a_vector3 const &rhs) { a_vector3_add(&lhs, &rhs, &lhs); }
    friend A_INLINE a_vector3 operator+(a_vector3 const &lhs, a_vector3 const &rhs)
    {
        a_vector3 res;
        a_vector3_add(&lhs, &rhs, &res);
        return res;
    }

    friend A_INLINE void operator-=(a_vector3 &lhs, a_vector3 const &rhs) { a_vector3_sub(&lhs, &rhs, &lhs); }
    friend A_INLINE a_vector3 operator-(a_vector3 const &lhs, a_vector3 const &rhs)
    {
        a_vector3 res;
        a_vector3_sub(&lhs, &rhs, &res);
        return res;
    }

    friend A_INLINE a_real operator*(a_vector3 const &lhs, a_vector3 const &rhs)
    {
        return a_vector3_dot(&lhs, &rhs);
    }

    friend A_INLINE void operator*=(a_vector3 &lhs, a_real rhs) { a_vector3_mul(&lhs, rhs, &lhs); }
    friend A_INLINE a_vector3 operator*(a_real lhs, a_vector3 const &rhs)
    {
        a_vector3 res;
        a_vector3_mul(&rhs, lhs, &res);
        return res;
    }

    friend A_INLINE a_vector3 operator*(a_vector3 const &lhs, a_real rhs)
    {
        a_vector3 res;
        a_vector3_mul(&lhs, rhs, &res);
        return res;
    }

    friend A_INLINE void operator/=(a_vector3 &lhs, a_real rhs) { a_vector3_div(&lhs, rhs, &lhs); }
    friend A_INLINE a_vector3 operator/(a_vector3 const &lhs, a_real rhs)
    {
        a_vector3 res;
        a_vector3_div(&lhs, rhs, &res);
        return res;
    }
    friend A_INLINE a_vector3 operator+(a_vector3 const &rhs) { return rhs; }
    friend A_INLINE a_vector3 operator-(a_vector3 const &rhs)
    {
        a_vector3 res;
        a_vector3_neg(&rhs, &res);
        return res;
    }
#endif /* __cplusplus */
};
 
#if defined(LIBA_VECTOR3_C)
#undef A_INTERN
#define A_INTERN A_INLINE
#endif /* LIBA_VECTOR3_C */
#if defined(A_HAVE_INLINE) || defined(LIBA_VECTOR3_C)
 
A_INLINE a_real a_vector3_set_dir(a_vector3 *ctx, a_real x, a_real y, a_real z)
{
    ctx->x = x;
    ctx->y = y;
    ctx->z = z;
    return a_vector3_unit(ctx);
}
A_INTERN void a_vector3_val(a_vector3 const *ctx, a_real *x, a_real *y, a_real *z)
{
    *x = ctx->x;
    *y = ctx->y;
    *z = ctx->z;
}
A_INTERN void a_vector3_set_val(a_vector3 *ctx, a_real x, a_real y, a_real z)
{
    ctx->x = x;
    ctx->y = y;
    ctx->z = z;
}
A_INTERN void a_vector3_cyl(a_vector3 const *ctx, a_real *rho, a_real *theta, a_real *z)
{
    a_real_cart2pol(ctx->x, ctx->y, rho, theta);
    *z = ctx->z;
}
A_INTERN void a_vector3_set_cyl(a_vector3 *ctx, a_real rho, a_real theta, a_real z)
{
    a_real_pol2cart(rho, theta, &ctx->x, &ctx->y);
    ctx->z = z;
}
A_INTERN void a_vector3_sph(a_vector3 const *ctx, a_real *rho, a_real *theta, a_real *alpha)
{
    a_real_cart2sph(ctx->x, ctx->y, ctx->z, rho, theta, alpha);
}
A_INTERN void a_vector3_set_sph(a_vector3 *ctx, a_real rho, a_real theta, a_real alpha)
{
    a_real_sph2cart(rho, theta, alpha, &ctx->x, &ctx->y, &ctx->z);
}
A_INTERN void a_vector3_add(a_vector3 const *lhs, a_vector3 const *rhs, a_vector3 *res)
{
    res->x = lhs->x + rhs->x;
    res->y = lhs->y + rhs->y;
    res->z = lhs->z + rhs->z;
}
A_INTERN void a_vector3_sub(a_vector3 const *lhs, a_vector3 const *rhs, a_vector3 *res)
{
    res->x = lhs->x - rhs->x;
    res->y = lhs->y - rhs->y;
    res->z = lhs->z - rhs->z;
}
A_INTERN void a_vector3_mul(a_vector3 const *lhs, a_real rhs, a_vector3 *res)
{
    res->x = lhs->x * rhs;
    res->y = lhs->y * rhs;
    res->z = lhs->z * rhs;
}
A_INTERN void a_vector3_div(a_vector3 const *lhs, a_real rhs, a_vector3 *res)
{
    res->x = lhs->x / rhs;
    res->y = lhs->y / rhs;
    res->z = lhs->z / rhs;
}
A_INTERN void a_vector3_neg(a_vector3 const *ctx, a_vector3 *res)
{
    res->x = -ctx->x;
    res->y = -ctx->y;
    res->z = -ctx->z;
}
 
A_INTERN a_real a_vector3_norm2(a_vector3 const *ctx)
{
    return ctx->x * ctx->x + ctx->y * ctx->y + ctx->z * ctx->z;
}
 
A_INTERN a_real a_vector3_dist2(a_vector3 const *lhs, a_vector3 const *rhs)
{
    a_real const x = rhs->x - lhs->x;
    a_real const y = rhs->y - lhs->y;
    a_real const z = rhs->z - lhs->z;
    return x * x + y * y + z * z;
}
 
A_INTERN a_real a_vector3_dot(a_vector3 const *lhs, a_vector3 const *rhs)
{
    return lhs->x * rhs->x + lhs->y * rhs->y + lhs->z * rhs->z;
}
 
A_INTERN void a_vector3_cross(a_vector3 const *lhs, a_vector3 const *rhs, a_vector3 *res)
{
    a_real const x = lhs->y * rhs->z - lhs->z * rhs->y;
    a_real const y = lhs->z * rhs->x - lhs->x * rhs->z;
    a_real const z = lhs->x * rhs->y - lhs->y * rhs->x;
    res->x = x;
    res->y = y;
    res->z = z;
}
 
A_INTERN void a_vector3_outer(a_vector3 const *lhs, a_vector3 const *rhs, a_real res[9])
{
    res[0] = lhs->x * rhs->x;
    res[1] = lhs->x * rhs->y;
    res[2] = lhs->x * rhs->z;
    res[3] = lhs->y * rhs->x;
    res[4] = lhs->y * rhs->y;
    res[5] = lhs->y * rhs->z;
    res[6] = lhs->z * rhs->x;
    res[7] = lhs->z * rhs->y;
    res[8] = lhs->z * rhs->z;
}
 
A_INTERN a_bool a_vector3_isver(a_vector3 const *lhs, a_vector3 const *rhs)
{
    a_real const r = lhs->x * rhs->x + lhs->y * rhs->y + lhs->z * rhs->z;
    return A_ABS(r) < A_REAL_TOL;
}
 
A_INTERN a_bool a_vector3_ispar(a_vector3 const *lhs, a_vector3 const *rhs)
{
    a_real x, y, z;
    z = lhs->x * rhs->y - lhs->y * rhs->x;
    if (!(A_ABS(z) < A_REAL_TOL)) { return 0; }
    y = lhs->z * rhs->x - lhs->x * rhs->z;
    if (!(A_ABS(y) < A_REAL_TOL)) { return 0; }
    x = lhs->y * rhs->z - lhs->z * rhs->y;
    if (!(A_ABS(x) < A_REAL_TOL)) { return 0; }
    return 1;
}
 
A_INTERN void a_vector3_lerp(a_vector3 const *lhs, a_vector3 const *rhs, a_real val, a_vector3 *res)
{
    res->x = lhs->x + (rhs->x - lhs->x) * val;
    res->y = lhs->y + (rhs->y - lhs->y) * val;
    res->z = lhs->z + (rhs->z - lhs->z) * val;
}
 
#endif /* A_HAVE_INLINE */
#if defined(LIBA_VECTOR3_C)
#undef A_INTERN
#define A_INTERN static A_INLINE
#endif /* LIBA_VECTOR3_C */

 
#endif /* a/vector3.h */