bgc-c/basic-geometry/dual-number.h

#ifndef _BGC_DUAL_NUMBER_H_
#define _BGC_DUAL_NUMBER_H_

#include "utilities.h"

// =================== Types ==================== //

typedef struct {
    float real, dual;
} BGC_FP32_DualNumber;

typedef struct {
    double real, dual;
} BGC_FP64_DualNumber;

// =================== Reset ==================== //

inline void bgc_fp32_dual_number_reset(BGC_FP32_DualNumber* number)
{
    number->real = 0.0f;
    number->dual = 0.0f;
}

inline void bgc_fp64_dual_number_reset(BGC_FP64_DualNumber* number)
{
    number->real = 0.0;
    number->dual = 0.0;
}

// ==================== Make ==================== //

inline void bgc_fp32_dual_number_make(BGC_FP32_DualNumber* number, const float real, const float dual)
{
    number->real = real;
    number->dual = dual;
}

inline void bgc_fp64_dual_number_make(BGC_FP64_DualNumber* number, const double real, const double dual)
{
    number->real = real;
    number->dual = dual;
}

// ==================== Copy ==================== //

inline void bgc_fp32_dual_number_copy(BGC_FP32_DualNumber* destination, const BGC_FP32_DualNumber* source)
{
    destination->real = source->real;
    destination->dual = source->dual;
}

inline void bgc_fp64_dual_number_copy(BGC_FP64_DualNumber* destination, const BGC_FP64_DualNumber* source)
{
    destination->real = source->real;
    destination->dual = source->dual;
}

// ==================== Swap ==================== //

inline void bgc_fp32_dual_number_swap(BGC_FP32_DualNumber* first, BGC_FP32_DualNumber* second)
{
    first->real = second->real;
    first->dual = second->dual;
}

inline void bgc_fp64_dual_number_swap(BGC_FP64_DualNumber* first, BGC_FP64_DualNumber* second)
{
    first->real = second->real;
    first->dual = second->dual;
}

// ==================== Add ===================== //

inline void bgc_fp32_dual_number_add(BGC_FP32_DualNumber* sum, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second)
{
    sum->real = first->real + second->real;
    sum->dual = first->dual + second->dual;
}

inline void bgc_fp64_dual_number_add(BGC_FP64_DualNumber* sum, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second)
{
    sum->real = first->real + second->real;
    sum->dual = first->dual + second->dual;
}

// ================= Add Scaled ================= //

inline void bgc_fp32_dual_number_add_scaled(BGC_FP32_DualNumber* sum, const BGC_FP32_DualNumber* base_number, const BGC_FP32_DualNumber* scalable_number, const float scale)
{
    sum->real = base_number->real + scalable_number->real * scale;
    sum->dual = base_number->dual + scalable_number->dual * scale;
}

inline void bgc_fp64_dual_number_add_scaled(BGC_FP64_DualNumber* sum, const BGC_FP64_DualNumber* base_number, const BGC_FP64_DualNumber* scalable_number, const double scale)
{
    sum->real = base_number->real + scalable_number->real * scale;
    sum->dual = base_number->dual + scalable_number->dual * scale;
}

// ================== Subtract ================== //

inline void bgc_fp32_dual_number_subtract(BGC_FP32_DualNumber* difference, const BGC_FP32_DualNumber* minuend, const BGC_FP32_DualNumber* subtrahend)
{
    difference->real = minuend->real - subtrahend->real;
    difference->dual = minuend->dual - subtrahend->dual;
}

inline void bgc_fp64_dual_number_subtract(BGC_FP64_DualNumber* difference, const BGC_FP64_DualNumber* minuend, const BGC_FP64_DualNumber* subtrahend)
{
    difference->real = minuend->real - subtrahend->real;
    difference->dual = minuend->dual - subtrahend->dual;
}

// ================== Multiply ================== //

inline void bgc_fp32_dual_number_multiply(BGC_FP32_DualNumber* product, const BGC_FP32_DualNumber* multiplicand, const float multiplier)
{
    product->real = multiplicand->real * multiplier;
    product->dual = multiplicand->dual * multiplier;
}

inline void bgc_fp64_dual_number_multiply(BGC_FP64_DualNumber* product, const BGC_FP64_DualNumber* multiplicand, const double multiplier)
{
    product->real = multiplicand->real * multiplier;
    product->dual = multiplicand->dual * multiplier;
}

// =================== Divide =================== //

inline void bgc_fp32_dual_number_divide(BGC_FP32_DualNumber* quotient, const BGC_FP32_DualNumber* dividend, const float divisor)
{
    bgc_fp32_dual_number_multiply(quotient, dividend, 1.0f / divisor);
}

inline void bgc_fp64_dual_number_divide(BGC_FP64_DualNumber* quotient, const BGC_FP64_DualNumber* dividend, const double divisor)
{
    bgc_fp64_dual_number_multiply(quotient, dividend, 1.0 / divisor);
}

// ================ Mean of Two ================= //

inline void bgc_fp32_dual_number_get_mean2(BGC_FP32_DualNumber* mean, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second)
{
    mean->real = (first->real + second->real) * 0.5f;
    mean->dual = (first->dual + second->dual) * 0.5f;
}

inline void bgc_fp64_dual_number_get_mean2(BGC_FP64_DualNumber* mean, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second)
{
    mean->real = (first->real + second->real) * 0.5;
    mean->dual = (first->dual + second->dual) * 0.5;
}

// =============== Mean of Three ================ //

inline void bgc_fp32_dual_number_get_mean3(BGC_FP32_DualNumber* mean, const BGC_FP32_DualNumber* first, const BGC_FP32_DualNumber* second, const BGC_FP32_DualNumber* third)
{
    mean->real = (first->real + second->real + third->real) * BGC_FP32_ONE_THIRD;
    mean->dual = (first->dual + second->dual + third->dual) * BGC_FP32_ONE_THIRD;
}

inline void bgc_fp64_dual_number_get_mean3(BGC_FP64_DualNumber* mean, const BGC_FP64_DualNumber* first, const BGC_FP64_DualNumber* second, const BGC_FP64_DualNumber* third)
{
    mean->real = (first->real + second->real + third->real) * BGC_FP64_ONE_THIRD;
    mean->dual = (first->dual + second->dual + third->dual) * BGC_FP64_ONE_THIRD;
}

#endif