void GSurface::regeneratePath(int ns, int nt){
updateCoords();
calculateCoefficients();
double delta_s = 1.0 / (ns - 1);
double delta_t = 1.0 / (nt - 1);
createDeltaMatrices(delta_s, delta_t);
createForwardDiffMatrices();
_curves.clear();
for (int i = 0; i < ns; i++) {
makeCurve(nt,
_DDx[0][0], _DDx[0][1], _DDx[0][2], _DDx[0][3],
_DDy[0][0], _DDy[0][1], _DDy[0][2], _DDy[0][3],
_DDz[0][0], _DDz[0][1], _DDz[0][2], _DDz[0][3] );
UpdateForwardDiffMatrices();
}
createForwardDiffMatrices();
_DDx = Transformation(_DDx).transpose().m();
_DDy = Transformation(_DDy).transpose().m();
_DDz = Transformation(_DDz).transpose().m();
for (int i = 0; i < nt; i++) {
makeCurve(ns,
_DDx[0][0], _DDx[0][1], _DDx[0][2], _DDx[0][3],
_DDy[0][0], _DDy[0][1], _DDy[0][2], _DDy[0][3],
_DDz[0][0], _DDz[0][1], _DDz[0][2], _DDz[0][3] );
UpdateForwardDiffMatrices();
}
}
float Filter::process(float in)
{
//TODO: add a flag to calculate coefficients here instead of calculating them at every param change
common::add_dc(in);
if (m_mode == k_filter_off)
return in;
//"clamping" with tanh
/*#if defined(WIN32)
in = tanhf(in);
#else
in = dnload_tanhf(in);
#endif*/
//svf process implementation
--m_calc_interval;
if (m_calc_coefficients)
if (m_calc_interval < 0)
{
calculateCoefficients();
m_calc_interval = STATE_CALC_INTERVAL;
}
float yL, yB, yH;
getOutputs(in, yL, yB, yH);
#if defined(APPROXIMATE_TANH)
return m_output_level * common::rational_tanh((m_c_low * yL + m_c_band * yB + m_c_high * yH)*(1.0f + (3.0f*m_drive)));
#else
#if defined(WIN32)
return m_output_level * tanhf((m_c_low * yL + m_c_band * yB + m_c_high * yH)*(1.0f+(3.0f*m_drive)));
#else
return m_output_level * dnload_tanhf((m_c_low * yL + m_c_band * yB + m_c_high * yH)*(1.0f + (3.0f*m_drive)));
#endif
#endif
}
TTErr TTSvf::setResonance(const TTValue& newValue)
{
mResonance = newValue;
mR = mResonance * 0.1;
calculateCoefficients();
return kTTErrNone;
}
Filter::Filter(void)
{
m_resonance = ONE_OVER_SQRT2;
m_r2 = 1/m_resonance;
m_h = 0.5f;
m_c_low=m_c_band=m_c_high=0.0f;
#ifdef VSTI
m_samplerate = SAMPLERATE;
#endif
m_base_freq=0.0f;
m_mod=0.0f;
m_staticmod=0.0f;
m_bandwidth=2.0f;
setMode(0.0f);
setCutoff(0.5f);
setMod(0.0f,0.0f);
setBandwidth(2.0f);
setDrive(0.0f);
m_staticmod = 0.0f;
setOutputLevel(1.0f);
m_cutoff = 0.0f;
calculateCoefficients();
m_calc_coefficients = false;
m_calc_interval = STATE_CALC_INTERVAL;
reset();
}
TTErr TTHighpassButterworth1::setFrequency(const TTValue& newValue)
{
mFrequency = newValue;
mRadians = kTTTwoPi*mFrequency;
mK = mRadians/tan(kTTPi*mFrequency/sr);
calculateCoefficients();
return kTTErrNone;
}
TTErr TTLowpassTwoPole::setResonance(const TTValue& newValue)
{
mResonance = TTClip(TTFloat64(newValue), 0.001, 100.0);
mNegOneOverResonance = -1.0/mResonance;
calculateCoefficients();
return kTTErrNone;
}
TTErr TTLowpassTwoPole::setFrequency(const TTValue& newValue)
{
mFrequency = newValue;
mRadians = hertzToRadians(mFrequency);
calculateCoefficients();
return kTTErrNone;
}
TTErr TTHighpassButterworth2::setFrequency(const TTValue& newValue)
{
mFrequency = newValue;
mC = tan( kTTPi*(mFrequency/sr ) );
mCSquared = mC * mC;
calculateCoefficients();
return kTTErrNone;
}
TTErr TTHighpassLinkwitzRiley4::setFrequency(const TTValue& newValue)
{
mFrequency = newValue;
mRadians = kTTTwoPi*mFrequency;
mK = mRadians/tan(kTTPi*mFrequency/sr); // kTTTwoPi*frequency/tan(kTTPi*frequency/sr);
calculateCoefficients();
return kTTErrNone;
}
TTErr TTSvf::setFrequency(const TTValue& newValue)
{
mFrequency = newValue;
mF = 2.0 * sin(kTTHalfPi * mFrequency / sr ); // equivalent to mF = 2.0 * sin(kTTPi * mFrequency / double(sr * 2));
if (mF > 0.25)
mF = 0.25;
calculateCoefficients();
return kTTErrNone;
}
TTErr TTLowpassLinkwitzRiley2::setFrequency(const TTValue& newValue)
{
mFrequency = newValue;
mRadians = kTTTwoPi*mFrequency;
mK = mRadians/tan(kTTPi*mFrequency/sr); // kTTTwoPi*frequency/tan(kTTPi*frequency/sr);
mRadiansSquared = mRadians * mRadians;
mKSquared = mK * mK;
calculateCoefficients();
return kTTErrNone;
}
TTErr TTLowpassButterworth3::setFrequency(const TTValue& newValue)
{
mFrequency = newValue;
mRadians = kTTTwoPi*mFrequency;
mRadiansSquared = mRadians * mRadians;
mRadiansCubic = mRadiansSquared * mRadians;
mK = mRadians/tan(kTTPi*mFrequency/sr); // kTTTwoPi*frequency/tan(kTTPi*frequency/sr);
mKSquared = mK * mK;
mKCubic = mKSquared * mK;
calculateCoefficients();
return kTTErrNone;
}
TTErr TTLowpassButterworth4::setFrequency(const TTValue& newValue)
{
mFrequency = newValue;
mRadians = kTTTwoPi*mFrequency;
mRadians2 = mRadians*mRadians;
mRadians3 = mRadians2*mRadians;
mRadians4 = mRadians3*mRadians;
mK = mRadians/tan(kTTPi*mFrequency/sr); // kTTTwoPi*frequency/tan(kTTPi*frequency/sr);
mK2 = mK*mK;
mK3 = mK2 * mK;
mK4 = mK3 * mK;
calculateCoefficients();
return kTTErrNone;
}
void Filter::setSamplerate(float samplerate)
{
m_samplerate = samplerate;
calculateCoefficients();
}
/** @brief generateDecryptionKey
*
* @todo: document this function
*/
int RSAEncDec::generateDecryptionKey()
{
int a[1][2];
a=calculateCoefficients(e,(p-1)*(q-1));
return a[0][1];
}
