void CState::randnVelocity(double mean, double sigma_v, long *seed)
{
vec2 randomNormal, randomUniform;
mat velocities(nAtoms, 3);
rowvec3 momentum;
double R;
for (int i = 0; i < nAtoms; i++)
{
for (int j = 0; j < 3; j++)
{
// Box-Muller transform
randomUniform << ran2(seed) << ran2(seed);
R = sqrt(-2*log(randomUniform(0)));
randomNormal(0) = R*cos(2*pi*randomUniform(1));
velocities(i, j) = randomNormal(0)*sigma_v + mean;
// unused random number... should probably use this one for something
// randomNormal(1) = R*sin(2*pi*randomUniform(1))*sigma_v + mean;
}
}
momentum = sum(velocities)/nAtoms; // finding the linear momentum of the system
for (int i = 0; i < nAtoms; i++)
{
velocities.row(i) -= momentum; // removing initial linear momentum from the system
}
// sending the generated velocities to the atoms
for (int i = 0; i < nAtoms; i++)
{
atoms[i]->setVelocity(velocities.row(i).t());
}
}
void randomCorrelation( double (&R)[NS][NS], uint32_t &seed )
{
double T[NS][NS];
for ( size_t i=0; i<NS; ++i )
{
for ( size_t j=0; j<NS; ++j )
{
T[i][j] = randomNormal( seed );
}
}
for ( size_t j=0; j<NS; ++j )
{
double sqSum = 0.0;
for ( size_t i=0; i<NS; ++i )
{
sqSum += T[i][j] * T[i][j];
}
double norm = sqrt( sqSum );
for ( size_t i=0; i<NS; ++i )
T[i][j] /= norm;
}
double TTrans[NS][NS];
trans( T, TTrans );
multMatMat( TTrans, T, R );
}
/********** Cr� la population **********/
void itsHybridContinuousInteractingAntColony::createAnts()
{
// r�ervations vecteurs
antProbaMemory.reserve( antsNb );
//antMoveRange.reserve( antsNb*SpaceDim() );
antMoveRange.reserve( antsNb );
antCurrentPoint.reserve( antsNb * this->getProblem()->getDimension() );
antCurrentValue.reserve( antsNb );
// trop gourmand : antIncomingPoints.reserve( antsNb*antsNb*SpaceDim() );
antIncomingPoints.reserve( antsNb*antsNb );
antIncomingValues.reserve( antsNb*antsNb );
antState.reserve( antsNb );
for( unsigned int i=0; i < antsNb; i++ ) {
// tirage al�toire uniforme sur l'hypercube de l'espace de recherche
vector<double> aPoint;
/*
aPoint.reserve( this->getProblem()->getDimension() );
aPoint = randomUniform( this->getProblem()->boundsMinima(), this->getProblem()->boundsMaxima() );
*/
aPoint = this->getSamplePointAddr(i)->getSolution();
// tire suivant N l'amplitude max de mouvement
// distribution normale sur la moyenne de l'amplitude de l'espace de recherche
double aMoveRange;
aMoveRange = abs( randomNormal(
mean( substraction(this->getProblem()->boundsMaxima(),this->getProblem()->boundsMinima()) ) * moveRangeMeanRatio,
1/2 * mean( substraction(this->getProblem()->boundsMaxima(),this->getProblem()->boundsMinima()) ) * moveRangeStdRatio
) );
// tire sur N la probabilit�de d�art d'utiliser un type de m�oire
double aProbaUseMemory;
aProbaUseMemory = randomNormal( probaUseMemoryMean, probaUseMemoryStd );
// corrige les d�assements
if ( aProbaUseMemory < 0 ) { aProbaUseMemory = 0; }
if ( aProbaUseMemory > 1 ) { aProbaUseMemory = 1; }
// ajoute la fourmi
addAnt( aPoint, aMoveRange, aProbaUseMemory );
}
}
vector< T > randomNormal( vector< T > & means, vector< T > & stds )
{
vector< T > v;
unsigned int i;
for(i=0; i<means.size(); i++) {
T x;
x = randomNormal(means[i], stds[i]);
v.push_back(x);
}
return v;
}
T randomNormalMulti( T means, U varcovar )
{
/*
- Let $u$ a vector of $n$ number, following a centered/reducted
normal distribution;
- let $L$ be the matrix resulting from the Cholesky decomposition
of $V$;
- the vector $y=m+Lu$ follow the multi-normal distribution,
with a mean $m$ and a variance-covariance matrix $V$.
*/
T finalPoint;
// Cholesky decomposition of the variance-covariance matrix
U popVarCholesky; // low triangular matrix
popVarCholesky = cholesky( varcovar );
// Vector with terms in a centered/reducted normal distribution
T u;
T mean(means.size(),0.0);
T variance(means.size(),1.0);
u = randomNormal( mean,variance );
// temporary vector for multiplication
U tempU;
tempU.push_back(u);
// post multiplication by the u vector
U tempCompVar;
tempCompVar = multiply( popVarCholesky, transpose(tempU) );
// transposition
T compVar = transpose(tempCompVar)[0];
// addition to the mean
finalPoint = addition( means, compVar );
return finalPoint;
}
void randomNormalVec( double (&vec)[NS], uint32_t &seed )
{
for ( size_t i=0; i<NS; ++i )
vec[i] = randomNormal( seed );
}
void GenEcho::step() {
// Implement a simple sine oscillator
//float deltaTime = engineGetSampleTime();
float amp_out = 0.0;
// handle the 3 switches for accumlating and mirror toggle
// and probability distrobution selection
is_accumulating = (int) params[ACCM_PARAM].value;
is_mirroring = (int) params[MIRR_PARAM].value;
dt = (DistType) params[PDST_PARAM].value;
// read in cv vals for astp, dstp and bpts
bpts_sig = 5.f * quadraticBipolar((inputs[BPTS_INPUT].value / 5.f) * params[BPTSCV_PARAM].value);
astp_sig = quadraticBipolar((inputs[ASTP_INPUT].value / 5.f) * params[ASTPCV_PARAM].value);
dstp_sig = quadraticBipolar((inputs[DSTP_INPUT].value / 5.f) * params[DSTPCV_PARAM].value);
max_amp_step = rescale(params[ASTP_PARAM].value + (astp_sig / 4.f), 0.0, 1.0, 0.05, 0.3);
max_dur_step = rescale(params[DSTP_PARAM].value + (dstp_sig / 4.f), 0.0, 1.0, 0.01, 0.3);
sample_length = (int) (clamp(params[SLEN_PARAM].value, 0.1, 1.f) * MAX_SAMPLE_SIZE);
bpt_spc = (unsigned int) params[BPTS_PARAM].value + 800;
bpt_spc += (unsigned int) rescale(bpts_sig, -1.f, 1.f, 1.f, 200.f);
num_bpts = sample_length / bpt_spc + 1;
env_dur = bpt_spc / 2;
// snap knob for selecting envelope for the grain
int env_num = (int) clamp(roundf(params[ENVS_PARAM].value), 1.0f, 4.0f);
if (env.et != (EnvType) env_num) {
env.switchEnvType((EnvType) env_num);
}
// handle sample reset
if (smpTrigger.process(params[TRIG_PARAM].value)
|| resetTrigger.process(inputs[RSET_INPUT].value / 2.f)) {
for (unsigned int i=0; i<MAX_SAMPLE_SIZE; i++) sample[i] = _sample[i];
for (unsigned int i=0; i<MAX_BPTS; i++) {
mAmps[i] = 0.f;
mDurs[i] = 1.f;
}
}
// handle sample trigger through gate
if (g2Trigger.process(inputs[GATE_INPUT].value / 2.f)) {
// reset accumulated breakpoint vals
for (unsigned int i=0; i<MAX_BPTS; i++) {
mAmps[i] = 0.f;
mDurs[i] = 1.f;
}
num_bpts = sample_length / bpt_spc;
sampling = true;
idx = 0;
s_i = 0;
}
if (sampling) {
if (s_i >= MAX_SAMPLE_SIZE - 50) {
float x,y,p;
x = sample[s_i-1];
y = sample[0];
p = 0.f;
while (s_i < MAX_SAMPLE_SIZE) {
sample[s_i] = (x * (1-p)) + (y * p);
p += 1.f / 50.f;
s_i++;
}
debug("Finished sampling");
sampling = false;
} else {
sample[s_i] = inputs[WAV0_INPUT].value;
_sample[s_i] = sample[s_i];
s_i++;
}
}
if (phase >= 1.0) {
phase -= 1.0;
amp = amp_next;
index = (index + 1) % num_bpts;
// adjust vals
astp = max_amp_step * rg.my_rand(dt, randomNormal());
dstp = max_dur_step * rg.my_rand(dt, randomNormal());
if (is_mirroring) {
mAmps[index] = mirror((is_accumulating ? mAmps[index] : 0.f) + astp, -1.0f, 1.0f);
mDurs[index] = mirror(mDurs[index] + (dstp), 0.5, 1.5);
}
else {
mAmps[index] = wrap((is_accumulating ? mAmps[index] : 0.f) + astp, -1.0f, 1.0f);
mDurs[index] = wrap(mDurs[index] + dstp, 0.5, 1.5);
}
amp_next = mAmps[index];
// step/adjust grain sample offsets
g_idx = g_idx_next;
g_idx_next = 0.0;
}
// change amp in sample buffer
sample[idx] = wrap(sample[idx] + (amp * env.get(g_idx)), -5.f, 5.f);
amp_out = sample[idx];
idx = (idx + 1) % sample_length;
g_idx = fmod(g_idx + (1.f / (4.f * env_dur)), 1.f);
g_idx_next = fmod(g_idx_next + (1.f / (4.f * env_dur)), 1.f);
phase += 1.f / (mDurs[index] * bpt_spc);
// get that amp OUT
outputs[SINE_OUTPUT].value = amp_out;
}
/// creates a random noise texture
void view::create_noise_texture(int width /* = 512 */, int height /* = 512 */, int seed /* = 1 */ )
{
Pixel* data = new Pixel[width * height];
if(data == 0) {
std::cout << "shit, memory full:(\n";
exit(1);
}
Utilities::Random r(seed);
for(int i = 0; i < 200; ++i) {
int x = r.randomFloat() * width;
int y = r.randomFloat() * height;
int pos = x + y * width;
// get random normal
float theta = r.randomFloat(0.0, PI);
float phi = r.randomFloat(0.0, PI_2);
point3f randomNormal(sin(theta) * cos(phi), sin(theta) * sin(phi), cos(theta));
data[pos].r = (unsigned char)255.0f * randomNormal.x();
data[pos].g = (unsigned char)255.0f * randomNormal.y();
data[pos].b = (unsigned char)255.0f * randomNormal.z();
data[pos].a = 255;
}
// for(int i = 0; i < width; ++i) {
// for(int j = 0; j < height; ++j) {
// int pos = i + j * width;
// data[pos].r = 255;
// data[pos].g = 0;
// data[pos].b = 0;
// }
// }
unsigned int texId;
glGenTextures(1, &texId);
glBindTexture(GL_TEXTURE_2D, texId);
m_noise_tex.level = 0;
m_noise_tex.internal_format = GL_RGBA8;
m_noise_tex.width = width;
m_noise_tex.height = height;
m_noise_tex.border = 0;
m_noise_tex.format = GL_RGBA;
m_noise_tex.type = GL_UNSIGNED_BYTE;
m_noise_tex.pixels = NULL;
m_noise_tex.bound = true;
m_noise_tex.texname = texId;
glTexImage2D( GL_TEXTURE_2D, // target
m_noise_tex.level,
m_noise_tex.internal_format,
m_noise_tex.width,
m_noise_tex.height,
m_noise_tex.border,
m_noise_tex.format,
m_noise_tex.type,
data);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
delete[] data;
}
