vector<int> Solution034::searchRange(vector<int> &nums, int target)
{
vector<int> res;
res.push_back( findLower(nums,target));
res.push_back( findUpper(nums,target));
return res;
}
void Foam::Histogram<List>::count(const List& bins, const List& l)
{
if (bins.size() < 2)
{
FatalErrorIn("Histogram<List>::count(const List&, const List&)")
<< "Should have at least two values in bins. Now:" << bins
<< exit(FatalError);
}
counts_.setSize(bins.size()-1);
counts_ = 0;
nLow_ = 0;
nHigh_ = 0;
forAll(l, i)
{
label index = findLower(bins, l[i]);
if (index == -1)
{
nLow_++;
}
else if (index == bins.size()-1)
{
nHigh_++;
}
else
{
counts_[index]++;
}
}
// Find position in values so between minIndex and this position there
// are wantedSize elements.
void Foam::hierarchGeomDecomp::findBinary
(
const label sizeTol,
const List<scalar>& values,
const label minIndex, // index of previous value
const scalar minValue, // value at minIndex
const scalar maxValue, // global max of values
const scalar wantedSize, // wanted size
label& mid, // index where size of bin is
// wantedSize (to within sizeTol)
scalar& midValue // value at mid
)
{
label low = minIndex;
scalar lowValue = minValue;
scalar highValue = maxValue;
// (one beyond) index of highValue
label high = values.size();
//while (low <= high)
while (true)
{
label size = returnReduce(mid-minIndex, sumOp<label>());
if (debug)
{
Pout<< "low:" << low << " lowValue:" << lowValue
<< " high:" << high << " highValue:" << highValue
<< " mid:" << mid << " midValue:" << midValue << nl
<< "globalSize:" << size << " wantedSize:" << wantedSize
<< " sizeTol:" << sizeTol << endl;
}
if (wantedSize < size - sizeTol)
{
high = mid;
highValue = midValue;
}
else if (wantedSize > size + sizeTol)
{
low = mid;
lowValue = midValue;
}
else
{
break;
}
// Update mid, midValue
midValue = 0.5*(lowValue+highValue);
mid = findLower(values, midValue, low, high);
}
}
bool splineInterpolationWeights::valueWeights
(
const scalar t,
labelList& indices,
scalarField& weights
) const
{
bool indexChanged = false;
// linear interpolation
if (samples_.size() <= 2)
{
return linearInterpolationWeights(samples_).valueWeights
(
t,
indices,
weights
);
}
// Check if current timeIndex is still valid
if
(
index_ >= 0
&& index_ < samples_.size()
&& (
samples_[index_] <= t
&& (index_ == samples_.size()-1 || t <= samples_[index_+1])
)
)
{
// index_ still at correct slot
}
else
{
// search for correct index
index_ = findLower(samples_, t);
indexChanged = true;
}
// Clamp if outside table
if (index_ == -1)
{
indices.setSize(1);
weights.setSize(1);
indices[0] = 0;
weights[0] = 1;
return indexChanged;
}
else if (index_ == samples_.size()-1)
{
indices.setSize(1);
weights.setSize(1);
indices[0] = samples_.size()-1;
weights[0] = 1;
return indexChanged;
}
label lo = index_;
label hi = index_+1;
// weighting
scalar mu = (t - samples_[lo])/(samples_[hi] - samples_[lo]);
scalar w0 = 0.5*(mu*(-1+mu*(2-mu))); // coeff of lo-1
scalar w1 = 0.5*(2+mu*(mu*(-5 + mu*(3)))); // coeff of lo
scalar w2 = 0.5*(mu*(1 + mu*(4 + mu*(-3)))); // coeff of hi
scalar w3 = 0.5*(mu*mu*(-1 + mu)); // coeff of hi+1
if (lo > 0)
{
if (hi < samples_.size()-1)
{
// Four points available
indices.setSize(4);
weights.setSize(4);
indices[0] = lo-1;
indices[1] = lo;
indices[2] = hi;
indices[3] = hi+1;
weights[0] = w0;
weights[1] = w1;
weights[2] = w2;
weights[3] = w3;
}
else
{
// No y3 available. Extrapolate: y3=3*y2-y1
indices.setSize(3);
weights.setSize(3);
indices[0] = lo-1;
indices[1] = lo;
indices[2] = hi;
weights[0] = w0;
weights[1] = w1 - w3;
weights[2] = w2 + 2*w3;
}
}
else
{
// No y0 available. Extrapolate: y0=2*y1-y2;
if (hi < samples_.size()-1)
{
indices.setSize(3);
weights.setSize(3);
indices[0] = lo;
indices[1] = hi;
indices[2] = hi+1;
weights[0] = w1 + 2*w0;
weights[1] = w2 - w0;
weights[2] = w3;
}
else
{
indices.setSize(2);
weights.setSize(2);
indices[0] = lo;
indices[1] = hi;
weights[0] = w1 + 2*w0 - w3;
weights[1] = w2 - w0 + 2*w3;
}
}
return indexChanged;
}
bool Foam::matchPoints
(
const UList<point>& pts0,
const UList<point>& pts1,
const UList<scalar>& matchDistances,
const bool verbose,
labelList& from0To1,
const point& origin
)
{
from0To1.setSize(pts0.size());
from0To1 = -1;
bool fullMatch = true;
point compareOrigin = origin;
if (origin == point(VGREAT, VGREAT, VGREAT))
{
if (pts1.size())
{
compareOrigin = sum(pts1)/pts1.size();
}
}
SortableList<scalar> pts0MagSqr(magSqr(pts0 - compareOrigin));
SortableList<scalar> pts1MagSqr(magSqr(pts1 - compareOrigin));
forAll(pts0MagSqr, i)
{
scalar dist0 = pts0MagSqr[i];
label face0I = pts0MagSqr.indices()[i];
scalar matchDist = matchDistances[face0I];
label startI = findLower(pts1MagSqr, 0.99999*dist0 - 2*matchDist);
if (startI == -1)
{
startI = 0;
}
// Go through range of equal mag and find nearest vector.
scalar minDistSqr = VGREAT;
label minFacei = -1;
for
(
label j = startI;
(
(j < pts1MagSqr.size())
&& (pts1MagSqr[j] < 1.00001*dist0 + 2*matchDist)
);
j++
)
{
label facei = pts1MagSqr.indices()[j];
// Compare actual vectors
scalar distSqr = magSqr(pts0[face0I] - pts1[facei]);
if (distSqr <= sqr(matchDist) && distSqr < minDistSqr)
{
minDistSqr = distSqr;
minFacei = facei;
}
}
if (minFacei == -1)
{
fullMatch = false;
if (verbose)
{
Pout<< "Cannot find point in pts1 matching point " << face0I
<< " coord:" << pts0[face0I]
<< " in pts0 when using tolerance " << matchDist << endl;
// Go through range of equal mag and find equal vector.
Pout<< "Searching started from:" << startI << " in pts1"
<< endl;
for
(
label j = startI;
(
(j < pts1MagSqr.size())
&& (pts1MagSqr[j] < 1.00001*dist0 + 2*matchDist)
);
j++
)
{
label facei = pts1MagSqr.indices()[j];
Pout<< " Compared coord: " << pts1[facei]
<< " at index " << j
<< " with difference to point "
<< mag(pts1[facei] - pts0[face0I]) << endl;
}
}
}
from0To1[face0I] = minFacei;
}
bool linearInterpolationWeights::valueWeights
(
const scalar t,
labelList& indices,
scalarField& weights
) const
{
bool indexChanged = false;
// Check if current timeIndex is still valid
if
(
index_ >= 0
&& index_ < samples_.size()
&& (
samples_[index_] <= t
&& (index_ == samples_.size()-1 || t <= samples_[index_+1])
)
)
{
// index_ still at correct slot
}
else
{
// search for correct index
index_ = findLower(samples_, t);
indexChanged = true;
}
if (index_ == -1)
{
// Use first element only
indices.setSize(1);
weights.setSize(1);
indices[0] = 0;
weights[0] = 1.0;
}
else if (index_ == samples_.size()-1)
{
// Use last element only
indices.setSize(1);
weights.setSize(1);
indices[0] = samples_.size()-1;
weights[0] = 1.0;
}
else
{
// Interpolate
indices.setSize(2);
weights.setSize(2);
indices[0] = index_;
indices[1] = index_+1;
scalar t0 = samples_[indices[0]];
scalar t1 = samples_[indices[1]];
scalar deltaT = t1-t0;
weights[0] = (t1-t)/deltaT;
weights[1] = 1.0-weights[0];
}
return indexChanged;
}
bool linearInterpolationWeights::integrationWeights
(
const scalar t1,
const scalar t2,
labelList& indices,
scalarField& weights
) const
{
if (t2 < t1-VSMALL)
{
FatalErrorIn("linearInterpolationWeights::integrationWeights(..)")
<< "Integration should be in positive direction."
<< " t1:" << t1 << " t2:" << t2
<< exit(FatalError);
}
// Currently no fancy logic on cached index like in value
//- Find lower or equal index
label i1 = findLower(samples_, t1, 0, lessEqOp<scalar>());
//- Find lower index
label i2 = findLower(samples_, t2);
// For now just fail if any outside table
if (i1 == -1 || i2 == samples_.size()-1)
{
FatalErrorIn("linearInterpolationWeights::integrationWeights(..)")
<< "Integrating outside table " << samples_[0] << ".."
<< samples_.last() << " not implemented."
<< " t1:" << t1 << " t2:" << t2 << exit(FatalError);
}
label nIndices = i2-i1+2;
// Determine if indices already correct
bool anyChanged = false;
if (nIndices != indices.size())
{
anyChanged = true;
}
else
{
// Closer check
label index = i1;
forAll(indices, i)
{
if (indices[i] != index)
{
anyChanged = true;
break;
}
index++;
}
}
indices.setSize(nIndices);
weights.setSize(nIndices);
weights = 0.0;
// Sum from i1+1 to i2+1
for (label i = i1+1; i <= i2; i++)
{
scalar d = samples_[i+1]-samples_[i];
indices[i-i1] = i;
weights[i-i1] += 0.5*d;
indices[i+1-i1] = i+1;
weights[i+1-i1] += 0.5*d;
}
// Add from i1 to t1
{
Pair<scalar> i1Tot1 = integrationWeights(i1, t1);
indices[0] = i1;
weights[0] += i1Tot1.first();
indices[1] = i1+1;
weights[1] += i1Tot1.second();
}
// Subtract from t2 to i2+1
{
Pair<scalar> wghts = integrationWeights(i2, t2);
indices[i2-i1] = i2;
weights[i2-i1] += -wghts.first();
indices[i2-i1+1] = i2+1;
weights[i2-i1+1] += -wghts.second();
}
return anyChanged;
}
