const Matrix<complex<double> > randomMatrix( Uniform<double>& generator, 
                                             const int dimension,
                                             const double upperBound ) {

    Matrix<complex<double> > tmp( dimension, dimension,
                                  complex<double>(0.0,0.0) );
    for ( int i=0; i<dimension; i++ ) {
        tmp[i][i] = generator.random();
        for ( int j=0; j<i; j++ ) {
            tmp[j][i] = complex<double>( generator.random() - 0.5,
                                         generator.random() - 0.5 );
            tmp[i][j] = conj( tmp[j][i] );
        }
    }

    double trace = 0.0;
    for ( int i=0; i<dimension; i++ ) {
        trace += tmp[i][i].real();
    }

    if ( trace < ZERO ) throw Fpe("trace too small");

    for ( int i=0; i<dimension; i++ ) {
        for ( int j=0; j<dimension; j++ ) {
            tmp[i][j] /= trace;
            tmp[i][j] *= upperBound;
        }
    }

    return tmp;

}

void Shader::extractShaderUniforms()
{
	GLuint pId = getProgramID();
	const int BUFF_SIZE = 255;
	int count;
	glGetProgramiv(pId, GL_OBJECT_ACTIVE_UNIFORMS_ARB, &count);

	for (int i = 0; i < count; ++i)
	{
		char name[BUFF_SIZE]; // for holding the variable name
		GLint size = BUFF_SIZE;
		GLenum type;
		GLsizei length;
		GLsizei bufSize = BUFF_SIZE;
		glGetActiveUniform(pId, i, bufSize, &length, &size, &type, name);
		int location = glGetUniformLocation(pId, name);

		Uniform* uniform = UniformFactory::createUniform(name, type);
		uniform->addOwner(this,location);
		uniforms.insert(std::make_pair(uniform->getName(), uniform));

		//Borrar
		const char* uni_types[6] = { "Error", "FLOAT", "FLOAT_VEC3", "FLOAT_VEC4", "FLOAT_MAT3", "FLOAT_MAT4" };
		printf("Uniform name: %s. Type: %s.\n", uniform->getName().c_str(), uni_types[uniform->getType()]);	
	}
	printf("---------------\n");
}

int main() {
  switch (2) {
    case 0: {
      // Sample uniform scalars.
      Uniform<> uniform;
      for (int i = 0; i < 100; i++) {
        cout << uniform.sample() << " ";
      }
      cout << endl;
      break;
    }
    case 1: {
      // Sample Gaussian.
      Vector2d mean;
      mean << -4, 10;
      Matrix<double, 2, 2> covariance;
      covariance << 3, -1.6, -1.6, 1;
      Gaussian<double, 2> gaussian(mean, covariance);
      Matrix2Xd samples(2, 1000);
      gaussian.sample(samples);
      // Output is where lots of mallocs and frees happen.
      cout << samples << endl;
      break;
    }
    case 2: {
      // Bag classification problem.
      testProblem(buildSqueezeProblem);
      break;
    }
  }
  return 0;
}

void Squad::read_members() {
    m_members_addr = m_df->enumerate_vector(m_address + m_mem->squad_offset("members"));

    short carry_food = m_df->read_short(m_address+m_mem->squad_offset("carry_food"));
    short carry_water = m_df->read_short(m_address+m_mem->squad_offset("carry_water"));
    int carry_ammo = m_df->enumerate_vector(m_address+m_mem->squad_offset("ammunition")).count();

    //read the uniforms
    int position = 0;
    Uniform *u;
    foreach(VIRTADDR addr, m_members_addr){
        u = new Uniform(m_df,this);

        m_members.insert(position,m_df->read_int(addr));
        read_equip_category(addr+m_mem->squad_offset("armor_vector"),ARMOR,u);
        read_equip_category(addr+m_mem->squad_offset("helm_vector"),HELM,u);
        read_equip_category(addr+m_mem->squad_offset("pants_vector"),PANTS,u);
        read_equip_category(addr+m_mem->squad_offset("gloves_vector"),GLOVES,u);
        read_equip_category(addr+m_mem->squad_offset("shoes_vector"),SHOES,u);
        read_equip_category(addr+m_mem->squad_offset("shield_vector"),SHIELD,u);
        read_equip_category(addr+m_mem->squad_offset("weapon_vector"),WEAPON,u);

        //add other items
        if(carry_ammo){
            u->add_uniform_item(addr+m_mem->squad_offset("quiver"),QUIVER);
            u->add_uniform_item(AMMO,-1,-1);
        }
        if(carry_food)
            u->add_uniform_item(addr+m_mem->squad_offset("backpack"),BACKPACK);
        if(carry_water)
            u->add_uniform_item(addr+m_mem->squad_offset("flask"),FLASK);

        m_uniforms.insert(position,u);
        position++;
    }

/***************************************************************
* Function: updateVSParameters()
***************************************************************/
void DSVirtualEarth::updateVSParameters(const Vec3 &viewDir, const Vec3 &viewPos)
{
    if (!mVirtualScenicHandler) return;

    /*  compute sun direction in world space: apply transforms resulted by viewer's orientation change, 
	guarantee that from the viewer's position, the virtual earth is always half illuminated. */
    Matrixd baserotMat;
    baserotMat.makeRotate(Vec3(0, 1, 0), gDesignStateFrontVect);
    Vec3 sunDirWorld = (CAVEAnimationModeler::ANIMVirtualEarthLightDir()) * baserotMat;
    StateSet *stateset = mEarthGeode->getStateSet();
    if (stateset)
    {
	Uniform *lightposUniform = stateset->getOrCreateUniform("LightPos", Uniform::FLOAT_VEC4);
	lightposUniform->set(Vec4(sunDirWorld, 0.0));
    }

    /* compute matrix combination that transforms a vector from shader space into world space */
    Matrixd latiMat;
    latiMat.makeRotate(mLati / 180.f * M_PI, Vec3(0, 1, 0));
    Matrixd equatorMat;   
    equatorMat.makeRotate((mTimeOffset / 12.f + mLongi / 180.f) * M_PI, Vec3(0, 0, 1));  
    Matrixd tiltaxisMat = mTiltAxisTrans->getMatrix();
    Matrixd eclipticMat = mEclipticTrans->getMatrix();
    Matrixd transMat = mUnitspaceMat * latiMat * equatorMat * tiltaxisMat * eclipticMat * baserotMat;

    /* updata environment rendering by passing parameters to VirtualScenicHandler */
    mVirtualScenicHandler->updateVSParameters(transMat, sunDirWorld, viewDir, viewPos);
}

Uniform const& GLES_Shader::get_uniform_skin_matrix(void* data) const
{
    Command_Stream::Render_Context* ctx = (Command_Stream::Render_Context*)data;
    static Uniform u(Uniform::Type::VEC4, 1);
    if (u.get_count() == 1)
    {
        u = Uniform(Uniform::Type::VEC4, m_max_skin_nodes * 3);
    }
    if (ctx)
    {
        QASSERT(ctx->render_job_data->node_transform_count < m_max_skin_nodes);
        size_t count = math::min(ctx->render_job_data->node_transform_count, m_max_skin_nodes);
        if (u.get_count() == count * 3)
        {
            u = Uniform(Uniform::Type::VEC4, count * 3);
        }
        for (size_t i = 0; i < count; i++)
        {
            auto const& mat = ctx->render_job_data->node_transforms[i].mat;
            u.set(i*3 + 0, mat.get_row(0));
            u.set(i*3 + 1, mat.get_row(1));
            u.set(i*3 + 2, mat.get_row(2));
        }
    }
    return u;
}

bool pushUniform_sub(const std::string& name, const Uniform& uniform, UniformStack& stack) {
    auto p = uniform.find(name);
    if (p != uniform.end()) {
        stack[name].push(p->second);
        return true;
    }
    return false;
}

void Shader::SetUniformValueByIndex(int32 uniformIndex, const Matrix3 & matrix)
{
	DVASSERT(uniformIndex >= 0 && uniformIndex < activeUniforms);
	Uniform* currentUniform = GET_UNIFORM(uniformIndex);
	if(currentUniform->ValidateCache(matrix) == false)
	{
		RENDER_VERIFY(glUniformMatrix3fv(currentUniform->location, 1, GL_FALSE, matrix.data));
	}
}

bool popUniform_sub(const std::string& name, Uniform& uniform, UniformStack& stack) {
    auto p = uniform.find(name);
    if (p != uniform.end()) {
        p->second = stack[name].top();
        stack[name].pop();
        return true;
    }
    return false;
}

void printRandoms()
{
  Uniform<T> x;
  //x.seed((unsigned int)time(0));
  x.seed(5);
  int N=5;
  for (int i = 0; i < N; ++i) 
    cout << setprecision(digits10(T())) << LD_HACK(x.random()) << endl;

  cout << endl;
}

bool Pass::hasUniformState(const char* name) const
{
  if (!m_program)
    return false;

  Uniform* uniform = m_program->findUniform(name);
  if (!uniform)
    return false;

  return !uniform->isShared();
}

void getUniformNumbersAsArray(Array * targetArray,const Uniform & u){
	const value_t *v = reinterpret_cast<const value_t*>(u.getData());
	const size_t numSingleValues = u.getDataSize() / sizeof(value_t);
	ERef<Array> arr;
	for(size_t i=0;i<numSingleValues;++i){
		if( (i%bucketSize) == 0){
			arr=Array::create();
			targetArray->pushBack(arr.get());
		}
		arr->pushBack(Number::create(v[i]));
	}
}

    Eigen::VectorXd sample(const Uniform &d, RNG &rng)
    {
      std::uniform_real_distribution<double> dist(0, 1);

      Eigen::ArrayXd sample(length(d));
      for (Eigen::ArrayXd::Index i = 0; i < sample.rows(); i++)
      {
        sample(i) = dist(rng);
      }

      // Transform the output to fit within the support of the distribution
      return d.min().array() + sample * (d.max() - d.min()).array();
    }

 void IEffect::UseCustomTexture(Texture* texture)
 {        
     Uniform CustomTexture;
     std::ostringstream toSTR; toSTR << "uTex" << TextureUnits;
     CustomTexture.Name = toSTR.str();
     CustomTexture.Type = DataType::Int;
     CustomTexture.Usage = PostEffects::Other;
     CustomTexture.SetValue(&TextureUnits);
     AddUniform(CustomTexture);
     
     // Set RTT Order
     RTTOrder.push_back(RTT::Info(texture, RTT::CustomTexture, TextureUnits));
     
     TextureUnits++;
 }

int CFeasibilityMap::count_x_out_fn(CData &Data,int i_tau, int i_original,int n_simul, Uniform &randUnif) {
	
  // double case2_count_out = 0;
	int case2_count_out = 0; // Changed by Hang on 5/16/2015
	
  ColumnVector s_i = tau_to_s_fn( i_tau, Data.n_var );   
  ColumnVector item_by_joint = Data.copy_non_balance_edit(s_i);
  ColumnVector tilde_y_i = Data.log_D_Observed.row(i_original).t();
  
	for (int i_simul=1; i_simul<=n_simul; i_simul++){
			//Generate from uniform distribution
			ColumnVector y_q = tilde_y_i;
			for ( int temp_j=1; temp_j<=Data.n_var; temp_j++ ){
				if ( item_by_joint(temp_j)==1 ){
					y_q(temp_j) = Data.logB_L(temp_j)+Data.logB_U_L(temp_j)*randUnif.Next(); 
				} 
			} 
	
			ColumnVector x_q = exp_ColumnVector(y_q) ;
      Data.update_full_x_for_balance_edit(x_q);
			// if (!Data.PassEdits(x_q)) { case2_count_out += 1.0;}
      if (!Data.PassEdits(x_q)) { case2_count_out += 1;}  // Changed by Hang on 5/16/2015
	} 
  if (case2_count_out ==0) {
    case2_count_out = 1;
  }
	return case2_count_out; // ADDED by Hang on 5/16/2015
}

void ShVarModel::setRecursiveUniformValues(ShVarItem *item, const Uniform& u)
{
	if (!item)
		return;

	if (item->getFullName() == u.name()) {
		dbgPrint(DBGLVL_INFO, "found uniform: %s\n", u.name().toAscii().data());
		item->setData(DF_DEBUG_UNIFORM_VALUE, u.toString());
		emit dataChanged(ShVarModel::getIndex(item, 0),
				ShVarModel::getIndex(item, DF_LAST - 1));
	} else {
		for (int i = 0; i < item->childCount(); ++i) {
			setRecursiveUniformValues(item->child(i), u);
		}
	}
}

/*
=============
OpenGLProgram::SetUniform

	Sets a uniform int value.
=============
*/
void OpenGLProgram::SetUniform( const char* name, const int* value, unsigned size ) {	
	Uniform* cachedUniform = GetCachedUniform( name );
    if ( cachedUniform ) {
        cachedUniform->Set( value );
    } else {
	    //Not found
        GLint location = glGetUniformLocation( m_programID, name );
	    if ( location > -1 ) {
		    Uniform* newUniform = new Uniform( location, name, size );
		    newUniform->Set( value );
        
            m_uniforms[StringUtils::Hash( name )] = ( newUniform );
	    } else {
			printf( "Could not find int uniform: %s\n", name );
        }
    }
}

	void Render(double time)
	{
		gl.Clear().ColorBuffer().DepthBuffer();
		//
		auto lightAzimuth = FullCircles(time * -0.5);
		light_pos.Set(
			Vec3f(
				Cos(lightAzimuth),
				1.0f,
				Sin(lightAzimuth)
			) * 2.0f
		);
		//
		camera_matrix.Set(
			CamMatrixf::Orbiting(
				Vec3f(),
				3.0f,
				Degrees(-45),
				Degrees(SineWave(time / 30.0) * 70)
			)
		);

		// set the model matrix
		model_matrix.Set(
			ModelMatrixf::RotationY(FullCircles(time * 0.05))
		);

		cube.Bind();
		gl.CullFace(Face::Back);
		cube_instr.Draw(cube_indices);
	}

	void Render(double time)
	{
		gl.Clear().ColorBuffer().DepthBuffer();

		camera_matrix.Set(
			CamMatrixf::Orbiting(
				Vec3f(),
				4.0,
				Degrees(time * 25),
				Degrees(SineWave(time / 30.0) * 90)
			)
		);

		model_matrix.Set(
			ModelMatrixf::RotationA(
				Vec3f(1.0f, 1.0f, 1.0f),
				FullCircles(time * 0.5)
			)
		);

		shape.Draw();

		thread_ready.Signal();
		parent_ready.Wait();
	}

	void Render(const PangoCairoLayout& layout)
	{
		_bitmap.Set(GLint(layout.Use()));
		_log_coords.Set(layout._log_coords);
		_tex_coords.Set(layout._tex_coords);
		_gl.DrawArrays(PrimitiveType::Points, 0, 1);
	}