/* used in headerbuttons.c image.c mesh.c screen.c sound.c and library.c */
void free_libblock(ListBase *lb, void *idv)
{
ID *id= idv;
#ifdef WITH_PYTHON
BPY_id_release(id);
#endif
switch( GS(id->name) ) { /* GetShort from util.h */
case ID_SCE:
free_scene((Scene *)id);
break;
case ID_LI:
free_library((Library *)id);
break;
case ID_OB:
free_object((Object *)id);
break;
case ID_ME:
free_mesh((Mesh *)id);
break;
case ID_CU:
free_curve((Curve *)id);
break;
case ID_MB:
free_mball((MetaBall *)id);
break;
case ID_MA:
free_material((Material *)id);
break;
case ID_TE:
free_texture((Tex *)id);
break;
case ID_IM:
free_image((Image *)id);
break;
case ID_LT:
free_lattice((Lattice *)id);
break;
case ID_LA:
free_lamp((Lamp *)id);
break;
case ID_CA:
free_camera((Camera*) id);
break;
case ID_IP:
free_ipo((Ipo *)id);
break;
case ID_KE:
free_key((Key *)id);
break;
case ID_WO:
free_world((World *)id);
break;
case ID_SCR:
free_screen((bScreen *)id);
break;
case ID_VF:
free_vfont((VFont *)id);
break;
case ID_TXT:
free_text((Text *)id);
break;
case ID_SCRIPT:
//XXX free_script((Script *)id);
break;
case ID_SPK:
free_speaker((Speaker *)id);
break;
case ID_SO:
sound_free((bSound*)id);
break;
case ID_GR:
free_group_objects((Group *)id);
break;
case ID_AR:
free_armature((bArmature *)id);
break;
case ID_AC:
free_action((bAction *)id);
break;
case ID_NT:
ntreeFreeTree((bNodeTree *)id);
break;
case ID_BR:
free_brush((Brush *)id);
break;
case ID_PA:
psys_free_settings((ParticleSettings *)id);
break;
case ID_WM:
if(free_windowmanager_cb)
free_windowmanager_cb(NULL, (wmWindowManager *)id);
break;
case ID_GD:
free_gpencil_data((bGPdata *)id);
break;
}
if (id->properties) {
IDP_FreeProperty(id->properties);
MEM_freeN(id->properties);
}
BLI_remlink(lb, id);
/* this ID may be a driver target! */
BKE_animdata_main_cb(G.main, animdata_dtar_clear_cb, (void *)id);
MEM_freeN(id);
}
void Decoder::decode(Instance * inst) {
init_lattice(inst);
viterbi_decode(inst);
get_result(inst);
free_lattice();
}
int
main (int argc, char **argv)
{
settings conf;
double beta_step, beta_start, beta;
datapoint data;
double c0, cl1, cl2, cr1, cr2;
const gsl_rng_type * RngType;
gsl_rng_env_setup();
RngType = gsl_rng_default;
conf.rng = gsl_rng_alloc (RngType);
lattice_site * lattice = NULL;
gsl_vector * mag_vector = NULL ;
/************
* SETTINGS *
************/
conf.spindims = 2;
conf.spacedims = 2;
conf.sidelength = 32;
conf.max_settle = 1000;
conf.block_size = 1000;
conf.blocks = 20;
conf.verbose_flag = 0;
/*************************************
* ALLOCATION OF LATTICE AND VECTORS *
*************************************/
//Store Element number for future use
conf.elements = intpow(conf.sidelength,conf.spacedims);
printf("#Allocating\n");
int * location = (int *) malloc(conf.spacedims*sizeof(int));
int * neigh = (int *) malloc(conf.spacedims*sizeof(int));
lattice = allocate_lattice(conf);
if(conf.verbose_flag)
fprintf(stderr,"#Allocated %d points on the lattice\n",conf.elements);
randomize_spins(lattice,conf);
/* if(conf.verbose_flag)
print_lattice (lattice,sidelength,conf.spacedims,conf.spindims); */
mag_vector = gsl_vector_calloc(conf.spindims);
/**********************
* Running Simulation *
**********************/
double err = 100;
double firstd, secondd;
beta_start = 0.45;
beta_step = 0.001;
double dbeta;
beta = beta_start;
while(err > 0.01)
{
//Calculate values of specific heat
//c(beta)
clusterupdatebatch(lattice,conf,beta,&data);
c0 = data.c;
//Left and Right one step
clusterupdatebatch(lattice,conf,beta-beta_step,&data);
cl1 = data.c;
clusterupdatebatch(lattice,conf,beta+beta_step,&data);
cr1 = data.c;
//Left and Right one step
clusterupdatebatch(lattice,conf,beta-2*beta_step,&data);
cl2 = data.c;
clusterupdatebatch(lattice,conf,beta+2*beta_step,&data);
cr2 = data.c;
//Find first derivative
firstd = ( ((cl2-cr2)/12) +(2*(-cl1+cr1)/3) )/beta_step;
//Find second derivative
secondd = ( ((-cl2-cr2)/12) +(4*(cl1+cr1)/3) - (5*c0/2) )/pow(beta_step,2);
dbeta = firstd/secondd;
err = fabs(firstd);
beta = beta - dbeta;
printf("Beta Est = %g delta= %g firstd= %g secondd= %g\n",beta,dbeta,firstd,secondd);
}
/***********
* CLEANUP *
***********/
printf("#Cleaning Up\n");
free_lattice(lattice,conf);
free(location);
location = NULL;
free(neigh);
neigh = NULL;
/* Free GSL Random Num Generator*/
gsl_rng_free (conf.rng);
printf("#Done\n");
return EXIT_SUCCESS;
}
int
main (int argc, char * argv[])
{
int i,j;
int size = argc - 2;
int *data = (int *) malloc(sizeof(int)*size);
int sidelength, spacedims, spindims;
int * loc;
int num;
gsl_rng * rng;
const gsl_rng_type * RngType;
gsl_rng_env_setup();
RngType = gsl_rng_default;
rng = gsl_rng_alloc (RngType);
gsl_vector ** lattice;
gsl_vector * magnet;
double mag,energy;
/* Read in data */
if(size != 0)
{
for (i = 0 ; i< size ; i++)
{
data[i] = atoi(argv[i+2]);
}
}
switch(atoi(argv[1]))
{
case 0: /* Magnetization */
/**********************************************
* Outputs magnetization of a uniform lattice *
**********************************************/
sidelength = data[0];
spacedims = data[1];
spindims = data[2];
magnet = gsl_vector_alloc(spindims);
lattice = allocate_lattice(sidelength,spacedims,spindims);
set_homogenious_spins(lattice,sidelength,spacedims,spindims);
mag = magnetization(lattice,sidelength,spacedims,spindims,magnet);
free_lattice(lattice,sidelength,spacedims);
printf("%2.1f\n",mag);
break;
case 1: /* Local Energy */
/**********************************************
* Outputs energy of a uniform lattice point *
**********************************************/
sidelength = data[0];
spacedims = data[1];
spindims = data[2];
loc = (int *) malloc(sizeof(int)*spacedims);
for(i = 0 ; i < spacedims ; i++)
loc[i] = data[i+3];
lattice = allocate_lattice(sidelength,spacedims,spindims);
set_homogenious_spins(lattice,sidelength,spacedims,spindims);
energy = 0;
energy = local_energy(lattice, sidelength, spacedims, spindims, loc);
free_lattice(lattice,sidelength,spacedims);
printf("%1.3e\n",energy);
break;
case 2: /* Total Energy */
/********************************************
* Outputs energy of a checkerboard lattice *
********************************************/
sidelength = data[0];
spacedims = data[1];
spindims = data[2];
lattice = allocate_lattice(sidelength,spacedims,spindims);
set_checkerboard_spins(lattice,sidelength,spacedims,spindims);
energy = total_energy(lattice, sidelength, spacedims, spindims );
printf("%1.3e\n",energy);
break;
default:
printf("No arguments!\n");
exit(EXIT_FAILURE);
}
}
