float pcl::RangeImageNew::ComputeAngularResolutionWidth(CloudType::ConstPtr cloud)
{
float total_angle = 0.0f;
unsigned int valid_angle_counter = 0;
// Traverse the grid in pairs of a point and the point to the right of it.
for(unsigned int col = 0; col < cloud->width - 1; ++col) // (width - 1) because there is no point to the right of the last column!
{
for(unsigned int row = 0; row < cloud->height; ++row)
{
CloudType::PointType p0 = (*cloud)(col, row);
CloudType::PointType p1 = (*cloud)(col + 1, row);
if(IsNan(p0) || IsNan(p1))
{
continue;
}
else
{
total_angle = AngleBetweenPointVectors(p0, p1);
valid_angle_counter++;
}
}
}
float average_angle = total_angle/static_cast<float>(valid_angle_counter);
return average_angle;
}
void CCalculator::CalculateTwoOperandsFunction(SFunctionData & fnInfo)
{
double firstOperand = GetValue(fnInfo.firstOperand);
double secondOperand = GetValue(fnInfo.secondOperand);
if (!IsNan(firstOperand) && !IsNan(secondOperand))
{
double result = std::numeric_limits<double>::quiet_NaN();
switch (fnInfo.operatorType)
{
case Operator::Plus:
result = firstOperand + secondOperand;
break;
case Operator::Slash:
result = firstOperand / secondOperand;
break;
case Operator::Star:
result = firstOperand * secondOperand;
break;
case Operator::Minus:
result = firstOperand - secondOperand;
break;
}
fnInfo.value = result;
}
}
inline void ApplyPower<false>(float * pix, const float * power)
{
// Note: Set NaNs to 0 to match the SSE path.
pix[0] = IsNan(pix[0]) ? 0.0f : (pix[0]<0.f ? pix[0] : powf(pix[0], power[0]));
pix[1] = IsNan(pix[1]) ? 0.0f : (pix[1]<0.f ? pix[1] : powf(pix[1], power[1]));
pix[2] = IsNan(pix[2]) ? 0.0f : (pix[2]<0.f ? pix[2] : powf(pix[2], power[2]));
}
void FDrawPointer::draw(Qwt3D::Triple const& pos)
{
if(IsNan(Pointer->x) || IsNan(Pointer->y)) return;
if(pos.x == Pointer->x && pos.y == Pointer->y)
{
double PtsSize = (((plot->hull().maxVertex - plot->hull().minVertex).length())/plot->hull().maxVertex.length())*10;
//É preciso salvar o status de tamanho anterior pra não dar erro na projeção de curvas (Isoline projections).
GLfloat _SizePrevious;
glGetFloatv(GL_POINT_SIZE, &_SizePrevious);
glPointSize(PtsSize);
glEnable(GL_POINT_SMOOTH);
glColor3d(1, 1, 0); // Yellow
glBegin(GL_POINTS);
glVertex3d(pos.x,pos.y,pos.z);
glEnd();
//Retomando o status anterior as mudanças.
glDisable(GL_POINT_SMOOTH);
glPointSize(_SizePrevious);
}
}
// This is the 'final' version of the AlmostEqualUlps function.
// The optional checks are included for completeness, but in many
// cases they are not necessary, or even not desirable.
bool AlmostEqualUlpsFinal(float A, float B, int maxUlps)
{
// There are several optional checks that you can do, depending
// on what behavior you want from your floating point comparisons.
// These checks should not be necessary and they are included
// mainly for completeness.
#ifdef INFINITYCHECK
// If A or B are infinity (positive or negative) then
// only return true if they are exactly equal to each other -
// that is, if they are both infinities of the same sign.
// This check is only needed if you will be generating
// infinities and you don't want them 'close' to numbers
// near FLT_MAX.
if (IsInfinite(A) || IsInfinite(B))
return A == B;
#endif
#ifdef NANCHECK
// If A or B are a NAN, return false. NANs are equal to nothing,
// not even themselves.
// This check is only needed if you will be generating NANs
// and you use a maxUlps greater than 4 million or you want to
// ensure that a NAN does not equal itself.
if (IsNan(A) || IsNan(B))
return false;
#endif
#ifdef SIGNCHECK
// After adjusting floats so their representations are lexicographically
// ordered as twos-complement integers a very small positive number
// will compare as 'close' to a very small negative number. If this is
// not desireable, and if you are on a platform that supports
// subnormals (which is the only place the problem can show up) then
// you need this check.
// The check for A == B is because zero and negative zero have different
// signs but are equal to each other.
if (Sign(A) != Sign(B))
return A == B;
#endif
int aInt = *(int*)&A;
// Make aInt lexicographically ordered as a twos-complement int
if (aInt < 0)
aInt = 0x80000000 - aInt;
// Make bInt lexicographically ordered as a twos-complement int
int bInt = *(int*)&B;
if (bInt < 0)
bInt = 0x80000000 - bInt;
// Now we can compare aInt and bInt to find out how far apart A and B
// are.
int intDiff = abs(aInt - bInt);
if (intDiff <= maxUlps)
return true;
return false;
}
// Calculate high pressure rate coefficients at current T.
void IrreversibleUnimolecularReaction::HighPresRateCoeffs(vector<double> *pCoeffs) {
vector<double> rctGrainDOS, rctGrainEne;
m_rct1->getDOS().getGrainDensityOfStates(rctGrainDOS);
m_rct1->getDOS().getGrainEnergies(rctGrainEne);
const size_t MaximumGrain = (getEnv().MaxGrn-get_fluxFirstNonZeroIdx());
const double beta = getEnv().beta;
double kf(0.0);
for(size_t i(0); i < MaximumGrain; ++i)
kf += m_GrainKfmc[i] * exp( log(rctGrainDOS[i]) - beta * rctGrainEne[i]);
const double rctprtfn = canonicalPartitionFunction(rctGrainDOS, rctGrainEne, beta);
//printf("temperature: %f\ttsprtfn: %f\trctprtfn: %f\n",1/beta/boltzmann_RCpK, kf, rctprtfn);
ctest << "temperature, tsprtfn, rctprtfn: " << 1.0/beta/boltzmann_RCpK << " " << kf << " " << rctprtfn << endl;
kf /= rctprtfn;
if (pCoeffs) {
pCoeffs->push_back(kf) ;
const double Keq = calcEquilibriumConstant() ;
if(!IsNan(Keq)) {
pCoeffs->push_back(kf/Keq) ;
pCoeffs->push_back(Keq) ;
}
} else {
const double temperature = 1./(boltzmann_RCpK * beta);
ctest << endl << "Canonical pseudo first order forward rate constant of irreversible reaction "
<< getName() << " = " << kf << " s-1 (" << temperature << " K)" << endl;
}
}
Color Color::FromString(const char *str)
{
assume(str);
if (!str)
return Color();
MATH_SKIP_WORD(str, "Color");
MATH_SKIP_WORD(str, "(");
Color c;
// Use DeserializeFloat() instead of duplicating its code but comply
// with the old strtod behavior where 0 is used on conversion failure.
c.r = DeserializeFloat(str, &str); if (IsNan(c.r)) c.r = 0.f;
c.g = DeserializeFloat(str, &str); if (IsNan(c.g)) c.g = 0.f;
c.b = DeserializeFloat(str, &str); if (IsNan(c.b)) c.b = 0.f;
if (str && *str != '\0') // alpha optional
{
c.a = DeserializeFloat(str, &str);
if (IsNan(c.a)) c.a = 01.f;
}
return c;
}
float pcl::RangeImageNew::ComputeMaxAngleHeight(CloudType::ConstPtr cloud)
{
// Compute the average of the angle between extreme points
float total_angle = 0.0f;
unsigned int valid_angle_counter = 0;
for(unsigned int col = 0; col < cloud->width; ++col)
{
CloudType::PointType p0 = (*cloud)(col, 0);
CloudType::PointType p1 = (*cloud)(col, cloud->height - 1);
if(IsNan(p0) || IsNan(p1))
{
continue;
}
else
{
total_angle = AngleBetweenPointVectors(p0, p1);
valid_angle_counter++;
}
}
float average_angle = total_angle/static_cast<float>(valid_angle_counter);
return average_angle;
}
bool AABB::IsDegenerate() const
{
#ifdef _MSC_VER
// MSVC generates code that assumes nans can't be present - add an explicit check for that case.
return IsNan(minPoint.x) || IsNan(minPoint.y) || IsNan(minPoint.z) ||
IsNan(maxPoint.x) || IsNan(maxPoint.y) || IsNan(maxPoint.z) ||
!(minPoint.x < maxPoint.x && minPoint.y < maxPoint.y && minPoint.z < maxPoint.z);
#else
return !(minPoint.x < maxPoint.x && minPoint.y < maxPoint.y && minPoint.z < maxPoint.z);
#endif
}
char *SerializeFloat(float f, char *dstStr)
{
if (!IsNan(f))
{
#ifdef MATH_WITH_GRISU3
int numChars = dtoa_grisu3((double)f, dstStr);
return dstStr + numChars;
#else
return dstStr + sprintf(dstStr, "%.17g", f);
#endif
}
else
{
u32 u = ReinterpretAsU32(f);
int numChars = sprintf(dstStr, "NaN(%8X)", (unsigned int)u);
return dstStr + numChars;
}
}
static inline void BinarizeFloatFeature(int featureIdx,
const TDocumentStorage& docStorage,
const TDocSelector& docSelector,
const TVector<float>& borders,
ENanMode nanMode,
NPar::TLocalExecutor& localExecutor,
int floatFeatureIdx,
TAllFeatures* features,
bool* seenNans) {
size_t docCount = docSelector.GetDocCount();
const TVector<float>& src = docStorage.Factors[featureIdx];
TVector<ui8>& hist = features->FloatHistograms[floatFeatureIdx];
hist.resize(docCount);
ui8* histData = hist.data();
const float* featureBorderData = borders.data();
const int featureBorderSize = borders.ysize();
localExecutor.ExecRange([&] (int i) {
const auto& featureVal = src[docSelector(i)];
if (IsNan(featureVal)) {
*seenNans = true;
histData[i] = nanMode == ENanMode::Min ? 0 : featureBorderSize;
} else {
int j = 0;
while (j < featureBorderSize && featureVal > featureBorderData[j]) {
++histData[i];
++j;
}
// histData[i] = LowerBound(featureBorderData, featureBorderData + featureBorderSize, featureVal) - featureBorderData;
}
}
, NPar::TLocalExecutor::TExecRangeParams(0, docCount).SetBlockSize(1000)
, NPar::TLocalExecutor::WAIT_COMPLETE);
}
void CXTPMarkupGrid::SetFinalSize(CXTPMarkupDefinitionCollection* pDefinitions, int finalSize)
{
CXTPMarkupDefinitionBase** pTempDefinitions = new CXTPMarkupDefinitionBase*[pDefinitions->GetCount()];
int length = 0;
int num2 = pDefinitions->GetCount();
double num3 = 0;
for (int i = 0; i < pDefinitions->GetCount(); i++)
{
CXTPMarkupDefinitionBase* pDefinition = pDefinitions->GetItem(i);
if (pDefinition->GetUserSize()->IsStar())
{
pTempDefinitions[length++] = pDefinition;
double d = pDefinition->GetUserSize()->GetValue();
if (d == 0)
{
pDefinition->m_nMeasureSize = 0;
pDefinition->m_nSizeCache = 0;
}
else
{
pDefinition->m_nMeasureSize = d;
int num6 = IsNan(pDefinition->GetUserMaxSize()) ? pDefinition->m_nMinSize : max(pDefinition->m_nMinSize, pDefinition->GetUserMaxSize());
pDefinition->m_nSizeCache = (double)num6 / (double)d;
}
}
else
{
pTempDefinitions[--num2] = pDefinition;
double nMinSizeForArrange = 0;
switch (pDefinition->GetUserSize()->GetUnitType())
{
case CXTPMarkupGridLength::unitTypeAuto:
nMinSizeForArrange = pDefinition->m_nMinSize;
break;
case CXTPMarkupGridLength::unitTypePixel:
nMinSizeForArrange = pDefinition->GetUserSize()->GetValue();
break;
}
int nUserMaxSize = pDefinition->GetUserMaxSize();
pDefinition->m_nSizeCache = max(pDefinition->m_nMinSize, min(nMinSizeForArrange, nUserMaxSize));
num3 += pDefinition->m_nSizeCache;
}
}
if (length > 0)
{
qsort(pTempDefinitions, length, sizeof(CXTPMarkupDefinitionBase*), StarDistributionOrderComparer);
double num9 = 0;
int nIndex;
for (nIndex = length - 1; nIndex >= 0; nIndex--)
{
num9 += pTempDefinitions[nIndex]->m_nMeasureSize;
pTempDefinitions[nIndex]->m_nSizeCache = num9;
}
for (nIndex = 0; nIndex < length; nIndex++)
{
CXTPMarkupDefinitionBase* pDefinition = pTempDefinitions[nIndex];
int num11;
double nMeasureSize = pDefinition->m_nMeasureSize;
if (nMeasureSize == 0)
{
num11 = pDefinition->m_nMinSize;
}
else
{
double num13 = max((double) (finalSize - num3), (double) 0) * (nMeasureSize / pDefinition->m_nSizeCache);
num11 = min((int)num13, pDefinition->GetUserMaxSize());
num11 = max(pDefinition->m_nMinSize, num11);
}
pDefinition->m_nSizeCache = num11;
num3 += num11;
}
}
if (num3 > finalSize)
{
qsort(pTempDefinitions, length, sizeof(CXTPMarkupDefinitionBase*), DistributionOrderComparer);
double num14 = finalSize - num3;
for (int k = 0; k < pDefinitions->GetCount(); k++)
{
double num16 = pTempDefinitions[k]->m_nSizeCache + (num14 / ((double) (pDefinitions->GetCount() - k)));
num16 = min(max(num16, pTempDefinitions[k]->m_nMinSize), pTempDefinitions[k]->m_nSizeCache);
num14 -= num16 - pTempDefinitions[k]->m_nSizeCache;
pTempDefinitions[k]->m_nSizeCache = num16;
}
}
pDefinitions->GetItem(0)->m_nFinalOffset = 0;
for (int j = 1; j < pDefinitions->GetCount(); j++)
{
pDefinitions->GetItem(j)->m_nFinalOffset = pDefinitions->GetItem(j - 1)->m_nFinalOffset + (int)pDefinitions->GetItem(j - 1)->m_nSizeCache;
}
delete[] pTempDefinitions;
}
static void OutputConstantUnion(TInfoSink& out, const TIntermTyped* node, const TConstUnionArray& constUnion, int depth)
{
int size = node->getType().computeNumComponents();
for (int i = 0; i < size; i++) {
OutputTreeText(out, node, depth);
switch (constUnion[i].getType()) {
case EbtBool:
if (constUnion[i].getBConst())
out.debug << "true";
else
out.debug << "false";
out.debug << " (" << "const bool" << ")";
out.debug << "\n";
break;
case EbtFloat:
case EbtDouble:
#ifdef AMD_EXTENSIONS
case EbtFloat16:
#endif
{
const double value = constUnion[i].getDConst();
// Print infinities and NaNs in a portable way.
if (IsInfinity(value)) {
if (value < 0)
out.debug << "-1.#INF\n";
else
out.debug << "+1.#INF\n";
} else if (IsNan(value))
out.debug << "1.#IND\n";
else {
const int maxSize = 300;
char buf[maxSize];
snprintf(buf, maxSize, "%f", value);
out.debug << buf << "\n";
}
}
break;
case EbtInt:
{
const int maxSize = 300;
char buf[maxSize];
snprintf(buf, maxSize, "%d (%s)", constUnion[i].getIConst(), "const int");
out.debug << buf << "\n";
}
break;
case EbtUint:
{
const int maxSize = 300;
char buf[maxSize];
snprintf(buf, maxSize, "%u (%s)", constUnion[i].getUConst(), "const uint");
out.debug << buf << "\n";
}
break;
case EbtInt64:
{
const int maxSize = 300;
char buf[maxSize];
snprintf(buf, maxSize, "%lld (%s)", constUnion[i].getI64Const(), "const int64_t");
out.debug << buf << "\n";
}
break;
case EbtUint64:
{
const int maxSize = 300;
char buf[maxSize];
snprintf(buf, maxSize, "%llu (%s)", constUnion[i].getU64Const(), "const uint64_t");
out.debug << buf << "\n";
}
break;
default:
out.info.message(EPrefixInternalError, "Unknown constant", node->getLoc());
break;
}
}
}
bool CBotTwoOpExpr::Execute(CBotStack* &pStack)
{
CBotStack* pStk1 = pStack->AddStack(this); // adds an item to the stack
// or return in case of recovery
// if ( pStk1 == EOX ) return true;
// according to recovery, it may be in one of two states
if ( pStk1->GetState() == 0 ) // first state, evaluates the left operand
{
if (!m_leftop->Execute(pStk1) ) return false; // interrupted here?
// for OR and AND logic does not evaluate the second expression if not necessary
if ( (GetTokenType() == ID_LOG_AND || GetTokenType() == ID_TXT_AND ) && pStk1->GetVal() == false )
{
CBotVar* res = CBotVar::Create("", CBotTypBoolean);
res->SetValInt(false);
pStk1->SetVar(res);
return pStack->Return(pStk1); // transmits the result
}
if ( (GetTokenType() == ID_LOG_OR||GetTokenType() == ID_TXT_OR) && pStk1->GetVal() == true )
{
CBotVar* res = CBotVar::Create("", CBotTypBoolean);
res->SetValInt(true);
pStk1->SetVar(res);
return pStack->Return(pStk1); // transmits the result
}
// passes to the next step
pStk1->SetState(1); // ready for further
}
// requires a little more stack to avoid touching the result
// of which is left on the stack, precisely
CBotStack* pStk2 = pStk1->AddStack(); // adds an item to the stack
// or return in case of recovery
// 2e état, évalue l'opérande de droite
if ( pStk2->GetState() == 0 )
{
if ( !m_rightop->Execute(pStk2) ) return false; // interrupted here?
pStk2->IncState();
}
assert(pStk1->GetVar() != nullptr && pStk2->GetVar() != nullptr);
CBotTypResult type1 = pStk1->GetVar()->GetTypResult(); // what kind of results?
CBotTypResult type2 = pStk2->GetVar()->GetTypResult();
CBotStack* pStk3 = pStk2->AddStack(this); // adds an item to the stack
if ( pStk3->IfStep() ) return false; // shows the operation if step by step
// creates a temporary variable to put the result
// what kind of result?
int TypeRes = std::max(type1.GetType(), type2.GetType());
// see "any type convertible chain" in compile method
if ( GetTokenType() == ID_ADD &&
(type1.Eq(CBotTypString) || type2.Eq(CBotTypString)) )
{
TypeRes = CBotTypString;
}
switch ( GetTokenType() )
{
case ID_LOG_OR:
case ID_LOG_AND:
case ID_TXT_OR:
case ID_TXT_AND:
case ID_EQ:
case ID_NE:
case ID_HI:
case ID_LO:
case ID_HS:
case ID_LS:
TypeRes = CBotTypBoolean;
break;
case ID_DIV:
TypeRes = std::max(TypeRes, static_cast<int>(CBotTypFloat));
}
// creates a variable for the result
CBotVar* result = CBotVar::Create("", TypeRes);
// get left and right operands
CBotVar* left = pStk1->GetVar();
CBotVar* right = pStk2->GetVar();
// creates a variable to perform the calculation in the appropriate type
if ( TypeRes != CBotTypString ) // keep string conversion
{
TypeRes = std::max(type1.GetType(), type2.GetType());
}
else
{
left->Update(nullptr);
right->Update(nullptr);
}
if ( GetTokenType() == ID_ADD && type1.Eq(CBotTypString) )
{
TypeRes = CBotTypString;
}
CBotVar* temp;
if ( TypeRes == CBotTypPointer ) TypeRes = CBotTypNullPointer;
if ( TypeRes == CBotTypClass ) temp = CBotVar::Create("", CBotTypResult(CBotTypIntrinsic, type1.GetClass() ) );
else temp = CBotVar::Create("", TypeRes );
CBotError err = CBotNoErr;
// is a operation according to request
switch (GetTokenType())
{
case ID_ADD:
if ( !IsNan(left, right, &err) ) result->Add(left , right); // addition
break;
case ID_SUB:
if ( !IsNan(left, right, &err) ) result->Sub(left , right); // substraction
break;
case ID_MUL:
if ( !IsNan(left, right, &err) ) result->Mul(left , right); // multiplies
break;
case ID_POWER:
if ( !IsNan(left, right, &err) ) result->Power(left , right); // power
break;
case ID_DIV:
if ( !IsNan(left, right, &err) ) err = result->Div(left , right);// division
break;
case ID_MODULO:
if ( !IsNan(left, right, &err) ) err = result->Modulo(left , right);// remainder of division
break;
case ID_LO:
if ( !IsNan(left, right, &err) )
result->SetValInt(temp->Lo(left , right)); // lower
break;
case ID_HI:
if ( !IsNan(left, right, &err) )
result->SetValInt(temp->Hi(left , right)); // top
break;
case ID_LS:
if ( !IsNan(left, right, &err) )
result->SetValInt(temp->Ls(left , right)); // less than or equal
break;
case ID_HS:
if ( !IsNan(left, right, &err) )
result->SetValInt(temp->Hs(left , right)); // greater than or equal
break;
case ID_EQ:
if ( IsNan(left, right) )
result->SetValInt(left->GetInit() == right->GetInit()) ;
else
result->SetValInt(temp->Eq(left , right)); // equal
break;
case ID_NE:
if ( IsNan(left, right) )
result->SetValInt(left ->GetInit() != right->GetInit()) ;
else
result->SetValInt(temp->Ne(left , right)); // different
break;
case ID_TXT_AND:
case ID_LOG_AND:
case ID_AND:
if ( !IsNan(left, right, &err) ) result->And(left , right); // AND
break;
case ID_TXT_OR:
case ID_LOG_OR:
case ID_OR:
if ( !IsNan(left, right, &err) ) result->Or(left , right); // OR
break;
case ID_XOR:
if ( !IsNan(left, right, &err) ) result->XOr(left , right); // exclusive OR
break;
case ID_ASR:
if ( !IsNan(left, right, &err) ) result->ASR(left , right);
break;
case ID_SR:
if ( !IsNan(left, right, &err) ) result->SR(left , right);
break;
case ID_SL:
if ( !IsNan(left, right, &err) ) result->SL(left , right);
break;
default:
assert(0);
}
delete temp;
pStk2->SetVar(result); // puts the result on the stack
if ( err ) pStk2->SetError(err, &m_token); // and the possible error (division by zero)
// pStk1->Return(pStk2); // releases the stack
return pStack->Return(pStk2); // transmits the result
}
void CXTPMarkupGrid::ResolveStar(CXTPMarkupDefinitionCollection* pDefinitions, double availableSize)
{
CXTPMarkupDefinitionBase** pTempDefinitions = new CXTPMarkupDefinitionBase*[pDefinitions->GetCount()];
int length = 0;
double num2 = 0;
for (int i = 0; i < pDefinitions->GetCount(); i++)
{
CXTPMarkupDefinitionBase* pDefinition = pDefinitions->GetItem(i);
switch (pDefinition->m_nSizeType)
{
case sizeTypePixel:
num2 += pDefinition->m_nMeasureSize;
continue;
case sizeTypeAuto:
num2 += pDefinition->m_nMinSize;
continue;
case sizeTypeStar:
{
pTempDefinitions[length++] = pDefinition;
double num4 = pDefinition->GetUserSize()->GetValue();
if (num4 != 0)
{
pDefinition->m_nMeasureSize = num4;
double num5 = IsNan(pDefinition->GetUserMaxSize()) ? pDefinition->m_nMinSize : max(pDefinition->m_nMinSize, pDefinition->GetUserMaxSize());
pDefinition->m_nSizeCache = num5 / num4;
}
else
{
pDefinition->m_nMeasureSize = 0;
pDefinition->m_nSizeCache = 0;
}
continue;
}
}
}
if (length > 0)
{
qsort(pTempDefinitions, length, sizeof(CXTPMarkupDefinitionBase*), StarDistributionOrderComparer);
int nIndex;
double num6 = 0;
for (nIndex = length - 1; nIndex >= 0; nIndex--)
{
num6 += pTempDefinitions[nIndex]->m_nMeasureSize;
pTempDefinitions[nIndex]->m_nSizeCache = num6;
}
for (nIndex = 0; nIndex < length; nIndex++)
{
CXTPMarkupDefinitionBase* pDefinition = pTempDefinitions[nIndex];
int nMinSize;
double nMeasureSize = pDefinition->m_nMeasureSize;
if (nMeasureSize == 0)
{
nMinSize = pDefinition->m_nMinSize;
}
else
{
int num10 = (int)(max((double) (availableSize - num2), (double) 0) * (nMeasureSize / pDefinition->m_nSizeCache));
nMinSize = min(num10, pDefinition->GetUserMaxSize());
nMinSize = max(pDefinition->m_nMinSize, nMinSize);
}
pDefinition->m_nMeasureSize = nMinSize;
num2 += nMinSize;
}
}
delete[] pTempDefinitions;
}
void CXTPMarkupGrid::EnsureMinSizeInDefinitionRange(CXTPMarkupDefinitionCollection* pDefinitions, int start, int count, int requestedSize)
{
if (requestedSize == 0)
return;
CXTPMarkupDefinitionBase** pTempDefinitions = new CXTPMarkupDefinitionBase*[pDefinitions->GetCount()];
int num = start + count;
int nCountAuto = 0;
double dTotalMinSize = 0;
double dTotalPreferedSize = 0;
double dTotalMaxSize = 0;
double dMaxSize = 0;
for (int i = start; i < num; i++)
{
CXTPMarkupDefinitionBase* pDefinition = pDefinitions->GetItem(i);
double minSize = pDefinition->m_nMinSize;
double preferredSize = pDefinition->GetPreferredSize();
double maxSize = IsNan(pDefinition->GetUserMaxSize()) ? minSize : max(minSize, pDefinition->GetUserMaxSize());
dTotalMinSize += minSize;
dTotalPreferedSize += preferredSize;
dTotalMaxSize += maxSize;
pDefinition->m_nSizeCache = maxSize;
if (dMaxSize < maxSize)
{
dMaxSize = maxSize;
}
if (pDefinition->GetUserSize()->IsAuto())
{
nCountAuto++;
}
pTempDefinitions[i - start] = pDefinition;
}
if (requestedSize > dTotalMinSize)
{
if (requestedSize <= dTotalPreferedSize)
{
qsort(pTempDefinitions, count, sizeof(CXTPMarkupDefinitionBase*), SpanPreferredDistributionOrderComparer);
int index = 0;
double d = requestedSize;
while (index < nCountAuto)
{
d -= pTempDefinitions[index]->m_nMinSize;
index++;
}
while (index < count)
{
double a = min(d / ((double) (count - index)), pTempDefinitions[index]->GetPreferredSize());
if (a > pTempDefinitions[index]->m_nMinSize)
{
pTempDefinitions[index]->UpdateMinSize((int)a);
}
d -= a;
index++;
}
}
else if (requestedSize <= dTotalMaxSize)
{
qsort(pTempDefinitions, count, sizeof(CXTPMarkupDefinitionBase*), SpanMaxDistributionOrderComparer);
int n = 0;
double d = requestedSize - dTotalPreferedSize;
while (n < (count - nCountAuto))
{
double num16 = pTempDefinitions[n]->GetPreferredSize();
double num17 = num16 + (d / ((double) ((count - nCountAuto) - n)));
pTempDefinitions[n]->UpdateMinSize((int)min(num17, pTempDefinitions[n]->m_nSizeCache));
d -= pTempDefinitions[n]->m_nMinSize - num16;
n++;
}
while (n < count)
{
double num18 = pTempDefinitions[n]->m_nMinSize;
double num19 = num18 + (d / ((double) (count - n)));
pTempDefinitions[n]->UpdateMinSize((int)(min(num19, pTempDefinitions[n]->m_nSizeCache)));
d -= pTempDefinitions[n]->m_nMinSize - num18;
n++;
}
}
else
{
double dAverage = (double)requestedSize / ((double) count);
if (dAverage < dMaxSize)
{
double num21 = (dMaxSize * count) - dTotalMaxSize;
double num22 = requestedSize - dTotalMaxSize;
for (int j = 0; j < count; j++)
{
double num24 = ((dMaxSize - pTempDefinitions[j]->m_nSizeCache) * num22) / num21;
pTempDefinitions[j]->UpdateMinSize(int(pTempDefinitions[j]->m_nSizeCache + num24));
}
}
else
{
for (int k = 0; k < count; k++)
{
pTempDefinitions[k]->UpdateMinSize((int)dAverage);
}
}
}
}
delete[] pTempDefinitions;
}
// Calculate Standard Deviation for the values
void MgFeatureNumericFunctions::GetStandardDeviationCategories( VECTOR &values, int numCats,
double dataMin, double dataMax,
VECTOR &distValues)
{
// Expected categories should be more than zero
if (numCats <= 0)
{
STRING message = MgServerFeatureUtil::GetMessage(L"MgInvalidComputedProperty");
MgStringCollection arguments;
arguments.Add(message);
throw new MgFeatureServiceException(L"MgServerSelectFeatures.GetEqualCategories", __LINE__, __WFILE__, &arguments, L"", NULL);
}
// collect information about the data values
double min = DoubleMaxValue;
double max = -DoubleMaxValue;
double mean = 0;
int cnt = (int)values.size();
if (cnt <= 0) { return; } // Nothing to do, we just send back Property Definition to clients from reader
for (int i=0; i < cnt; i++)
{
double val = values[i];
if (val > max)
max = val;
if (val < min)
min = val;
mean += val;
}
// expand min and max a little to account for numerical instability
double delta = 0.0001 * (max - min);
min -= delta;
max += delta;
// compute the mean, variance and standard deviation
double count = (double)cnt; // (guaranteed to be > 0)
mean /= count;
double variance = 0;
for (int i=0; i < cnt; i++)
{
double val = values[i];
variance += (val - mean) * (val - mean);
}
double deviation = sqrt(variance / count);
// fill in the middle category/categories
double* cats = new double[numCats+1];
int midCat, highMidCat;
if (numCats % 2 == 0)
{
midCat = numCats / 2;
highMidCat = midCat;
cats[midCat] = mean;
}
else
{
midCat = (numCats - 1) / 2;
highMidCat = midCat + 1;
cats[midCat] = mean - 0.5 * deviation;
cats[highMidCat] = mean + 0.5 * deviation;
}
// fill in the other categories
for (int i=midCat-1; i>=0; i--)
cats[i] = cats[i+1] - deviation;
for (int i=highMidCat; i<=numCats; i++)
cats[i] = cats[i-1] + deviation;
// if the data method specifies strict a strict min and/or max, use them
if (!IsInf(dataMin) && !IsNan(dataMin) && (dataMin != -DoubleMaxValue))
min = dataMin;
if (!IsInf(dataMax) && !IsNan(dataMax) && (dataMax != DoubleMaxValue))
max = dataMax;
// flatten/clip any categories that extend beyond the min/max range
for (int i=0; i<=numCats; i++)
{
if (cats[i] < min)
cats[i] = min;
else if (cats[i] > max)
cats[i] = max;
}
for (int kk = 0; kk < numCats+1; kk++)
{
distValues.push_back(cats[kk]);
}
delete[] cats; // Delete the memory allocated before
}
//****************************************************************
bool OpSort::ProcessVec(std::vector<OBBase*>& vec)
{
// Make a vector containing both the OBBase* and the descriptor value and the sort it
if(!IsNan(_pDesc->Predict(vec[0], &_pDescOption)))
{
//a numerical descriptor
//Copy into a pair vector
std::vector<std::pair<OBBase*,double> > valvec;
valvec.reserve(vec.size());
std::vector<OBBase*>::iterator iter;
for(iter=vec.begin();iter!=vec.end();++iter)
valvec.push_back(std::make_pair<OBBase*,double>(*iter, _pDesc->Predict(*iter, &_pDescOption)));
//Sort
std::sort(valvec.begin(),valvec.end(), Order<double>(_pDesc, _rev));
//Copy back
std::vector<std::pair<OBBase*,double> >::iterator valiter;
iter=vec.begin();
for(valiter=valvec.begin();valiter!=valvec.end();++valiter, ++iter)
{
*iter = valiter->first;
if(_addDescToTitle)
{
std::stringstream ss;
ss << (*iter)->GetTitle() << ' ' << valiter->second;
(*iter)->SetTitle(ss.str().c_str());
}
}
}
else
{
//a string descriptor
//Copy into a pair vector
std::vector<std::pair<OBBase*,std::string> > valvec;
valvec.reserve(vec.size());
std::vector<OBBase*>::iterator iter;
std::string s;
for(iter=vec.begin();iter!=vec.end();++iter)
{
_pDesc->GetStringValue(*iter, s, &_pDescOption);
valvec.push_back(std::make_pair<OBBase*,std::string>(*iter, s));
}
//Sort
std::sort(valvec.begin(),valvec.end(), Order<std::string>(_pDesc, _rev));
//Copy back
std::vector<std::pair<OBBase*,std::string> >::iterator valiter;
iter=vec.begin();
for(valiter=valvec.begin();valiter!=valvec.end();++valiter, ++iter)
{
*iter = valiter->first;
if(_addDescToTitle)
{
std::stringstream ss;
ss << (*iter)->GetTitle() << ' ' << valiter->second;
(*iter)->SetTitle(ss.str().c_str());
}
}
}
return true;
}
