mozzi_fixmath.h

/*
 * mozzi_fixmath.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 FIXEDMATH_H_
#define FIXEDMATH_H_
 
#include <Arduino.h>
 
// types
typedef int8_t Q0n7;                
typedef int8_t Q7n0;                
typedef uint8_t Q0n8;       
typedef uint8_t Q8n0;       
typedef uint16_t Q0n16;         
typedef uint32_t Q0n31;             
typedef int16_t Q7n8;               
typedef uint16_t Q3n13; 
typedef int16_t Q1n14;              
typedef int16_t Q15n0;              
typedef uint16_t Q8n8;      
typedef int16_t  Q0n15;             
typedef uint16_t     Q1n15; 
typedef uint16_t     Q16n0; 
typedef int32_t Q23n8;              
typedef int32_t Q15n16;         
typedef int32_t Q31n0;              
typedef uint32_t Q32n0;     
typedef uint32_t    Q0n32;      
typedef uint32_t    Q8n24;      
typedef uint32_t Q24n8;     
typedef uint32_t Q16n16;    
// macros to save runtime calculations for representations of 1
#define Q0n7_FIX1 ((Q0n7) 127)          
#define Q7n8_FIX1 ((Q7n8) 256)          
#define Q8n8_FIX1 ((Q8n8) 256)          
#define Q23n8_FIX1 ((Q23n8) 256)            
#define Q1n14_FIX1 ((Q1n14) 16384)      
#define Q1n15_FIX1 ((Q1n15) 32768)      
#define Q16n16_FIX1 ((Q16n16) 65536)        
#define Q0n15_FIX1 ((Q0n15) 32767)      
#define Q0n16_FIX1 ((Q0n16) 65535)      
#define Q15n0_FIX1  ((Q15n0) 16384)     
#define Q15n16_FIX1 ((Q15n16) 65536)        
#define Q8n24_FIX1 ((Q8n24) 16777216)   
#define Q0n32_FIX1 ((Q0n32) 4294967295) 
#define Q16n16_PI ((Q16n16) 205887)     
#define Q3n13_2PI ((Q3n13) 411775)      
#define Q16n16_2PI ((Q16n16) 411775)        
#define low15bits ((Q1n15) 32767) 
/*
Type conversions: Float to Q
 
To convert a number from floating point to Qm.n format:
 
  Multiply the floating point number by 2^n
  Round to the nearest integer
 
Q to float
 
To convert a number from Qm.n format to floating point:
 
  Convert the number to floating point as if it were an integer
  Multiply by 2^-n
*/
inline
Q0n7 float_to_Q0n7(float a) { return static_cast<Q0n7>(a*256); }        
inline
Q0n8 float_to_Q0n8(float a) { return static_cast<Q0n8>(a*256); }        
inline
Q7n8 float_to_Q7n8(float a) { return static_cast<Q7n8>(a*256); }        
inline
Q8n8 float_to_Q8n8(float a) { return static_cast<Q8n8>(a*256); }        
inline
Q1n14 float_to_Q1n14(float a) { return static_cast<Q1n14>(a*16384); }   
inline
Q1n15 float_to_Q1n15(float a) { return static_cast<Q1n15>(a*32768); }   
inline
Q8n24 float_to_Q8n24(float a) { return static_cast<Q8n24>(a*16777216); }    
inline
Q23n8 float_to_Q23n8(float a) { return static_cast<Q23n8>(a*256); }     
inline
Q24n8 float_to_Q24n8(float a) { return static_cast<Q24n8>(a*256); }     
inline
Q16n16 float_to_Q16n16(float a) { return static_cast<Q16n16>(a*65536); }    
inline
Q0n16 float_to_Q0n16(float a) { return static_cast<Q0n16>(a*65536); }   
inline
Q15n16 float_to_Q15n16(float a) { return static_cast<Q15n16>(a*65536); }    
inline
Q1n14 Q0n7_to_Q1n14(Q0n7 a) { return (static_cast<Q1n14>(a))<<7; }      
inline
Q15n16 Q0n7_to_Q15n16(Q0n7 a) { return (static_cast<Q15n16>(a))<<8; }       
inline
float Q0n7_to_float(Q0n7 a) { return (static_cast<float>(a))/256; }     
inline
Q1n15 Q0n8_to_Q1n15(Q0n8 a) { return (static_cast<Q1n15>(a))<<7; }          
inline
Q8n8 Q0n8_to_Q8n8(Q0n8 a) { return (static_cast<Q8n8>(a))<<8; }         
inline
Q8n24 Q0n8_to_Q8n24(Q0n8 a) { return (static_cast<Q8n24>(a))<<16; }     
inline
Q24n8 Q0n8_to_Q24n8(Q0n8 a) { return (static_cast<Q24n8>(a))<<8; }              
inline
Q15n16 Q0n8_to_Q15n16(Q0n8 a) { return (static_cast<Q15n16>(a))<<8; }   
inline
Q16n16 Q0n8_to_Q16n16(Q0n8 a) { return (static_cast<Q16n16>(a))<<8; }       
inline
float Q0n8_to_float(Q0n8 a) { return (static_cast<float>(a))/256; } 
inline
Q7n8 Q7n0_to_Q7n8(Q7n0 a) { return (static_cast<Q7n8>(a))<<8; }         
inline
Q15n16 Q7n0_to_Q15n16(Q7n0 a) { return (static_cast<Q15n16>(a))<<16; }          
inline
Q7n8 Q8n0_to_Q7n8(Q8n0 a) { return (static_cast<Q7n8>(a))<<8; }     
inline
Q8n8 Q8n0_to_Q8n8(Q8n0 a) { return (static_cast<Q8n8>(a))<<8; }         
inline
Q15n16 Q8n0_to_Q15n16(Q8n0 a) { return (static_cast<Q15n16>(a))<<16; }          
inline
Q16n16 Q8n0_to_Q16n16(Q8n0 a) { return (static_cast<Q16n16>(a))<<16; }          
inline
Q7n0 Q7n8_to_Q7n0(Q7n8 a) { return static_cast<Q7n0>((Q7n8)a>>8); }         
inline
Q15n16 Q7n8_to_Q15n16(Q7n8 a) { return (static_cast<Q15n16>(a))<<8; }           
inline
float Q7n8_to_float(Q7n8 a) { return (static_cast<float>(a))/256; }         
inline
Q8n0 Q8n8_to_Q8n0(Q8n8 a) { return static_cast<Q8n0>((Q8n8)a>>8); }         
inline
Q16n16 Q8n8_to_Q16n16(Q8n8 a) { return (static_cast<Q16n16>(a))<<8; }           
inline
float Q8n8_to_float(Q8n8 a) { return (static_cast<float>(a))/256; }             
inline
Q0n7 Q1n14_to_Q0n7(Q1n14 a) { return static_cast<Q0n7>((Q1n14)a>>7); }          
inline
float Q1n14_to_float(Q1n14 a) { return (static_cast<float>(a))/16384; }         
inline
Q0n8 Q1n15_to_Q0n8(Q1n15 a) { return static_cast<Q0n8>((Q1n15)a>>7); }          
inline
float Q1n15_to_float(Q1n15 a) { return (static_cast<float>(a))/32768; }         
inline
float Q0n16_to_float(Q0n16 a) { return (static_cast<float>(a))/65536; }         
inline
Q15n16 Q15n0_to_Q15n16(Q15n0 a) { return (static_cast<Q15n16>(a))<<16; }        
inline
Q15n16 Q16n0_to_Q15n16(Q16n0 a) { return (static_cast<Q15n16>(a))<<16; }            
inline
Q23n8 Q16n0_to_Q23n8(Q16n0 a) { return (static_cast<Q23n8>(a))<<8; }            
inline
Q24n8 Q16n0_to_Q24n8(Q16n0 a) { return (static_cast<Q24n8>(a))<<8; }        
inline
Q16n16 Q16n0_to_Q16n16(Q16n0 a) { return (static_cast<Q16n16>(a))<<16; }            
inline
float Q16n0_to_float(Q16n0 a) { return (static_cast<float>(a)); }                   
inline
Q0n8 Q8n24_to_Q0n8(Q8n24 a) { return static_cast<Q0n8>((Q8n24)a>>16); }     
inline
float Q8n24_to_float(Q8n24 a) { return (static_cast<float>(a))/16777216; }      
inline
Q31n0 Q23n8_to_Q31n0(Q23n8 a) { return static_cast<Q31n0>((Q23n8)a>>8); }       
inline
Q16n0 Q23n8_to_Q16n0(Q23n8 a) { return static_cast<Q16n0>((Q23n8)a>>8); }       
inline
Q15n0 Q23n8_to_Q15n0(Q23n8 a) { return static_cast<Q15n0>((Q23n8)a>>8); }       
inline
Q7n8 Q23n8_to_Q7n8(Q23n8 a) { return static_cast<Q7n8>(a); }                
inline
float Q23n8_to_float(Q23n8 a) { return (static_cast<float>(a))/256; }           
inline
Q0n8 Q24n8_to_Q0n8(Q24n8 a) { return static_cast<Q0n8>(a); }            
inline
Q16n16 Q24n8_to_Q16n0(Q24n8 a) { return (static_cast<Q16n0>((Q24n8)a))>>8; }            
inline
Q32n0 Q24n8_to_Q32n0(Q24n8 a) { return static_cast<Q32n0>((Q24n8)a>>8); }       
inline
Q16n16 Q24n8_to_Q16n16(Q24n8 a) { return (static_cast<Q16n16>(a))<<8; }         
inline
float Q24n8_to_float(Q24n8 a) { return (static_cast<float>(a))/256; }               
inline
Q0n8 Q15n16_to_Q0n8(Q15n16 a) { return static_cast<Q0n8>((Q15n16)a>>8); }           
inline
Q8n0 Q15n16_to_Q8n0(Q15n16 a) { return static_cast<Q8n0>((Q15n16)a>>16); }          
inline
Q15n0 Q15n16_to_Q15n0(Q15n16 a) { return static_cast<Q15n0>((Q15n16)a>>16); }       
inline
Q7n8 Q15n16_to_Q7n8(Q15n16 a) { return static_cast<Q7n8>((Q15n16)a>>8); }           
inline
Q8n8 Q15n16_to_Q8n8(Q15n16 a) { return static_cast<Q8n8>((Q15n16)a>>8); }           
inline
Q23n8 Q15n16_to_Q23n8(Q15n16 a) { return static_cast<Q23n8>((Q15n16)a>>8); }            
inline
float Q15n16_to_float(Q15n16 a) { return (static_cast<float>(a))/65536; }           
inline
Q0n8 Q16n16_to_Q0n8(Q16n16 a) { return static_cast<Q0n8>((Q16n16)a>>8); }           
inline
Q8n8 Q16n16_to_Q8n8(Q8n8 a) { return static_cast<Q8n8>((Q16n16)a>>16); }        
inline
Q16n0 Q16n16_to_Q16n0(Q16n16 a) { return static_cast<Q16n0>((Q16n16)a>>16); }       
inline
Q24n8 Q16n16_to_Q24n8(Q16n16 a) { return static_cast<Q24n8>((Q16n16)a>>8); }        
inline
float Q16n16_to_float(Q16n16 a) { return (static_cast<float>(a))/65536; }       
/* @ingroup fixmath
Fast (?) fixed point multiply for Q7n8 fractional numbers.
The c  version below is 3 times faster, and not subject to the same overflow limitations (+-3.99, or +-2048)
@param a Q7n8 format multiplicand
@param b Q7n8 format multiplier
@return a Q7n8 format product
*/
/*
#define Q7n8_mult(a,b)        \
({            \
int16_t prod, val1=a, val2=b ;    \
__asm__ __volatile__ (    \
    "muls %B1, %B2  \n\t"   \
    "mov %B0, r0 \n\t"     \
    "mul %A1, %A2\n\t"     \
    "mov %A0, r1 \n\t"   \
    "mulsu %B1, %A2 \n\t"   \
    "add %A0, r0  \n\t"     \
    "adc %B0, r1 \n\t"     \
    "mulsu %B2, %A1 \n\t"   \
    "add %A0, r0 \n\t"     \
    "adc %B0, r1  \n\t"    \
    "clr r1  \n\t"         \
    : "=&d" (prod)     \
    : "a" (val1), "a" (val2)  \
      );            \
  prod;         \
})
*/
 
inline
Q7n8 Q7n8_mult(Q7n8 a, Q7n8 b) {
  return ((int16_t)((((int32_t)(a))*(b))>>8));
}
 
 
/*
#define FMULS8(v1, v2)      \
({            \
  uint8_t res;        \
  uint8_t val1 = v1;      \
  uint8_t val2 = v2;      \
  __asm__ __volatile__      \
  (           \
    "fmuls $1, $2"   "\n\t" \
    "mov $0, r1"     "\n\t" \
    "clr r1"     "\n\t" \
    : "=&d" (res)       \
    : "a" (val1), "a" (val2)  \
  );            \
  res;          \
}) */
 
 
/*
// from octosynth, Joe Marshall 2011:
 
  // multiply 2 16 bit numbers together and shift 8 without precision loss
  // requires assembler really
  volatile uint8_t zeroReg=0;
  volatile uint16_t multipliedCounter=oscillators[c].phaseStep;
  asm volatile
  (
  // high uint8_ts mult together = high  uint8_t
  "ldi %A[outVal],0" "\n\t"
  "mul %B[phaseStep],%B[pitchB}]" "\n\t"
  "mov %B[outVal],r0" "\n\t"
  // ignore overflow into r1 (should never overflow)
  // low uint8_t * high uint8_t -> both uint8_ts
  "mul %A[phaseStep],%B[pitchB}]" "\n\t"
  "add %A[outVal],r0" "\n\t"
  // carry into high uint8_t
  "adc %B[outVal],r1" "\n\t"
  // high uint8_t* low uint8_t -> both uint8_ts
  "mul %B[phaseStep],%A[pitchB}]" "\n\t"
  "add %A[outVal],r0" "\n\t"
  // carry into high uint8_t
  "adc %B[outVal],r1" "\n\t"
  // low uint8_t * low uint8_t -> round
  "mul %A[phaseStep],%A[pitchB}]" "\n\t"
  // the adc below is to round up based on high bit of low*low:
  "adc %A[outVal],r1" "\n\t"
  "adc %B[outVal],%[ZERO]" "\n\t"
  "clr r1" "\n\t"
  :[outVal] "=&d" (multipliedCounter)
  :[phaseStep] "d" (oscillators[c].phaseStep),[pitchB}] "d"( pitchB}Multiplier),[ZERO] "d" (zeroReg)
  :"r1","r0"
  );
  oscillators[c].phaseStep=multipliedCounter;
 
  */
 
 
 
int16_t ipow(int16_t base, int16_t exp); 
Q16n16 Q16n16_pow2(Q8n8 exponent);
 
uint8_t uint8_tMod(uint8_t n, uint8_t d);
uint8_t uint8_tDiv(uint8_t n, uint8_t d);
uint8_t uint8_tRnd(uint8_t min, uint8_t max);
uint16_t isqrt16(uint16_t n);
uint32_t isqrt32(uint32_t n);
 
#endif /* FIXEDMATH_H_ */