/* (non-Javadoc)
@see org.joml.Matrix4dc#unprojectInvRay(org.joml.Vector2dc, int[], org.joml.Vector3d, org.joml.Vector3d)
337234
public Matrix4d unprojectInvRay(Vector2dc winCoords, int[] viewport, Vector3d originDest, Vector3d dirDest) {
        return unprojectInvRay(winCoords.x(), winCoords.y(), viewport, originDest, dirDest);
    }
965587
public Vector4f unprojectInv(Vector3fc winCoords, int[] viewport, Vector4f dest) {
        return unprojectInv(winCoords.x(), winCoords.y(), winCoords.z(), viewport, dest);
    }
776489
public Vector3i negate(Vector3i dest) {
        dest.x = -x;
        dest.y = -y;
        dest.z = -z;
        return dest;
    }
485607
public void unproject(double x, double y, double z, double[] out) {
    glu.gluUnProject(x, y, z, modelview, 0, projection, 0, viewp, 0, out, 0);
  }
1308901
protected void removeProvisonalProject() {
		if (!this.currProject.exists()) {
			this.currProject = null;
			return;
		}

		final IRunnableWithProgress op = new IRunnableWithProgress() {
			@SuppressWarnings("synthetic-access")
			@Override
			public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
				doRemoveProject(monitor);
			}
		};

		try {
			getContainer().run(true, true, new WorkspaceModifyDelegatingOperation(op));
		} catch (InvocationTargetException e) {
			final String title = NewWizardMessages.NewJavaProjectWizardPageTwo_error_remove_title;
			final String message = NewWizardMessages.NewJavaProjectWizardPageTwo_error_remove_message;
			ExceptionHandler.handle(e, getShell(), title, message);
		} catch (InterruptedException e) {
			// cancel pressed
		}
	}
1202808
def unpublish_iteration(project_id, iteration_id, custom_headers:nil)
      response = unpublish_iteration_async(project_id, iteration_id, custom_headers:custom_headers).value!
      nil
    end
723944
@Deprecated
    public void deleteProjectMembership(int membershipId) throws RedmineException {
        transport.deleteObject(Membership.class, Integer.toString(membershipId));
    }
1169047
def unproject(self, xy):
        
        (x, y) = xy
        lng = x/EARTH_RADIUS * RAD_TO_DEG
        lat = 2 * atan(exp(y/EARTH_RADIUS)) - pi/2 * RAD_TO_DEG
        return (lng, lat)
587689
@Override
    public void unset(String propName) {
        if (propName.equals("level")) {
            unsetLevel();
        }
        if (propName.equals("treeView")) {
            unsetTreeView();
        }
        super.unset(propName);
    }
364968
private void removeDuplicateRow(DoubleMatrix1D c,
			DoubleMatrix2D A, DoubleMatrix1D b, 
			DoubleMatrix1D lb, DoubleMatrix1D ub, 
			DoubleMatrix1D ylb, DoubleMatrix1D yub,
			DoubleMatrix1D zlb, DoubleMatrix1D zub) {
		//the position 0 is for empty rows, 1 is for row singleton and 2 for row doubleton
		int startingLength = 3;
		for(int i=startingLength; i<vRowLengthMap.length; i++){
			int[] vRowLengthMapI = vRowLengthMap[i];
			if(vRowLengthMapI == null || vRowLengthMapI.length < 1){
				//no rows has this number of nz
				continue;
			}
			
			boolean stop = false;
			for(int j=0; !stop && j<vRowLengthMapI.length; j++){
				short prow = (short)vRowLengthMapI[j];//the row of A that has this number of nz
				if(vRowPositions[prow].length==0 || prow < nOfSlackVariables){
					//the upper left part of A is diagonal if there are the slack variables:
					//there is no sparsity superset possible 
					continue;
				}
				short[] vRowPositionsProw = vRowPositions[prow];
				if(vRowPositionsProw.length != i){
					log.debug("Row "+prow+" has an unexpected number of nz: expected " + i + " but is " + vRowPositionsProw.length);
					throw new IllegalStateException();
				}
				for(int si=i; !stop && si<vRowLengthMap.length; si++){
					//look into rows with superset sparsity pattern
					int[] vRowLengthMapSI = vRowLengthMap[si];
					if(vRowLengthMapSI == null || vRowLengthMapSI.length < 1){
						continue;
					}
					for(int sj=0; sj<vRowLengthMapSI.length; sj++){
						if(si==i && sj <= j){
							continue;//look forward, not behind
						}
						short srow = (short)vRowLengthMapSI[sj];
						if(vRowPositions[srow].length==0){
							continue;
						}
						short[] vRowPositionsSrow = vRowPositions[srow];
						//same sparsity pattern?
						if(isSubsetSparsityPattern(vRowPositionsProw, vRowPositionsSrow)){
							log.debug("found superset sparsity pattern: row " + prow + " contained in row " + srow);
							
							//look for the higher number of coefficients that can be deleted
							Map<Double, List<Integer>> coeffRatiosMap = new HashMap<Double, List<Integer>>();
							for(short k=0; k<vRowPositionsProw.length; k++){
								short col = vRowPositionsProw[k];
								double APRL = A.getQuick(prow, col); 
								double ASRL = A.getQuick(srow, col);
								double ratio = -ASRL/APRL;
								//put the ratio and the column index in the map
								boolean added = false;
								for(Double keyRatio : coeffRatiosMap.keySet()){
									if(isZero(ratio - keyRatio)){
										coeffRatiosMap.get(keyRatio).add((int)col);
										added = true;
										break;
									}
								}
								if(!added){
									List<Integer> newList = new ArrayList<Integer>();
									newList.add((int)col);
									coeffRatiosMap.put(ratio, newList);
								}
							}
							//take the ratio(s) with the higher number of column indexes
							int maxNumberOfColumn = -1;
							List<Integer> candidatedColumns = null;
							for(Double keyRatio : coeffRatiosMap.keySet()){
								int size = coeffRatiosMap.get(keyRatio).size(); 
								if(size > maxNumberOfColumn){
									maxNumberOfColumn = size;
									candidatedColumns = coeffRatiosMap.get(keyRatio);
								}else if(size == maxNumberOfColumn){
									candidatedColumns.addAll(coeffRatiosMap.get(keyRatio));
								}
							}

							//look for the position with less column fill in
							short lessFilledColumn = -1;//cannot be greater
							int lessFilledColumnLength = this.originalMeq + 1;//cannot be greater
							for(short k=0; k<candidatedColumns.size(); k++){
								short col = candidatedColumns.get(k).shortValue();
								if(vColPositions[col].length>1 && vColPositions[col].length<lessFilledColumnLength ){
									lessFilledColumn = col;
									lessFilledColumnLength = vColPositions[col].length;
								}
							}
							log.debug("less filled column (" + lessFilledColumn +"): length=" + lessFilledColumnLength);
							double APRL = A.getQuick(prow, lessFilledColumn); 
							double ASRL = A.getQuick(srow, lessFilledColumn);
							double alpha = -ASRL/APRL;
							
							b.setQuick(srow, b.getQuick(srow) + alpha*b.getQuick(prow));
							//substitute A[prow] with A[prow] * alpha*A[row] for every nz entry of A[row]
							for(short t=0; t<vRowPositionsProw.length; t++){
								short cc = vRowPositionsProw[t];
								double nv = 0.;
								if(cc!=lessFilledColumn){
									nv = A.getQuick(srow, cc) + alpha*A.getQuick(prow, cc);
								}
								A.setQuick(srow, cc, nv);
								if(isZero(nv)){
									vRowPositions[srow] = removeElementFromSortedArray(vRowPositions[srow], cc);
									changeColumnsLengthPosition(cc, vColPositions[cc].length, vColPositions[cc].length-1);
									vColPositions[cc] = removeElementFromSortedArray(vColPositions[cc], srow);
									changeRowsLengthPosition(srow, vRowPositions[srow].length+1, vRowPositions[srow].length);
									A.setQuick(srow, cc, 0.);
								}
							}
							this.someReductionDone = true;
							stop = true;
							i=startingLength-1;//restart, ++ comes from the for loop
							break;
						}
					}
				}
			}
		}
	}
315810
public Matrix4f unprojectRay(Vector2fc winCoords, int[] viewport, Vector3f originDest, Vector3f dirDest) {
        return unprojectRay(winCoords.x(), winCoords.y(), viewport, originDest, dirDest);
    }
840470
public Vector4d transformProject(double x, double y, double z, double w, Vector4d dest) {
        double invW = 1.0 / (m03 * x + m13 * y + m23 * z + m33 * w);
        dest.set((m00 * x + m10 * y + m20 * z + m30 * w) * invW,
                 (m01 * x + m11 * y + m21 * z + m31 * w) * invW,
                 (m02 * x + m12 * y + m22 * z + m32 * w) * invW,
                 1.0);
        return dest;
    }
96821
@Override
	public void unregisterIrObs(IREventObserver obs)
	{
		if (obs != null && irObserver == obs)
		{
			irObserver = null;
		}
	}
346473
function deleteProject(_ref9, _ref10) {
    var state = _ref9.state,
        commit = _ref9.commit,
        rootState = _ref9.rootState;

    var _ref11 = _slicedToArray(_ref10, 2),
        pid = _ref11[0],
        localRemove = _ref11[1];

    if (localRemove) commit('c3s/project/SET_PROJECT', null);
    return makeRequest(commit, rootState.c3s.client.apis.Projects.delete_project, {
      id: pid
    }, undefined);
  }
748058
function deleteProject(project) {
	return project.delete()
	.catch((error) => {
		console.error("Project with ID: " + project.id + " couldn't be deleted.");
		console.trace(error);
		throw error;
	});
}
1087914
public void cleanupProjectArtifacts(final int projectId) {
    try {
      this.storageCleaner.cleanupProjectArtifacts(projectId);
    } catch (final Exception e) {
      log.error("Error occured during cleanup. Ignoring and continuing...", e);
    }
  }
1001979
function unmountComponentFromNode(instance, container, safely) {
	  if (false) {
	    ReactInstrumentation.debugTool.onBeginFlush();
	  }
	  ReactReconciler.unmountComponent(instance, safely);
	  if (false) {
	    ReactInstrumentation.debugTool.onEndFlush();
	  }
	
	  if (container.nodeType === DOC_NODE_TYPE) {
	    container = container.documentElement;
	  }
	
	  // http://jsperf.com/emptying-a-node
	  while (container.lastChild) {
	    container.removeChild(container.lastChild);
	  }
	}