Line.h

/*
 * Line.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 LINE_H_
#define LINE_H_
 
#include <Arduino.h>
 
#include<FixMath.h>
 
template <class T>
class Line
{
private:
    T current_value;
    T step_size;
 
public:
    Line ()
    {
        ;
    }
 
    
        
    inline
    T next()
    {
        current_value += step_size;
        //Serial.println(current_value);
        return current_value;
    }
 
 
 
    inline
    void set(T value)
    {
        current_value=value;
    }
 
 
 
    inline
      void set(T targetvalue, T num_steps)
    {
      if(num_steps) {
        T numerator = targetvalue-current_value;
        step_size= numerator/num_steps;
      } else {
        step_size = 0;
        current_value = targetvalue;
      }
    }
 
    inline
    void set(T startvalue, T targetvalue, T num_steps)
    {
        set(startvalue);
        set(targetvalue, num_steps);
    }
};
 
 
/* unsigned char specialisation (probably not very useful because step size will likely = 0) */
template <>
class Line <unsigned char>
{
private:
    unsigned char current_value;
    char step_size;
 
public:
    Line ()
    {
        ;
    }
 
    
        
    inline
    unsigned char next()
    {
        current_value += step_size;
        return current_value;
    }
 
 
 
    inline
    void set(unsigned char value)
    {
        current_value=value;
    }
 
 
 
    inline
    void set(unsigned char targetvalue, unsigned char num_steps)
    {
        step_size=(char)((((float)targetvalue-current_value)/num_steps));
    }
 
    inline
    void set(unsigned char startvalue, unsigned char targetvalue, unsigned char num_steps)
    {
        set(startvalue);
        set(targetvalue, num_steps);
    }
    
};
    
    
/* unsigned int specialisation */
template <>
class Line <unsigned int>
{
private:
    unsigned int current_value;
    int step_size;
 
public:
    Line ()
    {
        ;
    }
 
    
        
    inline
    unsigned int next()
    {
        current_value += step_size;
        return current_value;
    }
 
 
 
    inline
    void set(unsigned int value)
    {
        current_value=value;
    }
 
 
 
    inline
    void set(unsigned int targetvalue, unsigned int num_steps)
    {
        step_size=(int)((((float)targetvalue-current_value)/num_steps));
    }
 
    
    inline
    void set(unsigned int startvalue, unsigned int targetvalue, unsigned int num_steps)
    {
        set(startvalue);
        set(targetvalue, num_steps);
    }
};
 
 
 
 
 
/* unsigned long specialisation */
template <>
class Line <unsigned long>
{
private:
    unsigned long current_value;
    long step_size;
 
public:
    Line ()
    {
        ;
    }
 
    
        
    inline
    unsigned long next()
    {
        current_value += step_size;
        return current_value;
    }
 
 
 
    inline
    void set(unsigned long value)
    {
        current_value=value;
    }
 
 
 
    inline
    void set(unsigned long targetvalue, unsigned long num_steps)
    {
        step_size=(long)((((float)targetvalue-current_value)/num_steps));
    }
 
    inline
    void set(unsigned long startvalue, unsigned long targetvalue, unsigned long num_steps)
    {
        set(startvalue);
        set(targetvalue, num_steps);
    }
};
 
 
/* UFix specialisation */
template<int8_t NI, int8_t NF>
class Line<UFix<NI, NF>>
{
private:
  typedef UFix<NI, NF> internal_type;
  internal_type current_value;
  SFix<NI,NF> step_size;
 
public:
  Line (){;}
 
  inline
  internal_type next()
  {
    current_value = current_value + step_size;
    return current_value;
  }
 
  inline
  void set(internal_type value)
  {
    current_value=value;
  }
 
  template<int8_t _NI>
  void set(internal_type targetvalue, UFix<_NI,0> num_steps)
  {
    if(num_steps.asRaw()) {
      auto numerator = targetvalue-current_value;
      step_size = numerator*num_steps.invAccurate();
    } else {
      step_size = 0;
      current_value = targetvalue;
    }
  }
 
 
  template<typename T>
  void set(internal_type targetvalue, T num_steps)
  {
    if(num_steps) {
      auto numerator = targetvalue-current_value;
      step_size = internal_type(numerator.asRaw()/num_steps,true);
    } else {
      step_size = 0;
      current_value = targetvalue;
    }
  }
 
  template<typename T>
  void set(internal_type startvalue, internal_type targetvalue, T num_steps)
  {
    set(startvalue);
    set(targetvalue, num_steps);
  }  
};
 
 
/* SFix specialisation (if someone has an idea to avoid duplication with UFix) */
template<int8_t NI, int8_t NF>
class Line<SFix<NI, NF>>
{
private:
  typedef SFix<NI, NF> internal_type;
  internal_type current_value;
  SFix<NI+1, NF> step_size;
 
public:
  Line (){;}
 
  inline
  internal_type next()
  {
    current_value = current_value + step_size;
    return current_value;
  }
 
  inline
  void set(internal_type value)
  {
    current_value=value;
  }
 
  template<int8_t _NI>
  void set(internal_type targetvalue, UFix<_NI,0> num_steps)
  {
    if(num_steps.asRaw()) {
      auto numerator = targetvalue-current_value;
      step_size = numerator*num_steps.invAccurate();
    } else {
      step_size = 0;
      current_value = targetvalue;
    }
  }
 
 
  template<typename T>
  void set(internal_type targetvalue, T num_steps)
  {
    if(num_steps) {
      auto numerator = targetvalue-current_value;
      step_size = internal_type(numerator.asRaw()/num_steps,true);
    } else {
      step_size = 0;
      current_value = targetvalue;
    }
  }
 
  template<typename T>
  void set(internal_type startvalue, internal_type targetvalue, T num_steps)
  {
    set(startvalue);
    set(targetvalue, num_steps);
  }  
};
 
 
 
#endif /* LINE_H_ */