Smooth.h

/*
 * Smooth.h
 *
 * This file is part of Mozzi.
 *
 * Copyright 2012-2024 Tim Barrass and the Mozzi Team
 *
 * Mozzi is licensed under the GNU Lesser General Public Licence (LGPL) Version 2.1 or later.
 *
 */
 
#ifndef SMOOTH_H_
#define SMOOTH_H_
 
#include "Arduino.h"
#include "mozzi_fixmath.h"
 
template <class T>
class Smooth
{
private:
    long last_out;
    Q0n16 a;
 
public:
    Smooth(float smoothness)
    {
        setSmoothness(smoothness);
    }
 
    Smooth()
    {}
 
 
    inline
    T next(T in)
    {
        long out = ((((((long)in - (last_out>>8)) * a))>>8) + last_out);
        last_out = out;
        return (T)(out>>8);
    }
 
 
    inline
    T operator()(T n) {
        return next(n);
    }
 
 
    inline
    void setSmoothness(float smoothness)
    {
        a=float_to_Q0n16(1.f-smoothness);
    }
 
};
 
 // doxygen can ignore the specialisations
 
template <>
class Smooth <uint8_t>
{
private:
    unsigned int last_out;
    Q0n8 a;
 
public:
    Smooth(float smoothness)
    {
        setSmoothness(smoothness);
    }
 
    inline
    uint8_t next(uint8_t in)
    {
        unsigned int out = (((((int)in - (last_out>>8)) * a)) + last_out);
        last_out = out;
        return (uint8_t)(out>>8);
    }
 
 
    inline
    uint8_t  operator()(uint8_t  n) {
        return next(n);
    }
 
 
    inline
    void setSmoothness(float smoothness)
    {
        a=float_to_Q0n8(1.f-smoothness);
    }
 
};
 
 
template <>
class Smooth <int8_t>
{
private:
    int last_out;
    Q0n8 a;
 
public:
    Smooth(float smoothness)
    {
        setSmoothness(smoothness);
    }
 
 
    inline
    int8_t next(int8_t in)
    {
        int out = (((((int)in - (last_out>>8)) * a)) + last_out);
        last_out = out;
        return (int8_t)(out>>8);
    }
 
 
    inline
    int8_t operator()(int8_t n) {
        return next(n);
    }
 
 
    inline
    void setSmoothness(float smoothness)
    {
        a=float_to_Q0n8(1.f-smoothness);
    }
 
};
 
template <>
class Smooth <float>
{
private:
    float last_out;
    float a;
 
public:
    Smooth(float smoothness)
    {
        setSmoothness(smoothness);
    }
 
    inline
    float next(float in)
    {
        float out = last_out + a * (in - last_out);
        //float out = (in - last_out * a) + last_out;
        last_out = out;
        return out;
    }
 
 
    inline
    float operator()(float n) {
        return next(n);
    }
 
 
    inline
    void setSmoothness(float smoothness)
    {
        a=1.f-smoothness;
    }
 
};
 
 
/* Specialization for UFix */
template<int8_t NI, int8_t NF>
class Smooth<UFix<NI,NF>>
{
private:
  typedef UFix<NI, NF> internal_type;
  internal_type last_out;
  UFix<0,16> a;
 
public:
 
 
  template<typename T>
  Smooth(T smoothness)
  {
    setSmoothness(smoothness);
  }
 
  Smooth()
  {}
 
 
  inline
  internal_type next(internal_type in)
  {
    internal_type out = last_out + a * (in - last_out);  // With FixMath, the syntax is actually the same than with floats :)
    last_out = out;
    return out;
  }
 
  
 
  inline
  internal_type operator()(internal_type n) {
    return next(n);
  }
 
  inline
  void setSmoothness(float smoothness)
  {
    a=internal_type(1.f-smoothness);
  }
 
  template<int8_t _NF>
  void setSmoothness(UFix<0,_NF> smoothness)
  {
    a = UFix<1,0>(1) - smoothness;
  }  
 
};
 
 
 
 
/* Specialization for SFix */
template<int8_t NI, int8_t NF>
class Smooth<SFix<NI,NF>>
{
private:
  typedef SFix<NI, NF> internal_type;
  internal_type last_out;
  UFix<0,16> a;
 
public:
 
 
  template<typename T>
  Smooth(T smoothness)
  {
    setSmoothness(smoothness);
  }
 
  Smooth()
  {}
 
 
  inline
  internal_type next(internal_type in)
  {
    internal_type out = last_out + a * (in - last_out);
    last_out = out;
    return out;
  }
 
  
 
  inline
  internal_type operator()(internal_type n) {
    return next(n);
  }
 
  inline
  void setSmoothness(float smoothness)
  {
    a=internal_type(1.f-smoothness);
  }
 
  template<int8_t _NF>
  void setSmoothness(UFix<0,_NF> smoothness)
  {
    a = UFix<1,0>(1) - smoothness;
  }  
 
};
 
#endif /* SMOOTH_H_ */