Computes the null space from an SVD.  For more information see {@link SingularOps_DDRM#nullSpace}.
@return Null space vector.
191841
public SimpleMatrix nullSpace() {
        // TODO take advantage of the singular values being ordered already
        if( is64 ) {
            return SimpleMatrix.wrap(SingularOps_DDRM.nullSpace((SingularValueDecomposition_F64)svd, null, tol));
        } else {
            return SimpleMatrix.wrap(SingularOps_FDRM.nullSpace((SingularValueDecomposition_F32)svd, null, (float)tol));
        }
    }
270718
private Vector3d getReferenceAxisCylic() {
		if (rotationGroup.getPointGroup().equals("C2")) {
			Vector3d vr = new Vector3d(subunits.getOriginalCenters().get(0));
			vr.sub(subunits.getCentroid());
			vr.normalize();
			return vr;
		}

		// get principal axis vector that is perpendicular to the principal
		// rotation vector
		Vector3d vmin = null;
		double dotMin = 1.0;
		for (Vector3d v: principalAxesOfInertia) {
			if (Math.abs(principalRotationVector.dot(v)) < dotMin) {
				dotMin = Math.abs(principalRotationVector.dot(v));
				vmin = new Vector3d(v);
			}
		}
		if (principalRotationVector.dot(vmin) < 0) {
			vmin.negate();
		}

		return vmin;
	}
649519
public INDArray getRange() {
        if (range == null) {
            try (MemoryWorkspace ws = Nd4j.getMemoryManager().scopeOutOfWorkspaces()) {
                range = upper.sub(lower);
            }
        }
        return range;
    }
74575
public int nullity() {
        if( is64 ) {
            return SingularOps_DDRM.nullity((SingularValueDecomposition_F64)svd, 10.0 * UtilEjml.EPS);
        } else {
            return SingularOps_FDRM.nullity((SingularValueDecomposition_F32)svd, 5.0f * UtilEjml.F_EPS);
        }
    }
119617
function() {
            	if (!this.isSquare) { return null; }
            	var els = [], n = this.elements.length;
            	for (var i = 0; i < n; i++) {
            	    els.push(this.elements[i][i]);
            	}
            	return $V(els);
                }
414986
public Double getDataNull() {

		Double dataNull = null;
		if (griddedCoverage != null) {
			dataNull = griddedCoverage.getDataNull();
		}

		return dataNull;
	}
573654
@Override
  public Row<K, N, V> peekLast() {
    return rowsList != null && rowsList.size() > 0 ? rowsList.get(rowsList.size()-1) : null;
  }
171113
public String getNamespace()
    {
        String strTargetVersion = this.getProperty("version");
        if (strTargetVersion == null)
            strTargetVersion = this.getDefaultVersion();
        return this.getMessageControl().getNamespaceFromVersion(strTargetVersion);
    }
215830
def nullval(cls):
        """"""

        d = dict(cls.__dict__.items())

        for k in d:
            d[k] = 0

        d['sl'] = cls.sl
        d[cls.level] = 0

        return cls(**d)
928914
def _svd(cls, matrix, num_concepts=5):
        
        u, s, v = svds(matrix, k=num_concepts)
        return u, s, v
1041568
protected static Dimension getSizeViaResize ()
    {
        BufferedReader bin = null;
        try {
            Process proc = Runtime.getRuntime().exec("resize");
            InputStream in = proc.getInputStream();
            bin = new BufferedReader(new InputStreamReader(in));
            Pattern regex = Pattern.compile("([0-9]+)");
            String line;
            int columns = -1, lines = -1;
            while ((line = bin.readLine()) != null) {
                if (line.indexOf("COLUMNS") != -1) {
                    Matcher match = regex.matcher(line);
                    if (match.find()) {
                        columns = safeToInt(match.group());
                    }
                } else if (line.indexOf("LINES") != -1) {
                    Matcher match = regex.matcher(line);
                    if (match.find()) {
                        lines = safeToInt(match.group());
                    }
                }
            }

            if (columns != -1 && lines != -1) {
                return new Dimension(columns, lines);
            }
            return null;

        } catch (PatternSyntaxException pse) {
            return null; // logging a warning here may be annoying
        } catch (SecurityException se) {
            return null; // logging a warning here may be annoying
        } catch (IOException ioe) {
            return null; // logging a warning here may be annoying
        } finally {
            StreamUtil.close(bin);
        }
    }
800132
public String cluster() {
    if (d1 == 0) {
      // Application portion is empty
      return null;
    } else {
      return (dN > 0 && dN == asg.length()) ? asg() : substr(asg, 0, dN);
    }
  }
632825
public DenseMatrix range() {
        if (!full) {
            throw new IllegalStateException("This is not a FULL singular value decomposition.");
        }

        int nr = 0;
        DenseMatrix rnge = Matrix.zeros(m, rank());
        for (int j = 0; j < n; j++) {
            if (s[j] > tol) {
                for (int i = 0; i < m; i++) {
                    rnge.set(i, nr, U.get(i, j));
                }
                nr++;
            }
        }
        return rnge;
    }
392521
public Vector<Object> marshallize()
    {
        Vector<Object> parameters = new Vector<Object>();        
        parameters.add(REFERENCE_REQUIREMENT_IDX, requirement.marshallize());
        parameters.add(REFERENCE_SPECIFICATION_IDX, specification.marshallize());
        parameters.add(REFERENCE_SUT_IDX, systemUnderTest.marshallize());
        parameters.add(REFERENCE_SECTIONS_IDX, StringUtils.defaultString(sections));
        
        parameters.add(REFERENCE_LAST_EXECUTION_IDX, lastExecution != null ? lastExecution.marshallize() : Execution.none().marshallize());
        return parameters;
    }
1162014
@Nonnull
  public static String getWithoutAnySpaces (@Nullable final String sStr)
  {
    if (sStr == null)
      return "";

    // Trim first
    final char [] aChars = sStr.trim ().toCharArray ();
    final StringBuilder aResult = new StringBuilder (aChars.length);
    for (final char c : aChars)
      if (!Character.isWhitespace (c) && !Character.isSpaceChar (c))
        aResult.append (c);
    return aResult.toString ();
  }
751182
@Restricted(DoNotUse.class)
    @Exported
    public @Nonnull String getDescription() {
        Node node = getNode();
        return (node != null) ? node.getNodeDescription() : null;
    }
452307
@Nonnull
  @ReturnsMutableCopy
  public Matrix getD ()
  {
    final Matrix aNewMatrix = new Matrix (m_nDim, m_nDim);
    final double [] [] aNewArray = aNewMatrix.internalGetArray ();
    for (int nRow = 0; nRow < m_nDim; nRow++)
    {
      final double [] aDstRow = aNewArray[nRow];
      Arrays.fill (aDstRow, 0.0);
      aDstRow[nRow] = m_aEVd[nRow];

      final double dEVe = m_aEVe[nRow];
      if (dEVe > 0)
        aDstRow[nRow + 1] = dEVe;
      else
        if (dEVe < 0)
          aDstRow[nRow - 1] = dEVe;
    }
    return aNewMatrix;
  }