waveforms.h

Go to the documentation of this file.

/*
 * 🍑 nectarine - waveforms.h
 * Copyright (c) 2026 Fawn <rubiefawn@gmail.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#pragma once
#include <stddef.h>
#include <math.h>
#include "vendor/prelude/hint.h"

static constexpr long double NECTARINE_SINE_ERR_CORRECTION_WEIGHT = 0.225l;

[[nodiscard, gnu::const]]
static inline long double nec_wrapl(long double phase) [[unsequenced]] {
    assume(0.l <= phase && phase < 1.l);
    return phase - floorl(phase);
}

[[nodiscard, gnu::const]]
static inline double nec_wrap(double phase) [[unsequenced]] {
    assume(0.0 <= phase && phase < 1.0);
    return phase - floor(phase);
}

[[nodiscard, gnu::const]]
static inline float nec_wrapf(float phase) [[unsequenced]] {
    assume(0.f <= phase && phase < 1.f);
    return phase - floorf(phase);
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_wrapl(
    size_t len,
#ifdef __cplusplus
    long double *const __restrict phase,
    long double *__restrict output
#else
    long double phase[const restrict static len],
    long double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_wrapl(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_wrap(
    size_t len,
#ifdef __cplusplus
    double *const __restrict phase,
    double *__restrict output
#else
    double phase[const restrict static len],
    double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_wrap(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_wrapf(
    size_t len,
#ifdef __cplusplus
    float *const __restrict phase,
    float *__restrict output
#else
    float phase[const restrict static len],
    float output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_wrapf(phase[i]);
    }
}

[[nodiscard, gnu::const]]
static inline long double nec_analog_sawtoothl(long double phase) [[unsequenced]] {
    assume(0.l <= phase && phase < 1.l);
    return (-4.l * phase + 1.5l) / (phase + 1.5l);
}

[[nodiscard, gnu::const]]
static inline double nec_analog_sawtooth(double phase) [[unsequenced]] {
    assume(0.0 <= phase && phase < 1.0);
    return (-4.0 * phase + 1.5) / (phase + 1.5);
}

[[nodiscard, gnu::const]]
static inline float nec_analog_sawtoothf(float phase) [[unsequenced]] {
    assume(0.f <= phase && phase < 1.f);
    return (-4.f * phase + 1.5f) / (phase + 1.5f);
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_analog_sawtoothl(
    size_t len,
#ifdef __cplusplus
    long double *const __restrict phase,
    long double *__restrict output
#else
    long double phase[const restrict static len],
    long double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_analog_sawtoothl(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_analog_sawtooth(
    size_t len,
#ifdef __cplusplus
    double *const __restrict phase,
    double *__restrict output
#else
    double phase[const restrict static len],
    double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_analog_sawtooth(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_analog_sawtoothf(
    size_t len,
#ifdef __cplusplus
    float *const __restrict phase,
    float *__restrict output
#else
    float phase[const restrict static len],
    float output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_analog_sawtoothf(phase[i]);
    }
}

[[nodiscard, gnu::const]]
static inline long double nec_analog_squarel(long double phase, long double duty) [[unsequenced]] {
    assume(0.l <= phase && phase < 1.l);
    assume(0.l <= duty && duty <= 1.l);
    const auto amplitude = (-phase + 6.l) / (4.l * phase + 6.l);
    return copysignl(amplitude, duty - phase);
}

[[nodiscard, gnu::const]]
static inline double nec_analog_square(double phase, double duty) [[unsequenced]] {
    assume(0.0 <= phase && phase < 1.0);
    assume(0.0 <= duty && duty <= 1.0);
    const auto amplitude = (-phase + 6.0) / (4.0 * phase + 6.0);
    return copysign(amplitude, duty - phase);
}

[[nodiscard, gnu::const]]
static inline float nec_analog_squaref(float phase, float duty) [[unsequenced]] {
    assume(0.f <= phase && phase < 1.f);
    assume(0.f <= duty && duty <= 1.f);
    const auto amplitude = (-phase + 6.f) / (4.f * phase + 6.f);
    return copysignf(amplitude, duty - phase);
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_analog_squarel(
    size_t len,
#ifdef __cplusplus
    long double *const __restrict phase,
    long double *const __restrict duty,
    long double *__restrict output
#else
    long double phase[const restrict static len],
    long double duty[const restrict static len],
    long double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_analog_squarel(phase[i], duty[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_analog_square(
    size_t len,
#ifdef __cplusplus
    double *const __restrict phase,
    double *const __restrict duty,
    double *__restrict output
#else
    double phase[const restrict static len],
    double duty[const restrict static len],
    double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_analog_square(phase[i], duty[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_analog_squaref(
    size_t len,
#ifdef __cplusplus
    float *const __restrict phase,
    float *const __restrict duty,
    float *__restrict output
#else
    float phase[const restrict static len],
    float duty[const restrict static len],
    float output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_analog_squaref(phase[i], duty[i]);
    }
}

[[nodiscard, gnu::const]]
static inline long double nec_analog_trianglel(long double phase) [[unsequenced]] {
    assume(0.l <= phase && phase < 1.l);
    return 2.l * fabsl(nec_analog_sawtoothl(phase)) - 1.l;
}

[[nodiscard, gnu::const]]
static inline double nec_analog_triangle(double phase) [[unsequenced]] {
    assume(0.0 <= phase && phase < 1.0);
    return 2.0 * fabs(nec_analog_sawtooth(phase)) - 1.0;
}

[[nodiscard, gnu::const]]
static inline float nec_analog_trianglef(float phase) [[unsequenced]] {
    assume(0.f <= phase && phase < 1.f);
    return 2.f * fabsf(nec_analog_sawtoothf(phase)) - 1.f;
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_analog_trianglel(
    size_t len,
#ifdef __cplusplus
    long double *const __restrict phase,
    long double *__restrict output
#else
    long double phase[const restrict static len],
    long double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_analog_trianglel(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_analog_triangle(
    size_t len,
#ifdef __cplusplus
    double *const __restrict phase,
    double *__restrict output
#else
    double phase[const restrict static len],
    double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_analog_triangle(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_analog_trianglef(
    size_t len,
#ifdef __cplusplus
    float *const __restrict phase,
    float *__restrict output
#else
    float phase[const restrict static len],
    float output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_analog_trianglef(phase[i]);
    }
}

[[nodiscard, gnu::const]]
static inline long double nec_paraboll(long double phase) [[unsequenced]] {
    assume(0.l <= phase && phase < 1.l);
    const auto x = 4.l * phase - 2.l;
    return x * (fabsl(x) - 2.l);
}

[[nodiscard, gnu::const]]
static inline double nec_parabol(double phase) [[unsequenced]] {
    assume(0.0 <= phase && phase < 1.0);
    const auto x = 4.0 * phase - 2.0;
    return x * (fabs(x) - 2.0);
}

[[nodiscard, gnu::const]]
static inline float nec_parabolf(float phase) [[unsequenced]] {
    assume(0.f <= phase && phase < 1.f);
    const auto x = 4.f * phase - 2.f;
    return x * (fabsf(x) - 2.f);
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_paraboll(
    size_t len,
#ifdef __cplusplus
    long double *const __restrict phase,
    long double *__restrict output
#else
    long double phase[const restrict static len],
    long double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_paraboll(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_parabol(
    size_t len,
#ifdef __cplusplus
    double *const __restrict phase,
    double *__restrict output
#else
    double phase[const restrict static len],
    double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_parabol(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_parabolf(
    size_t len,
#ifdef __cplusplus
    float *const __restrict phase,
    float *__restrict output
#else
    float phase[const restrict static len],
    float output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_parabolf(phase[i]);
    }
}

[[nodiscard, gnu::const]]
static inline long double nec_sinl(long double phase) [[unsequenced]] {
    constexpr auto weight = (long double)(NECTARINE_SINE_ERR_CORRECTION_WEIGHT);
    const auto p = nec_paraboll(phase);
    return weight * p * (fabsl(p) - 1.l) + p;
}

[[nodiscard, gnu::const]]
static inline double nec_sin(double phase) [[unsequenced]] {
    constexpr auto weight = (double)(NECTARINE_SINE_ERR_CORRECTION_WEIGHT);
    const auto p = nec_parabol(phase);
    return weight * p * (fabs(p) - 1.0) + p;
}

[[nodiscard, gnu::const]]
static inline float nec_sinf(float phase) [[unsequenced]] {
    constexpr auto weight = (float)(NECTARINE_SINE_ERR_CORRECTION_WEIGHT);
    const auto p = nec_parabolf(phase);
    return weight * p * (fabsf(p) - 1.f) + p;
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_sinl(
    size_t len,
#ifdef __cplusplus
    long double *const __restrict phase,
    long double *__restrict output
#else
    long double phase[const restrict static len],
    long double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_sinl(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_sin(
    size_t len,
#ifdef __cplusplus
    double *const __restrict phase,
    double *__restrict output
#else
    double phase[const restrict static len],
    double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_sin(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_sinf(
    size_t len,
#ifdef __cplusplus
    float *const __restrict phase,
    float *__restrict output
#else
    float phase[const restrict static len],
    float output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_sinf(phase[i]);
    }
}

[[nodiscard, gnu::const]]
static inline long double nec_circlel(long double phase) [[unsequenced]] {
    const auto p = nec_paraboll(phase);
    return copysignl(sqrtl(fabsl(p)), p);
}

[[nodiscard, gnu::const]]
static inline double nec_circle(double phase) [[unsequenced]] {
    const auto p = nec_parabol(phase);
    return copysign(sqrt(fabs(p)), p);
}

[[nodiscard, gnu::const]]
static inline float nec_circlef(float phase) [[unsequenced]] {
    const auto p = nec_parabolf(phase);
    return copysignf(sqrtf(fabsf(p)), p);
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_circlel(
    size_t len,
#ifdef __cplusplus
    long double *const __restrict phase,
    long double *__restrict output
#else
    long double phase[const restrict static len],
    long double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_circlel(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_circle(
    size_t len,
#ifdef __cplusplus
    double *const __restrict phase,
    double *__restrict output
#else
    double phase[const restrict static len],
    double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_circle(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_circlef(
    size_t len,
#ifdef __cplusplus
    float *const __restrict phase,
    float *__restrict output
#else
    float phase[const restrict static len],
    float output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_circlef(phase[i]);
    }
}

[[nodiscard, gnu::const]]
static inline long double nec_sawtoothl(long double phase) [[unsequenced]] {
    assume(0.l <= phase && phase < 1.l);
    return -2.l * phase + 1.l;
}

[[nodiscard, gnu::const]]
static inline double nec_sawtooth(double phase) [[unsequenced]] {
    assume(0.0 <= phase && phase < 1.0);
    return -2.0 * phase + 1.0;
}

[[nodiscard, gnu::const]]
static inline float nec_sawtoothf(float phase) [[unsequenced]] {
    assume(0.f <= phase && phase < 1.f);
    return -2.f * phase + 1.f;
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_sawtoothl(
    size_t len,
#ifdef __cplusplus
    long double *const __restrict phase,
    long double *__restrict output
#else
    long double phase[const restrict static len],
    long double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_sawtoothl(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_sawtooth(
    size_t len,
#ifdef __cplusplus
    double *const __restrict phase,
    double *__restrict output
#else
    double phase[const restrict static len],
    double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_sawtooth(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_sawtoothf(
    size_t len,
#ifdef __cplusplus
    float *const __restrict phase,
    float *__restrict output
#else
    float phase[const restrict static len],
    float output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_sawtoothf(phase[i]);
    }
}

[[nodiscard, gnu::const]]
static inline long double nec_squarel(long double phase, long double duty) [[unsequenced]] {
    assume(0.l <= phase && phase < 1.l);
    assume(0.l <= duty && duty <= 1.l);
    return copysignl(1.l, duty - phase);
}

[[nodiscard, gnu::const]]
static inline double nec_square(double phase, double duty) [[unsequenced]] {
    assume(0.0 <= phase && phase < 1.0);
    assume(0.0 <= duty && duty <= 1.0);
    return copysign(1.0, duty - phase);
}

[[nodiscard, gnu::const]]
static inline float nec_squaref(float phase, float duty) [[unsequenced]] {
    assume(0.f <= phase && phase < 1.f);
    assume(0.f <= duty && duty <= 1.f);
    return copysignf(1.f, duty - phase);
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_squarel(
    size_t len,
#ifdef __cplusplus
    long double *const __restrict phase,
    long double *const __restrict duty,
    long double *__restrict output
#else
    long double phase[const restrict static len],
    long double duty[const restrict static len],
    long double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_squarel(phase[i], duty[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_square(
    size_t len,
#ifdef __cplusplus
    double *const __restrict phase,
    double *const __restrict duty,
    double *__restrict output
#else
    double phase[const restrict static len],
    double duty[const restrict static len],
    double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_square(phase[i], duty[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_squaref(
    size_t len,
#ifdef __cplusplus
    float *const __restrict phase,
    float *const __restrict duty,
    float *__restrict output
#else
    float phase[const restrict static len],
    float duty[const restrict static len],
    float output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_squaref(phase[i], duty[i]);
    }
}

[[nodiscard, gnu::const]]
static inline long double nec_trianglel(long double phase) [[unsequenced]] {
    assume(0.l <= phase && phase < 1.l);
    return 2.l * fabsl(nec_sawtoothl(phase)) - 1.l;
}

[[nodiscard, gnu::const]]
static inline double nec_triangle(double phase) [[unsequenced]] {
    assume(0.0 <= phase && phase < 1.0);
    return 2.0 * fabs(nec_sawtooth(phase)) - 1.0;
}

[[nodiscard, gnu::const]]
static inline float nec_trianglef(float phase) [[unsequenced]] {
    assume(0.f <= phase && phase < 1.f);
    return 2.f * fabsf(nec_sawtoothf(phase)) - 1.f;
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_trianglel(
    size_t len,
#ifdef __cplusplus
    long double *const __restrict phase,
    long double *__restrict output
#else
    long double phase[const restrict static len],
    long double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_trianglel(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_triangle(
    size_t len,
#ifdef __cplusplus
    double *const __restrict phase,
    double *__restrict output
#else
    double phase[const restrict static len],
    double output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_triangle(phase[i]);
    }
}

[[gnu::reproducible, gnu::nonnull]]
static inline void nec_fill_trianglef(
    size_t len,
#ifdef __cplusplus
    float *const __restrict phase,
    float *__restrict output
#else
    float phase[const restrict static len],
    float output[restrict static len]
#endif
) [[reproducible]] {
    assume(len > 0);
    #pragma omp simd
    for (size_t i = 0; i < len; ++i) {
        output[i] = nec_trianglef(phase[i]);
    }
}