Projects the found estimate of E onto essential space.

@return true if svd returned true.
184877
protected boolean projectOntoEssential( DMatrixRMaj E ) {
		if( !svdConstraints.decompose(E) ) {
			return false;
		}
		svdV = svdConstraints.getV(svdV,false);
		svdU = svdConstraints.getU(svdU,false);
		svdS = svdConstraints.getW(svdS);

		SingularOps_DDRM.descendingOrder(svdU, false, svdS, svdV, false);

		// project it into essential space
		// the scale factor is arbitrary, but the first two singular values need
		// to be the same.  so just set them to one
		svdS.unsafe_set(0, 0, 1);
		svdS.unsafe_set(1, 1, 1);
		svdS.unsafe_set(2, 2, 0);

		// recompute F
		CommonOps_DDRM.mult(svdU, svdS, temp0);
		CommonOps_DDRM.multTransB(temp0,svdV, E);

		return true;
	}
977236
public boolean isSet() {
        if (isUsageMode()) {
            return true;
        }
        if (getJobFile() != null) {
            return true;
        }
        if (getListType() != null) {
            return true;
        }
        return false;
    }
983046
public boolean isFullRevision()
	{
		if (this.parts.size() == 1) {
			DiffPart p = this.parts.get(0);
			if (p.getAction() == DiffAction.FULL_REVISION_UNCOMPRESSED) {
				return true;
			}
		}

		return false;
	}
1067568
private boolean process(DMatrixRMaj A) {
		if( !solverNull.process(A,2,nullspace) )
			return false;

		SpecializedOps_DDRM.subvector(nullspace, 0, 0, 9, false, 0, F1);
		SpecializedOps_DDRM.subvector(nullspace, 0, 1, 9, false, 0, F2);

		return true;
	}
1200454
private boolean estimateMotion() {
		modelFitData.reset();

		Point2D_F64 normLeft = new Point2D_F64();
		Point2D_F64 normRight = new Point2D_F64();

		// use 0 -> 1 stereo associations to estimate each feature's 3D position
		for( int i = 0; i < quadViews.size; i++ ) {
			QuadView obs = quadViews.get(i);

			// convert old stereo view to normalized coordinates
			leftImageToNorm.compute(obs.v0.x,obs.v0.y,normLeft);
			rightImageToNorm.compute(obs.v1.x,obs.v1.y,normRight);

			// compute 3D location using triangulation
			triangulate.triangulate(normLeft,normRight,leftToRight,obs.X);

			// add to data set for fitting if not at infinity
			if( !Double.isInfinite(obs.X.normSq()) ) {
				Stereo2D3D data = modelFitData.grow();
				leftImageToNorm.compute(obs.v2.x,obs.v2.y,data.leftObs);
				rightImageToNorm.compute(obs.v3.x,obs.v3.y,data.rightObs);
				data.location.set(obs.X);
			}
		}

		// robustly match the data
		if( !matcher.process(modelFitData.toList()) )
			return false;

		Se3_F64 oldToNew = matcher.getModelParameters();

//		System.out.println("matcher rot = "+toString(oldToNew));
		// optionally refine the results
		if( modelRefiner != null ) {
			Se3_F64 found = new Se3_F64();
			if( modelRefiner.fitModel(matcher.getMatchSet(), oldToNew, found) ) {
//				System.out.println("matcher rot = "+toString(found));
				found.invert(newToOld);
			} else {
				oldToNew.invert(newToOld);
//				System.out.println("Fit failed!");
			}
		} else {
			oldToNew.invert(newToOld);
		}

		// compound the just found motion with the previously found motion
		Se3_F64 temp = new Se3_F64();
		newToOld.concat(leftCamToWorld, temp);
		leftCamToWorld.set(temp);

		return true;
	}
530113
private ESat isConsistent() {
        int[][] l = new int[nbDims][nbBins];
        for (int i = 0; i < bins.length; i++) {
            if (bins[i].isInstantiated()) {
                for (int d = 0; d < nbDims; d++) {
                    int v = bins[i].getValue();
                    l[d][v] += iSizes[d][i];
                    if (l[d][v] > loads[d][v].getUB()) {
                        return ESat.FALSE;
                    }
                }
            }
        }
        return ESat.TRUE;
    }
152517
public void process(DMatrixRMaj F , @Nullable Point3D_F64 e1 , @Nullable Point3D_F64 e2 ) {

		if( !svd.decompose(F) )
			throw new RuntimeException("SVD Failed?!");

		svd.getU(U,false);
		svd.getV(V,false);
		double singular[] = svd.getSingularValues();
		SingularOps_DDRM.descendingOrder(U,false,singular,3,V,false);

		if( e2 != null )
			e2.set(U.get(0,2),U.get(1,2),U.get(2,2));
		if( e1 != null )
			e1.set(V.get(0,2),V.get(1,2),V.get(2,2));
	}
1146692
public boolean isSingleMember() {
		final Address localAddress = getLocalAddress();
		if (localAddress != null) {
			final List<Address> clusterMembers = getClusterMembers();
			return clusterMembers.size() == 1;
		}
		else {
			return true;
		}
	}
1127921
private boolean setNextObject() {
        while (true) {
            while (ds == null) {
                if (!fileSetIterator.hasNext()) {
                    return false;
                }
                FileSet fs = fileSetIterator.next();
                ds = fs.getDirectoryScanner(project);
                ds.scan();
                if (iterateDirectories) {
                    files = ds.getIncludedDirectories();
                } else {
                    files = ds.getIncludedFiles();
                }
                if (files.length > 0) {
                    fileIndex = -1;
                    break;
                } else {
                    ds = null;
                }
            }

            if (ds != null && files != null) {
                if (++fileIndex < files.length) {
                    nextFile = new File(ds.getBasedir(), files[fileIndex]);
                    nextObjectSet = true;
                    return true;
                } else {
                    ds = null;
                }
            }
        }
    }
796457
@Override
  public double[] projectDataToScaledSpace(NumberVector data) {
    final int dim = data.getDimensionality();
    double[] vec = new double[dim];
    for(int d = 0; d < dim; d++) {
      vec[d] = scales[d].getScaled(data.doubleValue(d));
    }
    return vec;
  }
740553
public double estimateExcludedVolumeFraction(){
		//Calculate volume/area of the of the scene without obstacles
		if(recalculateVolumeFraction){
			CentralRandomNumberGenerator r = CentralRandomNumberGenerator.getInstance();
			boolean firstRandomDraw = false;
			if(randomNumbers==null){
				randomNumbers = new double[nRandPoints*dimension];
				firstRandomDraw = true;
			}
			int countCollision = 0;
			for(int i = 0; i< nRandPoints; i++){
				double[] pos = new double[dimension];
				for(int j = 0; j < dimension; j++){
					if(firstRandomDraw){
						randomNumbers[i*dimension + j] = r.nextDouble();
					}
					pos[j] = randomNumbers[i*dimension + j]*size[j];
				}
				if(checkCollision(pos)){
					countCollision++;
				}
			}
			fraction = countCollision*1.0/nRandPoints;
			recalculateVolumeFraction = false;
		}
		return fraction;
	}
413220
public boolean isClosed() {
		if (isEmpty()) {
			return false;
		}
		if (getNumPoints() == 1) {
			return false;
		}
		Coordinate[] coordinates = getCoordinates();
		return coordinates[0].equals(coordinates[coordinates.length - 1]);
	}
1138571
public boolean isAbsolute()
   {
      if (names[0].getIndex() == 1 && names[0].getName().length() == 0 && names[0].getNamespace().length() == 0)
         return true;
      else
         return false;
   }
885813
private boolean isNoMeasureAvailable(HLAMeasure measure, IProject project) {

        return !project.getMeasures().contains(measure) || project.getMeasureValue(measure, false) == Project.VALUE_NOT_AVAILABLE;
    }
188992
private boolean isCurrentStageCompleted() {

		if (this.indexToCurrentExecutionStage >= this.stages.size()) {
			return true;
		}

		final ExecutionGraphIterator it = new ExecutionGraphIterator(this, this.indexToCurrentExecutionStage, true,
			true);
		while (it.hasNext()) {
			final ExecutionVertex vertex = it.next();
			if (vertex.getExecutionState() != ExecutionState.FINISHED) {
				return false;
			}
		}

		return true;
	}
1364884
public function hasTraefik()
    {
        $network = ProjectX::getProjectConfig()->getNetwork();

        return isset($network['proxy']) && $network['proxy']
            ? $network['proxy']
            : false;
    }
943501
protected boolean relevantSubspace(long[] subspace, DoubleDBIDList neigh, KernelDensityEstimator kernel) {
    final double crit = K_S_CRITICAL001 / FastMath.sqrt(neigh.size() - 2);

    double[] data = new double[neigh.size()];
    Relation<? extends NumberVector> relation = kernel.relation;
    for(int dim = BitsUtil.nextSetBit(subspace, 0); dim >= 0; dim = BitsUtil.nextSetBit(subspace, dim + 1)) {
      // TODO: can/should we save this copy?
      int count = 0;
      for(DBIDIter neighbor = neigh.iter(); neighbor.valid(); neighbor.advance()) {
        data[count++] = relation.get(neighbor).doubleValue(dim);
      }
      assert (count == neigh.size());
      Arrays.sort(data);

      final double min = data[0], norm = data[data.length - 1] - min;
      // Kolmogorow-Smirnow-Test against uniform distribution:
      boolean flag = false;
      for(int j = 1, end = data.length - 1; j < end; j++) {
        if(Math.abs(j / (data.length - 2.) - (data[j] - min) / norm) > crit) {
          flag = true;
          break;
        }
      }
      if(!flag) {
        return false;
      }
    }
    return true;
  }