//CALCULATES HANKEL FUNCTION AND DERIVATIVE USING STARTING VALUES FROM SMALL T EXPANSION AND SOLVING BESSELS EQUATION
void HankelH2(DOUBLE nu,DOUBLE xGoal,HankelPair &H2Goal){
//Starting point
DOUBLE xStart=DOUBLE(1.0);
HankelPair H2Start;
//Initialize at xStart using Series Expansion for small x
if(nu!=0){
H2Start.Value=HankelH2StartValue(COMPLEX(0,nu),COMPLEX(xStart,0));
H2Start.Derivative=HankelH2DerivativeStartValue(COMPLEX(0,nu),COMPLEX(xStart,0));
}
//For nu=0 use fixed values at x=1
else {
//STARTING VALUES AT x=1
xStart=DOUBLE(1.0);
//FIXED VALUES FROM MATHEMATICA
H2Start.Value=COMPLEX(0.76519769,-0.08825696);
H2Start.Derivative=COMPLEX(-0.44005059,-0.78121282);
}
//EVOLVE TO XGOAL
HankelH2Evolve(nu,xStart,H2Start,xGoal,H2Goal);
}
// get time when block of given size will be finished if started now
CTimerValue CBlockBufferStats::GetBlockFinalTime(SLONG slSize)
{
CTimerValue tvNow = _pTimer->GetHighPrecisionTimer();
// calculate how much should block be delayed due to latency and due to bandwidth
CTimerValue tvBandwidth;
if (bbs_fBandwidthLimit<=0.0f) {
tvBandwidth = CTimerValue(0.0);
} else {
tvBandwidth = CTimerValue(DOUBLE((slSize*8)/bbs_fBandwidthLimit));
}
CTimerValue tvLatency;
if (bbs_fLatencyLimit<=0.0f && bbs_fLatencyVariation<=0.0f) {
tvLatency = CTimerValue(0.0);
} else {
tvLatency = CTimerValue(DOUBLE(bbs_fLatencyLimit+(bbs_fLatencyVariation*rand())/RAND_MAX));
}
// start of packet receiving is later of
CTimerValue tvStart(
Max(
// current time plus latency and
(tvNow+tvLatency).tv_llValue,
// next free point in time
bbs_tvTimeUsed.tv_llValue));
// remember next free time and return it
bbs_tvTimeUsed = tvStart+tvBandwidth;
return bbs_tvTimeUsed;
}
// when can a certian ammount of data be sent?
CTimerValue CPacketBufferStats::GetPacketSendTime(SLONG slSize)
{
CTimerValue tvNow = _pTimer->GetHighPrecisionTimer();
// calculate how much should the packet be delayed due to latency and due to bandwidth
CTimerValue tvBandwidth;
if (pbs_fBandwidthLimit<=0.0f) {
tvBandwidth = CTimerValue(0.0);
} else {
tvBandwidth = CTimerValue(DOUBLE((slSize*8)/pbs_fBandwidthLimit));
}
CTimerValue tvLatency;
if (pbs_fLatencyLimit<=0.0f && pbs_fLatencyVariation<=0.0f) {
tvLatency = CTimerValue(0.0);
} else {
tvLatency = CTimerValue(DOUBLE(pbs_fLatencyLimit+(pbs_fLatencyVariation*rand())/RAND_MAX));
}
// time when the packet should be sent is max of
CTimerValue tvStart(
Max(
// current time plus latency and
(tvNow+tvLatency).tv_llValue,
// next free point in time
pbs_tvTimeNextPacketStart.tv_llValue));
// remember next free time and return it
pbs_tvTimeNextPacketStart = tvStart+tvBandwidth;
return pbs_tvTimeNextPacketStart;
};
const DOUBLE getAdjustedTimingFrequency( ) {
LARGE_INTEGER timingFrequency;
BOOL res1 = QueryPerformanceFrequency( &timingFrequency );
if ( !res1 ) {
fwprintf( stderr, L"QueryPerformanceFrequency failed!!!!!! Disregard any timing data!!\r\n" );
}
const DOUBLE adjustedTimingFrequency = ( DOUBLE( 1.00 ) / DOUBLE( timingFrequency.QuadPart ) );
return adjustedTimingFrequency;
}
int main(void)
{
printf("%d\n", DOUBLE(1 + 2)); //should be 2 * 1 + 2 = 4
printf("%d\n", 4 / DOUBLE(2)); //should be 4 / 2 * 2 = 4
#undef DOUBLE
#define DOUBLE(x) (2 * (x))
printf("%d\n", DOUBLE(1 + 2)); //should be 6
printf("%d\n", 4 / DOUBLE(2)); //should be 1
}
// COMPUTE EMid= -i SUNcLog(UNew.UOldDagger) AND UMid=exp( i EMid*c) UOld //
void GeodesicInterpolation(DOUBLE c,SU_Nc_FUNDAMENTAL_FORMAT *UOld,SU_Nc_FUNDAMENTAL_FORMAT *UNew,SU_Nc_FUNDAMENTAL_FORMAT *UMid,SU_Nc_ALGEBRA_FORMAT *EMid){
SU_Nc_FUNDAMENTAL_FORMAT Buffer[SUNcGroup::MatrixSize];
SUNcGroup::Operations::UD(UNew,UOld,Buffer);
SUNcAlgebra::Operations::MatrixILog(-DOUBLE(1.0),Buffer,EMid);
SUNcAlgebra::Operations::MatrixIExp(-DOUBLE(c),EMid,Buffer);
SUNcGroup::Operations::UU(Buffer,UOld,UMid);
}
std::string toString(){
DOUBLE FullExponent=order/log(DOUBLE(10.0));
INT IntExponent=floor(FullExponent);
COMPLEX val=number*pow(DOUBLE(10.0),FullExponent-IntExponent);
std::stringstream ss;
ss << "(" << real(val) << "," << imag(val) << ")E" << IntExponent;
return ss.str();
}
HRESULT CGraphics::UpdateTimer(void)
{
LONGLONG time;
if(!QueryPerformanceCounter((PLARGE_INTEGER)&time))
return E_FAIL;
// Calculate the elapsed time
m_TimerElapsed = DOUBLE(time - m_TimerLast) / DOUBLE(m_TimerFrequency) * DOUBLE(m_TimerFrameRate);
m_TimerAbsolute += m_TimerElapsed;
m_TimerLast = time;
return S_OK;
}
int main(void)
{
int x = DOUBLE(5) * 3;
printf("x: %d\n", x);
x = DOUBLE_impr(5) * 3;
printf("x: %d\n", x);
x = 3;
int y = DOUBLE(++x);
/* y = ( (++x) + (++x) ) */
printf("y: %d\n", y);
return 0;
}
void KDialogP::UpdateTemperature()
{
SOUNDSETTING setting;
KCLastMemory::GetInstance()->GetSoundMemory(setting);
if (setting.uAutoAir)
{
// 换算公式 F=(C×9/5)+32 ;
// C=(F-32)×5/9 ;式中F--华氏温度,C--摄氏温度 ·
WCHAR wcsTemperature[16] = {0};
DOUBLE dbTemperature = DOUBLE(setting.uOutdoorTemperature)/2 - 35;
// 1 : 摄氏温度 2：华氏温度
if (2 == setting.uTemperature)
{
swprintf(wcsTemperature, L"%.1f℉", (dbTemperature*9/5+32));
}
else
{
swprintf(wcsTemperature, L"%.1f℃", dbTemperature);
}
SAFECALL(m_pTxtTemperature)->SetText(wcsTemperature);
SAFECALL(m_pTxtTemperature)->SetShow(true);
}
else
{
SAFECALL(m_pTxtTemperature)->SetShow(false);
}
}
void CSoundSourceFMod::UpdateVolume()
{
// only if channel active
if(_FModChannel==-1)
return;
float fGain = CSoundSystemFMod::GetMe()->GetTypeVolume(GetType());
//3D模式
if(_b3DMode)
{
//得到与听者距离平方
FLOAT fDistanceSQR = TDU_GetDistSq(GetPos(), CSoundSystemFMod::GetMe()->Listener_GetPos());
//计算声音分贝
INT nVolumeDB= INT(floor(2000.0 * log10(fGain))); // convert to 1/100th decibels
const static INT s_nDBMin= -10000;
const static INT s_nDBMax= 0;
TDU_Clamp(nVolumeDB, s_nDBMin, s_nDBMax);
//根据距离计算音量
nVolumeDB= _ComputeManualRollOff(nVolumeDB, s_nDBMin, s_nDBMax, _Alpha, fDistanceSQR);
//计算线性值
DOUBLE dAttGain= pow((DOUBLE)10.0, DOUBLE(nVolumeDB)/2000.0);
TDU_Clamp(dAttGain, 0.0f, 1.0f);
FSOUND_SetVolume(_FModChannel, UINT(dAttGain*255));
}
else
{
FSOUND_SetVolume(_FModChannel, UINT(fGain*255));
}
}
// MEASURE PEAK STRESS //
void MeasurePeakStress(INT xLow,INT xHigh,INT yLow,INT yHigh,INT zLow,INT zHigh,GaugeLinks *U,GaugeTransformations *S){
DOUBLE MaxStress=0.0;
#pragma omp parallel
{
#pragma omp for reduction(max : MaxStress)
for(INT z=zLow;z<=zHigh;z++){
for(INT y=yLow;y<=yHigh;y++){
for(INT x=xLow;x<=xHigh;x++){
// DEFINE LOCAL STRESS //
DOUBLE LocalStress=DOUBLE(0.5)*(SUNcGroup::Operations::ReTrIDMinusU(EnslavedFields::U->Get(x,y,z,0))+SUNcGroup::Operations::ReTrIDMinusU(EnslavedFields::U->Get(x,y,z,1))+SUNcGroup::Operations::ReTrIDMinusU(EnslavedFields::U->Get(x,y,z,2))+SUNcGroup::Operations::ReTrIDMinusU(EnslavedFields::U->Get(x-1,y,z,0))+SUNcGroup::Operations::ReTrIDMinusU(EnslavedFields::U->Get(x,y-1,z,1))+SUNcGroup::Operations::ReTrIDMinusU(EnslavedFields::U->Get(x,y,z-1,2)));
// TEST FOR SUPREMUM //
MaxStress=std::max(LocalStress,MaxStress);
}
}
}
}// END PARALLEL
// SET GLOBAL PEAKSTRESS //
PeakStress=MaxStress;
}
void Output(std::string fname){
std::ofstream OutStream;
OutStream.open(fname.c_str());
OutStream << "#xLow=" << xLow << " xHigh=" << xHigh << " DeltaX=" << DeltaX << " NBins=" << NBins << std::endl;
OutStream << "#TOTALCOUNTS=" << TotalCounts << " UNCOUNTED=" << OutOfRange << std::endl;
for(INT i=0;i<NBins;i++){
if(Counts[i]>0){
OutStream << xValues[i]/Counts[i];
for(INT j=0;j<NumberOfObservables;j++){
OutStream << " " << yValues[NumberOfObservables*i+j]/Counts[i];
}
OutStream << " " << Counts[i]/DOUBLE(TotalCounts+OutOfRange) << std::endl;
}
}
OutStream.close();
}
// does "snap to grid" for given coordinate
void Snap( DOUBLE &fDest, DOUBLE fStep)
{
// this must use floor() to get proper snapping of negative values.
DOUBLE fDiv = fDest/fStep;
DOUBLE fRound = fDiv + 0.5f;
DOUBLE fSnap = DOUBLE(floor(fRound));
DOUBLE fRes = fSnap * fStep;
fDest = fRes;
}
void Power(SU_Nc_FUNDAMENTAL_FORMAT *V,SU_Nc_FUNDAMENTAL_FORMAT *Vm,DOUBLE m){
SU_Nc_ALGEBRA_FORMAT logV[SUNcAlgebra::VectorSize];
SUNcAlgebra::Operations::MatrixILog(DOUBLE(1.0),V,logV);
SUNcAlgebra::Operations::MatrixIExp(m,logV,Vm);
}
/**
* im_contrast_surface:
* @in: input image
* @out: output image
* @half_win_size: window radius
* @spacing: subsample output by this
*
* Generate an image where the value of each pixel represents the
* contrast within a window of half_win_size from the corresponsing
* point in the input image. Sub-sample by a factor of spacing.
*
* See also: im_spcor(), im_gradcor().
*
* Returns: 0 on success, -1 on error.
*/
int
im_contrast_surface (IMAGE * in, IMAGE * out, int half_win_size, int spacing)
{
IMAGE *t1 = im_open_local (out, "im_contrast_surface intermediate", "p");
if (!t1
|| im_embed (in, t1, 1, half_win_size, half_win_size,
in->Xsize + DOUBLE (half_win_size),
in->Ysize + DOUBLE (half_win_size))
|| im_contrast_surface_raw (t1, out, half_win_size, spacing))
return -1;
out->Xoffset = 0;
out->Yoffset = 0;
return 0;
}
//Computes sin(z) in smart complex format
SmartComplex sine(COMPLEX z){
SmartComplex res;
res.number=COMPLEX(sin(real(z)),tanh(imag(z))*cos(real(z)));
//USE COMPLETE log(cosh(x)) ONLY FOR x<10
if(abs(imag(z))<DOUBLE(10.0)){
res.order=log(cosh(imag(z)));
}
//ELSE USE log(cosh(x))~Abs[x]-log[2] (ABSOLUTE ERROR IS SMALLER THAN 1e-9 for |x|>10)
else {
res.order=abs(imag(z))-log(DOUBLE(2.0));
}
return res;
}
//STARTING VALUE FOR ODE
COMPLEX HankelH2StartValue(COMPLEX nu,COMPLEX z){
//Calculate Normalized value including exp(pi nu/2) factor
SmartComplex Value=SmartComplexFunctions::exponential(DOUBLE(0.5)*PI*imag(nu))*HankelH2Series(nu,z);
//Cast to complex number
return Value.number*exp(Value.order);
}
TMath::DOUBLE TMath::asin(DOUBLE x)
{
x = mod(x + 1, 2) - 1;
DOUBLE r = 0;
for (LONG n = 0; n <= 8L; n++)
{
r += fac(2 * n) / (pow(DOUBLE(2), 2 * n) * pow(fac(n), 2) * (2 * n + 1)) * pow(x, 2 * n + 1);
}
return r;
}
void
_fp_pack_extword(
fp_simd_type *pfpsd, /* Pointer to simulator data */
uint64_t *pu, /* unpacked operand */
uint_t n) /* register where datum starts */
{
if ((n & 1) == 1) /* fix register encoding */
n = (n & 0x1e) | 0x20;
pfpsd->fp_current_write_dreg(pu, DOUBLE(n), pfpsd);
}
// calculate the number of roots, given the number of levels
void TaxPar::calc_values(void)
{
LINT nset;
nset = 0;
nset += (nlevels != 0);
nset += (fanout != 0);
nset += (nroots != 0);
switch (nset)
{
case 0: // fill in defaults
nroots = 250;
fanout = 5;
return;
case 1: // need to fill in 1 value
assert (nlevels == 0);
if (fanout == 0)
fanout = 5;
else if (nroots == 0)
nroots = 250;
return;
case 2:
if (nlevels == 0) // all set!
return;
if (fanout != 0) { // calculate nroots
nroots = nitems / (1 + pow(DOUBLE(fanout), DOUBLE(nlevels-1)));
if (nroots < 1)
nroots = 1;
}
else if (nroots != 0) { // calculate fanout
FLOAT temp;
temp = (FLOAT)nitems / nroots - 1;
temp = log((DOUBLE)temp) / (nlevels - 1);
fanout = exp((DOUBLE)temp);
}
case 3: // all set!
return;
}
}
int
im_contrast_surface_raw (IMAGE * in, IMAGE * out, int half_win_size,
int spacing)
{
#define FUNCTION_NAME "im_contrast_surface_raw"
cont_surf_params_t *params;
if (im_piocheck (in, out) ||
im_check_uncoded (FUNCTION_NAME, in) ||
im_check_mono (FUNCTION_NAME, in) ||
im_check_format (FUNCTION_NAME, in, IM_BANDFMT_UCHAR))
return -1;
if (half_win_size < 1 || spacing < 1)
{
im_error (FUNCTION_NAME, "%s", _("bad parameters"));
return -1;
}
if (DOUBLE (half_win_size) >= LESSER (in->Xsize, in->Ysize))
{
im_error (FUNCTION_NAME,
"%s", _("parameters would result in zero size output image"));
return -1;
}
params = IM_NEW (out, cont_surf_params_t);
if (!params)
return -1;
params->half_win_size = half_win_size;
params->spacing = spacing;
if (im_cp_desc (out, in))
return -1;
out->BandFmt = IM_BANDFMT_UINT;
out->Xsize = 1 + ((in->Xsize - DOUBLE_ADD_ONE (half_win_size)) / spacing);
out->Ysize = 1 + ((in->Ysize - DOUBLE_ADD_ONE (half_win_size)) / spacing);
out->Xoffset = -half_win_size;
out->Yoffset = -half_win_size;
if (im_demand_hint (out, IM_FATSTRIP, in, NULL))
return -1;
return im_generate (out, im_start_one, cont_surf_gen, im_stop_one, in,
params);
#undef FUNCTION_NAME
}
int get_args(tree* my_tree, double* argv, const int argc)
{
assert(my_tree);
assert(argv);
assert(argc > 0);
tree* temp_tree = my_tree -> right;
int i = 0;
for (i = 0; i < argc - 1; ++i)
{
assert(temp_tree -> left);
argv[i] = DOUBLE(temp_tree -> left);
assert(temp_tree -> right);
temp_tree = temp_tree -> right;
}
argv[i] = DOUBLE(temp_tree);
return TREE_OK;
}
DOUBLE UnitarityNorm(SU_Nc_FUNDAMENTAL_FORMAT *V){
SU_Nc_FUNDAMENTAL_FORMAT C[SUNcGroup::MatrixSize];
SUNcGroup::Operations::UD(V,V,C);
DOUBLE Norm=DOUBLE(0.0);
for(int alpha=0;alpha<SUNcGroup::MatrixSize;alpha++){
Norm+=SQR(C[alpha]-SUNcGroup::UnitMatrix[alpha]);
}
return sqrt(Norm);
}
LPTSTR Unit2String( LFIXED Fixed, LPTSTR lpFixed )
{
long points, picas;
double d;
switch ( Units )
{
case UT_MM:
d = (DOUBLE(Fixed) * (double)25.4);
DoubleToString(d, lpFixed, 2);
break;
case UT_PICAS:
// d is now in points
d = (DOUBLE(Fixed) * (double)Points)/10.0;
points = (long)(d + 0.5);
picas = points/12L;
points -= (picas*12L);
wsprintf(lpFixed, "%ld,%ld", picas, points);
break;
case UT_CM:
d = (DOUBLE(Fixed) * (double)2.54);
DoubleToString(d, lpFixed, 3);
break;
case UT_PIXELS:
d = (DOUBLE(Fixed) * (double)UnitRes);
DoubleToString(d, lpFixed, 0);
break;
case UT_INCHES:
default:
FixedAscii( Fixed, lpFixed, 3 );
break;
}
return( lpFixed );
}
void genGateKeeperApprovedAppRow(sqlite3_stmt* const stmt, Row& r) {
for (int i = 0; i < sqlite3_column_count(stmt); i++) {
auto column_name = std::string(sqlite3_column_name(stmt, i));
auto column_type = sqlite3_column_type(stmt, i);
if (column_type == SQLITE_TEXT) {
auto value = sqlite3_column_text(stmt, i);
if (value != nullptr) {
r[column_name] = std::string(reinterpret_cast<const char*>(value));
}
} else if (column_type == SQLITE_FLOAT) {
auto value = sqlite3_column_double(stmt, i);
r[column_name] = DOUBLE(value);
}
}
}
void CKmlLoader::packet_1002(const unsigned real_sequence, const unsigned sequence, const QMap<QString, QVariant> content)
{
#define LON_LAT(name)\
QString::number(content[name].toDouble() / M_PI * 180, 'g', 11)
#define DOUBLE(name)\
QString::number(content[name].toDouble(), 'g', 11)
const QString field = QString("%1,%2,%3\n")
.arg(LON_LAT("longitude"))
.arg(LON_LAT("latitude"))
.arg(DOUBLE("altitude"));
stream.writeCharacters(field);
}
/* layer 3 */
static DOUBLE anfisAndOrNode(FIS *fis, int index, char *action, int index2)
{
DOUBLE *input = fis->node[index]->input;
int which_rule = fis->node[index]->l_index;
int and_or = fis->and_or[which_rule];
DOUBLE (*AndOrFcn)() = and_or == 1? fis->andFcn:fis->orFcn;
int i;
anfisSetupInputArray(fis, index);
if (strcmp(action, "forward") == 0) {
fis->node[index]->tmp =
fisArrayOperation(input, fis->node[index]->fanin_n,
AndOrFcn);
return(fis->node[index]->tmp);
}
if (strcmp(action, "backward") == 0) {
if ((AndOrFcn == fisMin) || (AndOrFcn == fisMax)) {
for (i = 0; i < fis->node[index]->fanin_n; i++)
if (fis->node[index]->tmp == input[i])
break;
return(index2 == i? 1.0:0.0);
}
if (AndOrFcn == fisProduct) {
DOUBLE product = 1.0;
for (i = 0; i < fis->node[index]->fanin_n; i++) {
if (i == index2)
continue;
product *= input[i];
}
return(product);
}
if (AndOrFcn == fisProbOr) {
DOUBLE product = 1.0;
for (i = 0; i < fis->node[index]->fanin_n; i++) {
if (i == index2)
continue;
product *= (1 - input[i]);
}
return(product);
}
}
if (strcmp(action, "parameter") == 0)
return(0.0);
fisError("Unknown action!\n");
return(0); /* for suppressing compiler's warning only */
}
int main (int argc, char *argv[])
{
int i;
double r,g,b;
printf ("The colormap %d is \"%s\".\n", AX_CMAP_IDX,
AX_cmap_funs[AX_CMAP_IDX].name);
printf ("Compare the following printout with Matlab function\n"
"fprintf(1,'%%5d %%9.4f %%9.4f %%9.4f\\n',"
"[(1:%d)' %s(%d)]')\n\n",
M, AX_cmap_funs[AX_CMAP_IDX].name, M);
for (i=1; i<=M; i++)
{
AX_cmap (AX_CMAP_IDX, DOUBLE(i)/M, &r, &g, &b);
printf ("%5d %9.4f %9.4f %9.4f\n", i, r, g, b);
}
return (0);
}
namespace ChernSimonsNumber{
///////////
// NAIVE //
///////////
// DELTA NCS ALONG THE ORIGINAL TRAJECTORY //
DOUBLE DeltaNCsRealTime=DOUBLE(0.0);
/////////////
// COOLING //
/////////////
// DELTA NCS REAL-TIME ALONG STANDARD COOL PATH //
DOUBLE DeltaNCsCoolRealTime=DOUBLE(0.0);
// DELTA NCS ALONG COOLING PATH //
DOUBLE DeltaNCsCooling=DOUBLE(0.0);
/////////////////
// CALIBRATION //
/////////////////
// DELTA NCS BETWEEN STANDARD COOL PATH AND VACUUM //
DOUBLE DeltaNCsCalibration=DOUBLE(0.0); DOUBLE DeltaNCsPreviousCalibration=DOUBLE(0.0);
// DELTA NCS IN REAL TIME ALONG THE STANDARD COOLING PATH AT TIME OF CALIBRATION //
DOUBLE DeltaNCsRealTimeCalibration=DOUBLE(0.0); DOUBLE DeltaNCsRealTimePreviousCalibration=DOUBLE(0.0);
DOUBLE NCsDot(GaugeLinks *U,ElectricFields *E){
DOUBLE EDotB;
////////////////////////////////////////
// COMPUTE VOLUME INTEGRAL OF tr[E.B] //
////////////////////////////////////////
// OPTION TO USE UNIMPROVED OPERATORS //
//EDotB=UnimprovedOperators::ComputeEDotB(U,E);
// END OPTION //
// OPTION TO USE IMPROVED OPERATORS //
EDotB=ImprovedOperators::ComputeEDotB(U,E);
// END OPTION //
return DOUBLE(0.125)*EDotB/SQR(PI);
}
}