waveforms.h

Go to the documentation of this file.

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

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

[[nodiscard, gnu::const]]
inline long double nec_wrapl(long double phase) [[unsequenced]] {
    return phase - floorl(phase);
}

[[nodiscard, gnu::const]]
inline double nec_wrap(double phase) [[unsequenced]] {
    return phase - floor(phase);
}

[[nodiscard, gnu::const]]
inline float nec_wrapf(float phase) [[unsequenced]] {
    return phase - floorf(phase);
}

[[gnu::reproducible, gnu::nonnull]]
inline void nec_fill_wrapl(
    size_t len,
#ifdef __cplusplus
    const long double *__restrict phase,
    long double *__restrict output
#else
    const long double phase[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]]
inline void nec_fill_wrap(
    size_t len,
#ifdef __cplusplus
    const double *__restrict phase,
    double *__restrict output
#else
    const double phase[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]]
inline void nec_fill_wrapf(
    size_t len,
#ifdef __cplusplus
    const float *__restrict phase,
    float *__restrict output
#else
    const float phase[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]]
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]]
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]]
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]]
inline void nec_fill_analog_sawtoothl(
    size_t len,
#ifdef __cplusplus
    const long double *__restrict phase,
    long double *__restrict output
#else
    const long double phase[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]]
inline void nec_fill_analog_sawtooth(
    size_t len,
#ifdef __cplusplus
    const double *__restrict phase,
    double *__restrict output
#else
    const double phase[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]]
inline void nec_fill_analog_sawtoothf(
    size_t len,
#ifdef __cplusplus
    const float *__restrict phase,
    float *__restrict output
#else
    const float phase[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]]
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]]
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]]
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]]
inline void nec_fill_analog_squarel(
    size_t len,
#ifdef __cplusplus
    const long double *__restrict phase,
    const long double *__restrict duty,
    long double *__restrict output
#else
    const long double phase[restrict static len],
    const long double duty[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]]
inline void nec_fill_analog_square(
    size_t len,
#ifdef __cplusplus
    const double *__restrict phase,
    const double *__restrict duty,
    double *__restrict output
#else
    const double phase[restrict static len],
    const double duty[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]]
inline void nec_fill_analog_squaref(
    size_t len,
#ifdef __cplusplus
    const float *__restrict phase,
    const float *__restrict duty,
    float *__restrict output
#else
    const float phase[restrict static len],
    const float duty[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]]
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]]
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]]
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]]
inline void nec_fill_analog_trianglel(
    size_t len,
#ifdef __cplusplus
    const long double *__restrict phase,
    long double *__restrict output
#else
    const long double phase[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]]
inline void nec_fill_analog_triangle(
    size_t len,
#ifdef __cplusplus
    const double *__restrict phase,
    double *__restrict output
#else
    const double phase[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]]
inline void nec_fill_analog_trianglef(
    size_t len,
#ifdef __cplusplus
    const float *__restrict phase,
    float *__restrict output
#else
    const float phase[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]]
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]]
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]]
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]]
inline void nec_fill_paraboll(
    size_t len,
#ifdef __cplusplus
    const long double *__restrict phase,
    long double *__restrict output
#else
    const long double phase[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]]
inline void nec_fill_parabol(
    size_t len,
#ifdef __cplusplus
    const double *__restrict phase,
    double *__restrict output
#else
    const double phase[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]]
inline void nec_fill_parabolf(
    size_t len,
#ifdef __cplusplus
    const float *__restrict phase,
    float *__restrict output
#else
    const float phase[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]]
inline long double nec_sinl(long double phase) [[unsequenced]] {
    const auto p = nec_paraboll(phase);
    return 0.225l * p * (fabsl(p) - 1.l) + p;
}

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

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

[[gnu::reproducible, gnu::nonnull]]
inline void nec_fill_sinl(
    size_t len,
#ifdef __cplusplus
    const long double *__restrict phase,
    long double *__restrict output
#else
    const long double phase[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]]
inline void nec_fill_sin(
    size_t len,
#ifdef __cplusplus
    const double *__restrict phase,
    double *__restrict output
#else
    const double phase[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]]
inline void nec_fill_sinf(
    size_t len,
#ifdef __cplusplus
    const float *__restrict phase,
    float *__restrict output
#else
    const float phase[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]]
inline long double nec_circlel(long double phase) [[unsequenced]] {
    const auto p = nec_paraboll(phase);
    return copysignl(sqrtl(fabsl(p)), p);
}

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

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

[[gnu::reproducible, gnu::nonnull]]
inline void nec_fill_circlel(
    size_t len,
#ifdef __cplusplus
    const long double *__restrict phase,
    long double *__restrict output
#else
    const long double phase[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]]
inline void nec_fill_circle(
    size_t len,
#ifdef __cplusplus
    const double *__restrict phase,
    double *__restrict output
#else
    const double phase[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]]
inline void nec_fill_circlef(
    size_t len,
#ifdef __cplusplus
    const float *__restrict phase,
    float *__restrict output
#else
    const float phase[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]]
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]]
inline double nec_sawtooth(double phase) [[unsequenced]] {
    assume(0.0 <= phase && phase < 1.0);
    return -2.0 * phase + 1.0;
}

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

[[gnu::reproducible, gnu::nonnull]]
inline void nec_fill_sawtoothl(
    size_t len,
#ifdef __cplusplus
    const long double *__restrict phase,
    long double *__restrict output
#else
    const long double phase[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]]
inline void nec_fill_sawtooth(
    size_t len,
#ifdef __cplusplus
    const double *__restrict phase,
    double *__restrict output
#else
    const double phase[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]]
inline void nec_fill_sawtoothf(
    size_t len,
#ifdef __cplusplus
    const float *__restrict phase,
    float *__restrict output
#else
    const float phase[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]]
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]]
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]]
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]]
inline void nec_fill_squarel(
    size_t len,
#ifdef __cplusplus
    const long double *__restrict phase,
    const long double *__restrict duty,
    long double *__restrict output
#else
    const long double phase[restrict static len],
    const long double duty[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]]
inline void nec_fill_square(
    size_t len,
#ifdef __cplusplus
    const double *__restrict phase,
    const double *__restrict duty,
    double *__restrict output
#else
    const double phase[restrict static len],
    const double duty[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]]
inline void nec_fill_squaref(
    size_t len,
#ifdef __cplusplus
    const float *__restrict phase,
    const float *__restrict duty,
    float *__restrict output
#else
    const float phase[restrict static len],
    const float duty[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]]
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]]
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]]
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]]
inline void nec_fill_trianglel(
    size_t len,
#ifdef __cplusplus
    const long double *__restrict phase,
    long double *__restrict output
#else
    const long double phase[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]]
inline void nec_fill_triangle(
    size_t len,
#ifdef __cplusplus
    const double *__restrict phase,
    double *__restrict output
#else
    const double phase[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]]
inline void nec_fill_trianglef(
    size_t len,
#ifdef __cplusplus
    const float *__restrict phase,
    float *__restrict output
#else
    const float phase[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]);
    }
}