bool LinearlyDependent_Robust_Template(const VT& a, const VT& b, Real& c, bool& cb, Real eps) {
Real aDotB = a.dot(b);
Real aNorm2 = a.normSquared();
if(aNorm2 > Abs(aDotB)) {
cb = false;
c = aDotB/aNorm2;
Real aNorm = Sqrt(aNorm2);
Real relEps = eps*aNorm;
for(int i=0;i<n;i++) {
if(!FuzzyEquals(c*a[i],b[i],relEps)) return false;
}
return true;
}
else {
Real bNorm2 = b.normSquared();
cb = true;
if(bNorm2 == Zero) { //both a and b are 0
c = One;
return true;
}
c = aDotB/bNorm2;
Real bNorm = Sqrt(bNorm2);
Real relEps = eps*bNorm;
for(int i=0;i<n;i++) {
if(!FuzzyEquals(a[i],c*b[i],relEps)) return false;
}
return true;
}
}
void LDLDecomposition<T>::getPseudoInverse(MatrixT& Ainv) const
{
Ainv.resize(LDL.n,LDL.n);
VectorT temp(LDL.n,Zero),y,x;
for(int i=0;i<LDL.n;i++) {
temp(i)=One;
LBackSub(temp,y);
for(int j=0;j<y.n;j++) {
if(!FuzzyZero(LDL(j,j),zeroTolerance))
y(j) = y(j)/LDL(j,j);
else
y(j) = 0.0;
}
LTBackSub(y,x);
//fill in a column
for(int j=0;j<LDL.n;j++)
Ainv(j,i)=x(j);
temp(i)=Zero;
}
T tol = Ainv.maxAbsElement()*Epsilon;
for(int i=0;i<LDL.n;i++)
for(int j=0;j<i;j++) {
if(!FuzzyEquals(Ainv(i,j),Ainv(j,i),tol))
LOG4CXX_INFO(KrisLibrary::logger(),Ainv);
Assert(FuzzyEquals(Ainv(i,j),Ainv(j,i),tol));
Ainv(i,j)=Ainv(j,i) = 0.5*(Ainv(i,j)+Ainv(j,i));
}
}
//assumes normalized normals
bool operator () (const dContactGeom& a,const dContactGeom& b)
{
Vector3 an,bn;
CopyVector(an,a.normal);
CopyVector(bn,b.normal);
Real ndot = an.dot(bn);
if(ndot > catol) {
Vector3 ax,bx;
CopyVector(ax,a.pos);
CopyVector(bx,b.pos);
return FuzzyEquals(ax.dot(an),bx.dot(an),ptol) &&
FuzzyEquals(ax.dot(bn),bx.dot(bn),ptol);
}
return false;
}
static TVector<TFeaturePathElement> UnwindFeaturePath(const TVector<TFeaturePathElement>& oldFeaturePath, size_t eraseElementIdx) {
const size_t pathLength = oldFeaturePath.size();
CB_ENSURE(pathLength > 0, "Path to unwind must have at least one element");
TVector<TFeaturePathElement> newFeaturePath(oldFeaturePath.begin(), oldFeaturePath.begin() + pathLength - 1);
for (size_t elementIdx = eraseElementIdx; elementIdx < pathLength - 1; ++elementIdx) {
newFeaturePath[elementIdx].Feature = oldFeaturePath[elementIdx + 1].Feature;
newFeaturePath[elementIdx].ZeroPathsFraction = oldFeaturePath[elementIdx + 1].ZeroPathsFraction;
newFeaturePath[elementIdx].OnePathsFraction = oldFeaturePath[elementIdx + 1].OnePathsFraction;
}
const double onePathsFraction = oldFeaturePath[eraseElementIdx].OnePathsFraction;
const double zeroPathsFraction = oldFeaturePath[eraseElementIdx].ZeroPathsFraction;
double weightDiff = oldFeaturePath[pathLength - 1].Weight;
if (!FuzzyEquals(onePathsFraction, 0.0)) {
for (int elementIdx = pathLength - 2; elementIdx >= 0; --elementIdx) {
double oldWeight = newFeaturePath[elementIdx].Weight;
newFeaturePath[elementIdx].Weight = weightDiff * pathLength / (onePathsFraction * (elementIdx + 1));
weightDiff = oldWeight - newFeaturePath[elementIdx].Weight * zeroPathsFraction * (pathLength - elementIdx - 1) / pathLength;
}
} else {
for (int elementIdx = pathLength - 2; elementIdx >= 0; --elementIdx) {
newFeaturePath[elementIdx].Weight *= pathLength / (zeroPathsFraction * (pathLength - elementIdx - 1));
}
}
return newFeaturePath;
}
bool DiagonalMatrixTemplate<T>::isIdentity(T eps) const
{
if(this->empty())
FatalError(MatrixError_SizeZero);
ItT v=this->begin();
for(int i=0; i<this->n; i++,v++)
if(!FuzzyEquals(*v,(T)1,eps))
return false;
return true;
}
void TransformCosSin_Sin(Real a,Real b,Real& c,Real& d)
{
//use sin(x+d) = sin(x)cos(d) + cos(x)sin(d)
//=> a=c*sin(d), b=c*cos(d)
//=> c^2 = a^2+b^2
if(a==0 && b==0) { c=d=0; }
else {
d = Atan2(a,b);
c = pythag(a,b);
}
Real x=0.5;
if(!FuzzyEquals(c*Sin(x+d),a*Cos(x)+b*Sin(x))) {
printf("Error in TransformCosSin\n");
printf("a: %f, b: %f\n",a,b);
printf("c: %f, d: %f\n",c,d);
printf("f(x): %f\n",a*Cos(x)+b*Sin(x));
printf("g(x): %f\n",c*Sin(x+d));
}
Assert(FuzzyEquals(c*Sin(x+d),a*Cos(x)+b*Sin(x)));
}
bool SolveCosSinEquation(Real a,Real b,Real c,Real& t1,Real& t2)
{
if(a==0 && b==0) {
if(c==0) { t1=0; t2=TwoPi; return true; }
return false;
}
else {
Real cs,ds;
TransformCosSin_Sin(a,b,cs,ds);
//cs*sin(x+ds)=c => x=asin(c/cs)-ds
//or pi-asin(c/cs)-ds
if(c > cs || c < -cs) return false;
t1 = Asin(c/cs);
t2 = Pi-t1;
t1 -= ds;
t2 -= ds;
Assert(FuzzyEquals(a*Cos(t1)+b*Sin(t1),c));
Assert(FuzzyEquals(a*Cos(t2)+b*Sin(t2),c));
}
return true;
}
bool RigidTransform2D::isValid(Real eps) const
{
return FuzzyEquals(R.determinant(),One,eps);
}
bool
SharedFrameMetricsHelper::UpdateFromCompositorFrameMetrics(
ContainerLayer* aLayer,
bool aHasPendingNewThebesContent,
bool aLowPrecision,
ParentLayerRect& aCompositionBounds,
CSSToParentLayerScale& aZoom)
{
MOZ_ASSERT(aLayer);
CompositorChild* compositor = CompositorChild::Get();
if (!compositor) {
FindFallbackContentFrameMetrics(aLayer, aCompositionBounds, aZoom);
return false;
}
const FrameMetrics& contentMetrics = aLayer->GetFrameMetrics();
FrameMetrics compositorMetrics;
if (!compositor->LookupCompositorFrameMetrics(contentMetrics.mScrollId,
compositorMetrics)) {
FindFallbackContentFrameMetrics(aLayer, aCompositionBounds, aZoom);
return false;
}
aCompositionBounds = ParentLayerRect(compositorMetrics.mCompositionBounds);
aZoom = compositorMetrics.GetZoomToParent();
// Reset the checkerboard risk flag when switching to low precision
// rendering.
if (aLowPrecision && !mLastProgressiveUpdateWasLowPrecision) {
// Skip low precision rendering until we're at risk of checkerboarding.
if (!mProgressiveUpdateWasInDanger) {
return true;
}
mProgressiveUpdateWasInDanger = false;
}
mLastProgressiveUpdateWasLowPrecision = aLowPrecision;
// Always abort updates if the resolution has changed. There's no use
// in drawing at the incorrect resolution.
if (!FuzzyEquals(compositorMetrics.GetZoom().scale, contentMetrics.GetZoom().scale)) {
return true;
}
// Never abort drawing if we can't be sure we've sent a more recent
// display-port. If we abort updating when we shouldn't, we can end up
// with blank regions on the screen and we open up the risk of entering
// an endless updating cycle.
if (fabsf(contentMetrics.GetScrollOffset().x - compositorMetrics.GetScrollOffset().x) <= 2 &&
fabsf(contentMetrics.GetScrollOffset().y - compositorMetrics.GetScrollOffset().y) <= 2 &&
fabsf(contentMetrics.mDisplayPort.x - compositorMetrics.mDisplayPort.x) <= 2 &&
fabsf(contentMetrics.mDisplayPort.y - compositorMetrics.mDisplayPort.y) <= 2 &&
fabsf(contentMetrics.mDisplayPort.width - compositorMetrics.mDisplayPort.width) <= 2 &&
fabsf(contentMetrics.mDisplayPort.height - compositorMetrics.mDisplayPort.height)) {
return false;
}
// When not a low precision pass and the page is in danger of checker boarding
// abort update.
if (!aLowPrecision && !mProgressiveUpdateWasInDanger) {
if (AboutToCheckerboard(contentMetrics, compositorMetrics)) {
mProgressiveUpdateWasInDanger = true;
return true;
}
}
// Abort drawing stale low-precision content if there's a more recent
// display-port in the pipeline.
if (aLowPrecision && !aHasPendingNewThebesContent) {
return true;
}
return false;
}
