ofxPDSPFunctions.h

#ifndef OFXPDSP_FUNCTIONS_INCLUDED
#define OFXPDSP_FUNCTIONS_INCLUDED

#include "../DSP/core/Preparable.h"
#include "../DSP/utility/PitchToFreq.h"
#include "../DSP/utility/DBtoLin.h"
#include "../math/random/random.h"



float dB ( float dBvalue );


namespace pdsp{

float panL ( float pan );

float panR ( float pan );

float f2p( float freq);


float pratio ( float pitch, float ratio );


int highestPartial( float pitch );


inline_f float urand( ){
    return randomUnipolarInclusive();
};

inline_f float brand(){
    return randomBipolar();
};

inline_f int dice(  int min, int maxExclusive  ){
    return (dice(maxExclusive-min) + min);
};


float spread(int index, int max, float spread, bool fromCenter = false);


float p2f( float pitch);

} // end namespace



class ofxPDSPFunctions{

    friend float pdsp::p2f( float pitch);
    friend float pdsp::pratio( float pitch, float ratio);
    friend int pdsp::highestPartial( float pitch );
    friend float pdsp::f2p( float freq );
    friend float panL ( float pan );
    friend float panR ( float pan );
    friend float dB ( float dBvalue );
    friend bool pdsp::chance( float chance );
    friend float pdsp::urand( );
    friend float pdsp::brand( );
    friend int pdsp::dice( int sides );    
    friend int pdsp::dice( int min, int maxExclusive );
    friend float pdsp::spread(int index, int max, float spread, bool fromCenter);
};


// ------------------------- OLD FUNCTIONS -----------------------------------

[[deprecated("pdspSpread deprecated, use pdsp::spread instead")]]
inline float pdspSpread(int index, int max, float spread, bool fromCenter = false){ 
    return pdsp::spread( index, max, spread, fromCenter );
}

[[deprecated("pdspChance deprecated, use pdsp::chance instead")]]
inline_f bool pdspChance( float value ){
    return pdsp::chance(value);
};

[[deprecated("pdspDice deprecated, use pdsp::dice instead")]]
inline_f int pdspDice( int sides ){
    return pdsp::dice(sides);
};

[[deprecated("pdspDice deprecated, use pdsp::dice instead")]]
inline_f int pdspDice(  int min, int maxExclusive  ){
    return (pdsp::dice(maxExclusive-min) + min);
};

[[deprecated("pdspURan deprecated, use pdsp::urand instead")]]
inline_f float pdspURan( ){
    return pdsp::randomUnipolarInclusive();
};

[[deprecated("pdspBRan deprecated, use pdsp::brand instead")]]
inline_f float pdspBRan(){
    return pdsp::randomBipolar();
};

#endif // OFXPDSP_FUNCTIONS_INCLUDED