void test_erf()
{
static_assert((std::is_same<decltype(erf((double)0)), double>::value), "");
static_assert((std::is_same<decltype(erff(0)), float>::value), "");
static_assert((std::is_same<decltype(erfl(0)), long double>::value), "");
assert(erf(0) == 0);
}
ATF_TC_BODY(erff_inf_pos, tc)
{
const float x = 1.0L / 0.0L;
if (erff(x) != 1.0)
atf_tc_fail_nonfatal("erff(+Inf) != 1.0");
}
ATF_TC_BODY(erff_inf_neg, tc)
{
const float x = -1.0L / 0.0L;
if (erff(x) != -1.0)
atf_tc_fail_nonfatal("erff(-Inf) != -1.0");
}
ATF_TC_BODY(erff_zero_pos, tc)
{
const float x = 0.0L;
float y = erff(x);
if (fabsf(y) > 0.0 || signbit(y) != 0)
atf_tc_fail_nonfatal("erff(+0.0) != +0.0");
}
ATF_TC_BODY(erff_zero_neg, tc)
{
const float x = -0.0L;
float y = erff(x);
if (fabsf(y) > 0.0 || signbit(y) == 0)
atf_tc_fail_nonfatal("erff(-0.0) != -0.0");
}
__declspec(noinline) void GetOptionPrices(float *pT, float *pK, float *pS0, float *pC)
{
int i;
float d1, d2, erf1, erf2, invf;
float sig2 = sig * sig;
#pragma simd
for (i = 0; i < N; i++)
{
invf = invsqrtf(sig2 * pT[i]);
d1 = (logf(pS0[i] / pK[i]) + (r + sig2 * 0.5f) * pT[i]) / invf;
d2 = (logf(pS0[i] / pK[i]) + (r - sig2 * 0.5f) * pT[i]) / invf;
erf1 = 0.5f + 0.5f * erff(d1 * invsqrt2);
erf2 = 0.5f + 0.5f * erff(d2 * invsqrt2);
pC[i] = pS0[i] * erf1 - pK[i] * expf((-1.0f) * r * pT[i]) * erf2;
}
}
/** Make a gaussian convolution kernel.
\return Returns 0 when successful, otherwise <>0.
*/
int imgFillGaussKernel(
/** Gaussian convolution kernel matrix[size][size], filled here */
float **kernel,
/** Gaussian S.D. in pixels (decimals are ok) */
float stdev,
/** Kernel dimension */
int size
) {
int x, y;
float mx, my, v, ksum=0.0;
if(kernel==NULL || size<3) return 1;
if(stdev<0.0) return 2;
if((size%2)==0) return 3; // size must be odd number
v=stdev*stdev;
for(x=0; x<size; x++) {
mx = x - size/2; // note: ints on purpose
for(y=0; y<size; y++) {
my = y - size/2; // note: ints on purpose
if(stdev>0) {
#if(0) // Gaussian in the middle of pixel is calculated
kernel[y][x] =
(1.0/(2.0*M_PI*v)) * powf(M_E,-((mx*mx)+(my*my))/(2.0*v));
#else // Pixel area is considered
kernel[y][x] = 0.25
*(erff((mx-0.5)/(stdev*M_SQRT2))-erff((mx+0.5)/(stdev*M_SQRT2)))
*(erff((my-0.5)/(stdev*M_SQRT2))-erff((my+0.5)/(stdev*M_SQRT2)));
#endif
} else {
if(x==size/2 && y==size/2) kernel[y][x]=1.0; else kernel[y][x]=0.0;
}
ksum+=kernel[y][x];
}
}
/* Ensure quantitativity with normalization;
divide each kernel value by their sum */
v=1.0/ksum;
for(x=0; x<size; x++) for(y=0; y<size; y++) kernel[y][x]*=v;
return 0;
}
static t_int *erf_perform(t_int *w)
{
t_float *in = (t_float *)(w[1]);
t_float *out = (t_float *)(w[2]);
int n = (int)(w[3]);
while (n--)
*out++ = erff(*in++);
return w+4;
}
int main(void)
{
char txt[MAXSTR];
int i,nval;
float val,x;
FILE *fp;
if ((fp = fopen("fncval.dat","r")) == NULL)
nrerror("Data file fncval.dat not found\n");
fgets(txt,MAXSTR,fp);
while (strncmp(txt,"Error Function",14)) {
fgets(txt,MAXSTR,fp);
if (feof(fp)) nrerror("Data not found in fncval.dat\n");
}
fscanf(fp,"%d %*s",&nval);
printf("\n%s\n",txt);
printf("%4s %12s %12s\n","x","actual","erf(x)");
for (i=1;i<=nval;i++) {
fscanf(fp,"%f %f",&x,&val);
printf("%6.2f %12.7f %12.7f\n",x,val,erff(x));
}
fclose(fp);
return 0;
}
ATF_TC_BODY(erff_nan, tc)
{
const float x = 0.0L / 0.0L;
ATF_CHECK(isnan(erff(x)) != 0);
}
// infty
// Q(z) = 1/sqrt(2 pi) int { exp(-u^2/2) du }
// z
//
// Q(z) = (1/2)*(1 - erf(z/sqrt(2)))
float liquid_Qf(float _z)
{
return 0.5f * (1.0f - erff(_z*M_SQRT1_2));
}
void
domathf (void)
{
#ifndef NO_FLOAT
float f1;
float f2;
int i1;
f1 = acosf(0.0);
fprintf( stdout, "acosf : %f\n", f1);
f1 = acoshf(0.0);
fprintf( stdout, "acoshf : %f\n", f1);
f1 = asinf(1.0);
fprintf( stdout, "asinf : %f\n", f1);
f1 = asinhf(1.0);
fprintf( stdout, "asinhf : %f\n", f1);
f1 = atanf(M_PI_4);
fprintf( stdout, "atanf : %f\n", f1);
f1 = atan2f(2.3, 2.3);
fprintf( stdout, "atan2f : %f\n", f1);
f1 = atanhf(1.0);
fprintf( stdout, "atanhf : %f\n", f1);
f1 = cbrtf(27.0);
fprintf( stdout, "cbrtf : %f\n", f1);
f1 = ceilf(3.5);
fprintf( stdout, "ceilf : %f\n", f1);
f1 = copysignf(3.5, -2.5);
fprintf( stdout, "copysignf : %f\n", f1);
f1 = cosf(M_PI_2);
fprintf( stdout, "cosf : %f\n", f1);
f1 = coshf(M_PI_2);
fprintf( stdout, "coshf : %f\n", f1);
f1 = erff(42.0);
fprintf( stdout, "erff : %f\n", f1);
f1 = erfcf(42.0);
fprintf( stdout, "erfcf : %f\n", f1);
f1 = expf(0.42);
fprintf( stdout, "expf : %f\n", f1);
f1 = exp2f(0.42);
fprintf( stdout, "exp2f : %f\n", f1);
f1 = expm1f(0.00042);
fprintf( stdout, "expm1f : %f\n", f1);
f1 = fabsf(-1.123);
fprintf( stdout, "fabsf : %f\n", f1);
f1 = fdimf(1.123, 2.123);
fprintf( stdout, "fdimf : %f\n", f1);
f1 = floorf(0.5);
fprintf( stdout, "floorf : %f\n", f1);
f1 = floorf(-0.5);
fprintf( stdout, "floorf : %f\n", f1);
f1 = fmaf(2.1, 2.2, 3.01);
fprintf( stdout, "fmaf : %f\n", f1);
f1 = fmaxf(-0.42, 0.42);
fprintf( stdout, "fmaxf : %f\n", f1);
f1 = fminf(-0.42, 0.42);
fprintf( stdout, "fminf : %f\n", f1);
f1 = fmodf(42.0, 3.0);
fprintf( stdout, "fmodf : %f\n", f1);
/* no type-specific variant */
i1 = fpclassify(1.0);
fprintf( stdout, "fpclassify : %d\n", i1);
f1 = frexpf(42.0, &i1);
fprintf( stdout, "frexpf : %f\n", f1);
f1 = hypotf(42.0, 42.0);
fprintf( stdout, "hypotf : %f\n", f1);
i1 = ilogbf(42.0);
fprintf( stdout, "ilogbf : %d\n", i1);
/* no type-specific variant */
i1 = isfinite(3.0);
fprintf( stdout, "isfinite : %d\n", i1);
/* no type-specific variant */
i1 = isgreater(3.0, 3.1);
fprintf( stdout, "isgreater : %d\n", i1);
/* no type-specific variant */
i1 = isgreaterequal(3.0, 3.1);
fprintf( stdout, "isgreaterequal : %d\n", i1);
/* no type-specific variant */
i1 = isinf(3.0);
fprintf( stdout, "isinf : %d\n", i1);
/* no type-specific variant */
i1 = isless(3.0, 3.1);
fprintf( stdout, "isless : %d\n", i1);
/* no type-specific variant */
i1 = islessequal(3.0, 3.1);
fprintf( stdout, "islessequal : %d\n", i1);
/* no type-specific variant */
i1 = islessgreater(3.0, 3.1);
fprintf( stdout, "islessgreater : %d\n", i1);
/* no type-specific variant */
i1 = isnan(0.0);
fprintf( stdout, "isnan : %d\n", i1);
/* no type-specific variant */
i1 = isnormal(3.0);
fprintf( stdout, "isnormal : %d\n", i1);
/* no type-specific variant */
f1 = isunordered(1.0, 2.0);
fprintf( stdout, "isunordered : %d\n", i1);
f1 = j0f(1.2);
fprintf( stdout, "j0f : %f\n", f1);
f1 = j1f(1.2);
fprintf( stdout, "j1f : %f\n", f1);
f1 = jnf(2,1.2);
fprintf( stdout, "jnf : %f\n", f1);
f1 = ldexpf(1.2,3);
fprintf( stdout, "ldexpf : %f\n", f1);
f1 = lgammaf(42.0);
fprintf( stdout, "lgammaf : %f\n", f1);
f1 = llrintf(-0.5);
fprintf( stdout, "llrintf : %f\n", f1);
f1 = llrintf(0.5);
fprintf( stdout, "llrintf : %f\n", f1);
f1 = llroundf(-0.5);
fprintf( stdout, "lroundf : %f\n", f1);
f1 = llroundf(0.5);
fprintf( stdout, "lroundf : %f\n", f1);
f1 = logf(42.0);
fprintf( stdout, "logf : %f\n", f1);
f1 = log10f(42.0);
fprintf( stdout, "log10f : %f\n", f1);
f1 = log1pf(42.0);
fprintf( stdout, "log1pf : %f\n", f1);
f1 = log2f(42.0);
fprintf( stdout, "log2f : %f\n", f1);
f1 = logbf(42.0);
fprintf( stdout, "logbf : %f\n", f1);
f1 = lrintf(-0.5);
fprintf( stdout, "lrintf : %f\n", f1);
f1 = lrintf(0.5);
fprintf( stdout, "lrintf : %f\n", f1);
f1 = lroundf(-0.5);
fprintf( stdout, "lroundf : %f\n", f1);
f1 = lroundf(0.5);
fprintf( stdout, "lroundf : %f\n", f1);
f1 = modff(42.0,&f2);
fprintf( stdout, "lmodff : %f\n", f1);
f1 = nanf("");
fprintf( stdout, "nanf : %f\n", f1);
f1 = nearbyintf(1.5);
fprintf( stdout, "nearbyintf : %f\n", f1);
f1 = nextafterf(1.5,2.0);
fprintf( stdout, "nextafterf : %f\n", f1);
f1 = powf(3.01, 2.0);
fprintf( stdout, "powf : %f\n", f1);
f1 = remainderf(3.01,2.0);
fprintf( stdout, "remainderf : %f\n", f1);
f1 = remquof(29.0,3.0,&i1);
fprintf( stdout, "remquof : %f\n", f1);
f1 = rintf(0.5);
fprintf( stdout, "rintf : %f\n", f1);
f1 = rintf(-0.5);
fprintf( stdout, "rintf : %f\n", f1);
f1 = roundf(0.5);
fprintf( stdout, "roundf : %f\n", f1);
f1 = roundf(-0.5);
fprintf( stdout, "roundf : %f\n", f1);
f1 = scalblnf(1.2,3);
fprintf( stdout, "scalblnf : %f\n", f1);
f1 = scalbnf(1.2,3);
fprintf( stdout, "scalbnf : %f\n", f1);
/* no type-specific variant */
i1 = signbit(1.0);
fprintf( stdout, "signbit : %i\n", i1);
f1 = sinf(M_PI_4);
fprintf( stdout, "sinf : %f\n", f1);
f1 = sinhf(M_PI_4);
fprintf( stdout, "sinhf : %f\n", f1);
f1 = sqrtf(9.0);
fprintf( stdout, "sqrtf : %f\n", f1);
f1 = tanf(M_PI_4);
fprintf( stdout, "tanf : %f\n", f1);
f1 = tanhf(M_PI_4);
fprintf( stdout, "tanhf : %f\n", f1);
f1 = tgammaf(2.1);
fprintf( stdout, "tgammaf : %f\n", f1);
f1 = truncf(3.5);
fprintf( stdout, "truncf : %f\n", f1);
f1 = y0f(1.2);
fprintf( stdout, "y0f : %f\n", f1);
f1 = y1f(1.2);
fprintf( stdout, "y1f : %f\n", f1);
f1 = ynf(3,1.2);
fprintf( stdout, "ynf : %f\n", f1);
#endif
}
// Gauss random number cumulative distribution function
float randnf_cdf(float _x,
float _eta,
float _sig)
{
return 0.5 + 0.5*erff( M_SQRT1_2*(_x-_eta)/_sig );
}
__global__ void FloatMathPrecise() {
int iX;
float fX, fY;
acosf(1.0f);
acoshf(1.0f);
asinf(0.0f);
asinhf(0.0f);
atan2f(0.0f, 1.0f);
atanf(0.0f);
atanhf(0.0f);
cbrtf(0.0f);
fX = ceilf(0.0f);
fX = copysignf(1.0f, -2.0f);
cosf(0.0f);
coshf(0.0f);
cospif(0.0f);
cyl_bessel_i0f(0.0f);
cyl_bessel_i1f(0.0f);
erfcf(0.0f);
erfcinvf(2.0f);
erfcxf(0.0f);
erff(0.0f);
erfinvf(1.0f);
exp10f(0.0f);
exp2f(0.0f);
expf(0.0f);
expm1f(0.0f);
fX = fabsf(1.0f);
fdimf(1.0f, 0.0f);
fdividef(0.0f, 1.0f);
fX = floorf(0.0f);
fmaf(1.0f, 2.0f, 3.0f);
fX = fmaxf(0.0f, 0.0f);
fX = fminf(0.0f, 0.0f);
fmodf(0.0f, 1.0f);
frexpf(0.0f, &iX);
hypotf(1.0f, 0.0f);
ilogbf(1.0f);
isfinite(0.0f);
fX = isinf(0.0f);
fX = isnan(0.0f);
j0f(0.0f);
j1f(0.0f);
jnf(-1.0f, 1.0f);
ldexpf(0.0f, 0);
lgammaf(1.0f);
llrintf(0.0f);
llroundf(0.0f);
log10f(1.0f);
log1pf(-1.0f);
log2f(1.0f);
logbf(1.0f);
logf(1.0f);
lrintf(0.0f);
lroundf(0.0f);
modff(0.0f, &fX);
fX = nanf("1");
fX = nearbyintf(0.0f);
nextafterf(0.0f, 0.0f);
norm3df(1.0f, 0.0f, 0.0f);
norm4df(1.0f, 0.0f, 0.0f, 0.0f);
normcdff(0.0f);
normcdfinvf(1.0f);
fX = 1.0f;
normf(1, &fX);
powf(1.0f, 0.0f);
rcbrtf(1.0f);
remainderf(2.0f, 1.0f);
remquof(1.0f, 2.0f, &iX);
rhypotf(0.0f, 1.0f);
fY = rintf(1.0f);
rnorm3df(0.0f, 0.0f, 1.0f);
rnorm4df(0.0f, 0.0f, 0.0f, 1.0f);
fX = 1.0f;
rnormf(1, &fX);
fY = roundf(0.0f);
rsqrtf(1.0f);
scalblnf(0.0f, 1);
scalbnf(0.0f, 1);
signbit(1.0f);
sincosf(0.0f, &fX, &fY);
sincospif(0.0f, &fX, &fY);
sinf(0.0f);
sinhf(0.0f);
sinpif(0.0f);
sqrtf(0.0f);
tanf(0.0f);
tanhf(0.0f);
tgammaf(2.0f);
fY = truncf(0.0f);
y0f(1.0f);
y1f(1.0f);
ynf(1, 1.0f);
}
/**
* @brief This is the pressure control thread
* @param void* to a PID Loops configuration
* @retval msg_t status
*/
msg_t Pressure_Thread(void *This_Config) {
/* This thread is passed a pointer to a PID loop configuration */
PID_State Pressure_PID_Controllers[((Pressure_Config_Type*)This_Config)->Number_Setpoints];
memset(Pressure_PID_Controllers,0,((Pressure_Config_Type*)This_Config)->Number_Setpoints*sizeof(PID_State));/* Initialise as zeros */
float* Last_PID_Out=(float*)chHeapAlloc(NULL,sizeof(float)*((Pressure_Config_Type*)This_Config)->Number_Setpoints);/* PID output for interpol */
adcsample_t Pressure_Samples[PRESSURE_SAMPLES],Pressure_Sample;/* Use multiple pressure samples to drive down the noise */
float PID_Out,Pressure;//,step=0.01,sawtooth=0.7;
uint32_t Setpoint=0;
uint8_t Old_Setpoint=0, Previous_Setpoint;
chRegSetThreadName("PID_Pressure");
//palSetGroupMode(GPIOC, PAL_PORT_BIT(5) | PAL_PORT_BIT(4), 0, PAL_MODE_INPUT_ANALOG);
palSetPadMode(GPIOE, 9, PAL_MODE_ALTERNATE(1)); /* Only set the pin as AF output here, so as to avoid solenoid getting driven earlier*/
palSetPadMode(GPIOE, 11, PAL_MODE_ALTERNATE(1)); /* Experimental servo output here */
#ifndef USE_SERVO
/*
* Activates the PWM driver
*/
pwmStart(&PWM_Driver_Solenoid, &PWM_Config_Solenoid); /* Have to define the timer to use for PWM_Driver in hardware config */
/*
* Set the solenoid PWM to off
*/
pwmEnableChannel(&PWM_Driver_Solenoid, (pwmchannel_t)PWM_CHANNEL_SOLENOID, (pwmcnt_t)0);
#else
/*
* Activates the experimental servo driver
*/
pwmStart(&PWM_Driver_Servo, &PWM_Config_Servo); /* Have to define the timer to use for PWM_Driver in hardware config */
#endif
/*
* Activates the ADC2 driver *and the thermal sensor*.
*/
adcStart(&ADCD2, NULL);
//adcSTM32EnableTSVREFE();
/*
/ Now we run the sensor offset calibration loop
*/
do {
adcConvert(&ADCD2, &adcgrpcfg1, &Pressure_Sample, 1);/* This function blocks until it has one sample*/
} while(Calibrate_Sensor((uint16_t)Pressure_Sample));
systime_t time = chTimeNow(); /* T0 */
systime_t Interpolation_Timeout = time; /* Set to T0 to show there is no current interpolation */
/* Loop for the pressure control thread */
while(TRUE) {
/*
* Linear conversion.
*/
adcConvert(&ADCD2, &adcgrpcfg1, Pressure_Samples, PRESSURE_SAMPLES);/* This function blocks until it has the samples via DMA*/
/*
/ Now we process the data and apply the PID controller - we use a median filter to take out the non guassian noise
*/
Pressure_Sample = quick_select(Pressure_Samples, PRESSURE_SAMPLES);
Pressure = Convert_Pressure((uint16_t)Pressure_Sample);/* Converts to PSI as a float */
/* Retrieve a new setpoint from the setpoint mailbox, only continue if we get it*/
if(chMBFetch(&Pressures_Setpoint, (msg_t*)&Setpoint, TIME_IMMEDIATE) == RDY_OK) {
//Pressure=Run_Pressure_Filter(Pressure);/* Square root raised cosine filter for low pass with minimal lag */
Pressure = Pressure<0?0.0:Pressure; /* A negative pressure is impossible with current hardware setup - disregard*/
Setpoint &= 0x000000FF;
/* The controller is built around an interpolated array of independant PID controllers with seperate setpoints */
if(Setpoint != Old_Setpoint) { /* The setpoint has changed */
Previous_Setpoint = Old_Setpoint;/* This is for use by the interpolator */
Old_Setpoint = Setpoint; /* Store the setpoint */
/* Store the time at which the interpolation to new setpoint completes*/
Interpolation_Timeout = time + (systime_t)( 4.0 / ((Pressure_Config_Type*)This_Config)->Interpolation_Base );
}
if(Interpolation_Timeout > time) { /* If we have an ongoing interpolation - note, operates in tick units */
/* Value goes from 1 to -1 */
float interpol = erff( (float)(Interpolation_Timeout - time) *\
((Pressure_Config_Type*)This_Config)->Interpolation_Base - 2.0 );/* erf function interpolator */
interpol = ( (-interpol + 1.0) / 2.0);/* Interpolation value goes from 0 to 1 */
PID_Out = ( Last_PID_Out[Previous_Setpoint] * (1.0 - interpol) ) + ( Last_PID_Out[Setpoint] * interpol );
Pressure_PID_Controllers[Setpoint].Last_Input = Pressure;/* Make sure the input to next PID controller is continuous */
}
else {
PID_Out = Run_PID_Loop( ((Pressure_Config_Type*)This_Config)->PID_Loop_Config, &Pressure_PID_Controllers[Setpoint],\
(((Pressure_Config_Type*)This_Config)->Setpoints)[Setpoint], \
Pressure, (float)PRESSURE_TIME_INTERVAL/1000.0);/* Run PID */
Last_PID_Out[Setpoint] = PID_Out;/* Store for use by the interpolator */
}
}
else
PID_Out=0; /* So we can turn off the solenoid simply by failing to send Setpoints */
PID_Out=PID_Out>1.0?1.0:PID_Out;
PID_Out=PID_Out<0.0?0.0:PID_Out; /* Enforce range limits on the PID output */
//sawtooth+=step; /* Test code for debugging mechanics with a sawtooth */
//if(sawtooth>=1 || sawtooth<=0.65)
// step=-step;
//PID_Out=sawtooth;
#ifndef USE_SERVO
/*
/ Now we apply the PID output to the PWM based solenoid controller, and feed data into the mailbox output - Note fractional input
*/
pwmEnableChannel(&PWM_Driver_Solenoid, (pwmchannel_t)PWM_CHANNEL_SOLENOID, (pwmcnt_t)PWM_FRACTION_TO_WIDTH(&PWM_Driver_Solenoid, 1000\
, (uint32_t)(1000.0*PID_Out)));
#else
pwmEnableChannel(&PWM_Driver_Servo, (pwmchannel_t)PWM_CHANNEL_SERVO, (pwmcnt_t)PWM_FRACTION_TO_WIDTH(&PWM_Driver_Servo, 10000\
, (uint32_t)(1000.0*(PID_Out+1.0))));
#endif
chMBPost(&Pressures_Reported, *((msg_t*)&Pressure), TIME_IMMEDIATE);/* Non blocking write attempt to the Reported Pressure mailbox FIFO */
/*
/ The Thread is syncronised to system time
*/
time += MS2ST(PRESSURE_TIME_INTERVAL); /* Next deadline */
chThdSleepUntil(time); /* Gives us a thread with regular timing */
}
}
TEST(math, erff) {
ASSERT_FLOAT_EQ(0.84270078f, erff(1.0f));
}
/*
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <assert.h>
#include "/home/piscioja/NRC/include/nr.h"
#include "/home/piscioja/halobias/bgc_read_utils.c"
#define sqr(x) ((x)*(x))
#define max(A,B) ((A) > (B) ? (A) : (B))
#define min(A,B) ((A) < (B) ? (A) : (B))
#define mabs(A) ((A) < 0.0 ? -(A) : (A))
#define cnint(x) ((x-floor(x)) < 0.5 ? floor(x) : ceil(x))
#define csign(x) (x < 0.0 ? -1 : 1)
#define PI (3.141592)
#define epsilon 1e-9
#define MAXLEN (5000)
int main()
{
double get_Mmin0(double , double , double , double , double , char* , char*);
double logMmin;
char bgc_file[MAXLEN],mf_file[MAXLEN];
snprintf(bgc_file,MAXLEN,"/net/bender/data0/LasDamas/Esmeralda/3011/fof_b0p2/Esmeralda_3011_z0p000_fof_b0p2.0000.bgc");
//snprintf(halos_file,MAXLEN,"/net/bender/data0/LasDamas/Consuelo/4004/Consuelo_4004_z0p054_fof_b0p2.com.halos");
snprintf(mf_file,MAXLEN,"/hd0/Research/Clustering/Emcee_test/3011_mass_function");
logMmin=get_Mmin0(0.0063,0.1,11.0,12.5,0.1,bgc_file,mf_file);
fprintf(stderr,"get_Mmin0> logMmin = %5.2f\n",logMmin) ;
return 0;
}
*/
double get_Mmin0(double rhogal, double siglogM, double logM0, double logM1, double alpha, char *bgc_file, char *mf_file)
{
fprintf(stderr,"In get_Min0\n");
int i,j ;
/*---Arguments-------------------------*/
double M0,M1 ;
FILE *fp1,*fp2 ;
/*---Halo-files------------------------*/
OUTPUT_HEADER hdr ;
int junki,Nhalos,Npart ;
double junkf,mp,Lbox,Mhalo,logMhalo ;
int Nbin,*Nhalosbin ;
double logMbin1,logMbin2,dlogMbin ;
/*---Bias-parameters-------------------*/
double logMh,Mh,Ncenavg,Nsatavg,Ngalaxies,Ngaltarget ;
double logMmin,fNgal ;
void Printhelp(void) ;
/*---Read-Arguments------------------------------------------------------------*/
M0=pow(10.,logM0) ;
M1=pow(10.,logM1) ;
/*---Read-BGC-header-----------------------------------------------------------*/
fp1=fopen(bgc_file,"r") ;
fprintf(stderr,"%s\n",bgc_file);
assert(fp1 != NULL);
bgc_read_header(fp1,&hdr);
fclose(fp1) ;
Nhalos=hdr.ngroups_total ;
mp=hdr.part_mass*1e10 ;
Lbox=hdr.BoxSize ;
Ngaltarget = rhogal*Lbox*Lbox*Lbox ;
/*---Read-halo-center-file-and-build-mass-function-----------------------------*/
logMbin1 = 10 ;
logMbin2 = 16 ;
dlogMbin = 0.01 ;
Nbin = (int)((logMbin2-logMbin1)/dlogMbin) ;
Nhalosbin=(int *) calloc(Nbin,sizeof(int)) ;
fp2=fopen(mf_file,"r") ;
fprintf(stderr,"%s\n",mf_file);
assert(fp2 != NULL);
for(i=0;i<Nbin;i++)
{
fscanf(fp2,"%lf %d",&junkf,&Nhalosbin[i]);
}
fclose(fp2);
/*---Loop-over-Mmin-values-------------------------------------------------------*/
logMmin = 8. ;
fNgal = 100. ;
i=0;
while(fNgal>1.01)
{
i++;
if(i>5E6)
{
fprintf(stderr,"Something has gone wrong with get_Mmin. Check HOD\n");
return -1;
}
logMmin += 0.01 ;
Ngalaxies = 0. ;
for(j=0;j<Nbin;j++)
{
if(Nhalosbin[j]>0)
{
logMh = logMbin1 + j*dlogMbin + 0.5*dlogMbin ;
Mh = pow(10.,logMh) ;
/*---Navg(M)--------------------------------------------------------------------*/
Ncenavg = 0.5*(1 + erff((logMh-logMmin)/siglogM)) ;
if(Mh>M0)
{
Nsatavg = 0.5*(1 + erff((logMh-logMmin)/siglogM))*pow(((Mh-M0)/M1),alpha) ;
}
else
{
Nsatavg = 0. ;
}
Ngalaxies += (Ncenavg + Nsatavg)*(double)Nhalosbin[j] ;
}
}
fNgal = Ngalaxies/Ngaltarget ;
}
fprintf(stderr,"get_Mmin0> logMmin = %5.2f\n",logMmin) ;
// fprintf(stdout,"%5.2f\n",logMmin) ;
return logMmin ;
}
static int testf(float float_x, long double long_double_x, /*float complex float_complex_x,*/ int int_x, long long_x)
{
int r = 0;
r += acosf(float_x);
r += acoshf(float_x);
r += asinf(float_x);
r += asinhf(float_x);
r += atan2f(float_x, float_x);
r += atanf(float_x);
r += atanhf(float_x);
/*r += cargf(float_complex_x); - will fight with complex numbers later */
r += cbrtf(float_x);
r += ceilf(float_x);
r += copysignf(float_x, float_x);
r += cosf(float_x);
r += coshf(float_x);
r += erfcf(float_x);
r += erff(float_x);
r += exp2f(float_x);
r += expf(float_x);
r += expm1f(float_x);
r += fabsf(float_x);
r += fdimf(float_x, float_x);
r += floorf(float_x);
r += fmaf(float_x, float_x, float_x);
r += fmaxf(float_x, float_x);
r += fminf(float_x, float_x);
r += fmodf(float_x, float_x);
r += frexpf(float_x, &int_x);
r += gammaf(float_x);
r += hypotf(float_x, float_x);
r += ilogbf(float_x);
r += ldexpf(float_x, int_x);
r += lgammaf(float_x);
r += llrintf(float_x);
r += llroundf(float_x);
r += log10f(float_x);
r += log1pf(float_x);
r += log2f(float_x);
r += logbf(float_x);
r += logf(float_x);
r += lrintf(float_x);
r += lroundf(float_x);
r += modff(float_x, &float_x);
r += nearbyintf(float_x);
r += nexttowardf(float_x, long_double_x);
r += powf(float_x, float_x);
r += remainderf(float_x, float_x);
r += remquof(float_x, float_x, &int_x);
r += rintf(float_x);
r += roundf(float_x);
#ifdef __UCLIBC_SUSV3_LEGACY__
r += scalbf(float_x, float_x);
#endif
r += scalblnf(float_x, long_x);
r += scalbnf(float_x, int_x);
r += significandf(float_x);
r += sinf(float_x);
r += sinhf(float_x);
r += sqrtf(float_x);
r += tanf(float_x);
r += tanhf(float_x);
r += tgammaf(float_x);
r += truncf(float_x);
return r;
}
__host__ void single_precision_math_functions()
{
int iX;
float fX, fY;
acosf(1.0f);
acoshf(1.0f);
asinf(0.0f);
asinhf(0.0f);
atan2f(0.0f, 1.0f);
atanf(0.0f);
atanhf(0.0f);
cbrtf(0.0f);
ceilf(0.0f);
copysignf(1.0f, -2.0f);
cosf(0.0f);
coshf(0.0f);
//cospif(0.0f);
//cyl_bessel_i0f(0.0f);
//cyl_bessel_i1f(0.0f);
erfcf(0.0f);
//erfcinvf(2.0f);
//erfcxf(0.0f);
erff(0.0f);
//erfinvf(1.0f);
exp10f(0.0f);
exp2f(0.0f);
expf(0.0f);
expm1f(0.0f);
fabsf(1.0f);
fdimf(1.0f, 0.0f);
//fdividef(0.0f, 1.0f);
floorf(0.0f);
fmaf(1.0f, 2.0f, 3.0f);
fmaxf(0.0f, 0.0f);
fminf(0.0f, 0.0f);
fmodf(0.0f, 1.0f);
frexpf(0.0f, &iX);
hypotf(1.0f, 0.0f);
ilogbf(1.0f);
isfinite(0.0f);
isinf(0.0f);
isnan(0.0f);
///j0f(0.0f);
///j1f(0.0f);
///jnf(-1.0f, 1.0f);
ldexpf(0.0f, 0);
///lgammaf(1.0f);
///llrintf(0.0f);
///llroundf(0.0f);
log10f(1.0f);
log1pf(-1.0f);
log2f(1.0f);
logbf(1.0f);
logf(1.0f);
///lrintf(0.0f);
///lroundf(0.0f);
modff(0.0f, &fX);
///nanf("1");
nearbyintf(0.0f);
//nextafterf(0.0f);
//norm3df(1.0f, 0.0f, 0.0f);
//norm4df(1.0f, 0.0f, 0.0f, 0.0f);
//normcdff(0.0f);
//normcdfinvf(1.0f);
//fX = 1.0f; normf(1, &fX);
powf(1.0f, 0.0f);
//rcbrtf(1.0f);
remainderf(2.0f, 1.0f);
remquof(1.0f, 2.0f, &iX);
//rhypotf(0.0f, 1.0f);
///rintf(1.0f);
//rnorm3df(0.0f, 0.0f, 1.0f);
//rnorm4df(0.0f, 0.0f, 0.0f, 1.0f);
//fX = 1.0f; rnormf(1, &fX);
roundf(0.0f);
//rsqrtf(1.0f);
///scalblnf(0.0f, 1);
scalbnf(0.0f, 1);
signbit(1.0f);
sincosf(0.0f, &fX, &fY);
//sincospif(0.0f, &fX, &fY);
sinf(0.0f);
sinhf(0.0f);
//sinpif(0.0f);
sqrtf(0.0f);
tanf(0.0f);
tanhf(0.0f);
tgammaf(2.0f);
truncf(0.0f);
///y0f(1.0f);
///y1f(1.0f);
///ynf(1, 1.0f);
}