Returns the mean extension (length) of structure
@return
542868
protected double getMeanExtension() {
		Vector3d dimension = rotationAxisAligner.getDimension();
		return (dimension.x+dimension.y+dimension.z)/3;
	}
1285140
public int getLength() {
    // Alias, number of patterns
    int length = 4 + 4;

    if (this.identifierPatterns != null) {
      for (String identifier : this.identifierPatterns) {
        try {
          length += (4 + identifier.getBytes("UTF-16BE").length);
        } catch (UnsupportedEncodingException e) {
          log.error("Unable to encode to UTF-16BE.");
        }
      }
    }
    return length;
  }
767739
public double mean() {
        double total = 0;

        final int N = getNumElements();
        for( int i = 0; i < N; i++ ) {
            total += get(i);
        }

        return total/N;
    }
322341
@InterfaceAudience.Public
    public long getLength() {
        Number length = (Number) metadata.get("length");
        if (length != null) {
            return length.longValue();
        } else {
            return 0;
        }
    }
307533
@Pure
	public double getLength() {
		double length  = 0;
		for (final RoadPath p : this.paths) {
			length += p.getLength();
		}
		return length;
	}
236144
protected Float getExpressionLengthPx(MediaExpression e)
    {
        if (e.size() == 1) //the length requires exactly one value
        {
            Term<?> term = e.get(0);
            if (term instanceof TermLength)
                return pxLength((TermLength) term);
            else
                return null;
        }
        else
            return null;
    }
446361
public int getApproximateLength() {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getApproximateLength");

    if (approxLength == -1) approxLength = guessApproxLength();

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getApproximateLength", Integer.valueOf(approxLength));
    return approxLength;
  }
50528
public int length() {
        if (tc.isEntryEnabled())
            SibTr.entry(tc, "length");
        if (tc.isDebugEnabled())
            SibTr.debug(tc, "rc=", elements);
        if (tc.isEntryEnabled())
            SibTr.exit(tc, "length");

        return elements;
    }
1071225
@Pure
	public double getLength() {
		double length = this.roadSegments.getLength();
		if (isValidPrimitive()) {
			BusItineraryHalt halt = this.validHalts.get(0);
			assert halt != null;
			RoadSegment sgmt = halt.getRoadSegment();
			assert sgmt != null;
			Direction1D dir = this.roadSegments.getRoadSegmentDirectionAt(halt.getRoadSegmentIndex());
			assert dir != null;
			if (dir == Direction1D.SEGMENT_DIRECTION) {
				length -= halt.getPositionOnSegment();
			} else {
				length -= sgmt.getLength() - halt.getPositionOnSegment();
			}

			halt = this.validHalts.get(this.validHalts.size() - 1);
			assert halt != null;
			sgmt = halt.getRoadSegment();
			assert sgmt != null;
			dir = this.roadSegments.getRoadSegmentDirectionAt(halt.getRoadSegmentIndex());
			assert dir != null;
			if (dir == Direction1D.SEGMENT_DIRECTION) {
				length -= sgmt.getLength() - halt.getPositionOnSegment();
			} else {
				length -= halt.getPositionOnSegment();
			}

			if (length < 0.) {
				length = 0.;
			}
		}
		return length;
	}
620700
public double getTotalArea() {
		double area = 0;
		for (StructureInterface interf:members) {
			area+=interf.getTotalArea();
		}
		return area/members.size();
	}
197945
public int getFrameLength()
	{
		int length = frameData.length + FRAME_HEAD_SIZE;

		if (grouped)
		{
			length++;
		}
		if (encrypted)
		{
			length++;
		}
		if (lengthIndicator)
		{
			length += 4;
		}

		return length;
	}
1351464
public static double getMaximumExtend( final Structure structure ) {
		double[][] bounds = getAtomCoordinateBounds(structure);
		double xMax = Math.abs(bounds[0][0] - bounds[1][0]);
		double yMax = Math.abs(bounds[0][1] - bounds[1][1]);
		double zMax = Math.abs(bounds[0][2] - bounds[1][2]);
		return Math.max(xMax, Math.max(yMax, zMax));
	}
1240887
public double getMeanValue() {
        Lock lock = this.lock.readLock();
        lock.lock();
        try {
            return this.meanValue;
        } finally {
            lock.unlock();
        }
    }
903813
@Override
	public int getMaxLength() {
		int max = 0;
		boolean found = false;
		for (Constraint c : constraints) {
			int cM = c.getMaxLength();
			if (cM != -1) {
				max += cM;
				found = true;
			}
		}
		return found ? max : -1;
	}
923234
public int encodedTypeLength() {
    int ans = 3; // kind code for TUPLE plus the length
    if (fields != null)
      for (int i = 0; i < fields.length; i++)
        ans += fields[i].encodedTypeLength();
    return ans;
  }
101291
public double getLength() {
		double length = 0;
		if (!isEmpty()) {
			length = exteriorRing.getLength();
			if (interiorRings != null) {
				for (LinearRing interiorRing : interiorRings) {
					length += interiorRing.getLength();
				}
			}
		}
		return length;
	}
34026
final int getMinLength() {
		switch (this.type) {
		case CONCAT:
			int sum = 0;
			for (int i = 0; i < this.size(); i++)
				sum += this.getChild(i).getMinLength();
			return sum;

		case CONDITION:
		case UNION:
			if (this.size() == 0)
				return 0;
			int ret = this.getChild(0).getMinLength();
			for (int i = 1; i < this.size(); i++) {
				int min = this.getChild(i).getMinLength();
				if (min < ret)
					ret = min;
			}
			return ret;

		case CLOSURE:
		case NONGREEDYCLOSURE:
			if (this.getMin() >= 0)
				return this.getMin() * this.getChild(0).getMinLength();
			return 0;

		case EMPTY:
		case ANCHOR:
			return 0;

		case DOT:
		case CHAR:
		case RANGE:
		case NRANGE:
			return 1;

		case INDEPENDENT:
		case PAREN:
		case MODIFIERGROUP:
			return this.getChild(0).getMinLength();

		case BACKREFERENCE:
			return 0; // *******

		case STRING:
			return this.getString().length();

		case LOOKAHEAD:
		case NEGATIVELOOKAHEAD:
		case LOOKBEHIND:
		case NEGATIVELOOKBEHIND:
			return 0; // ***** Really?

		default:
			throw new RuntimeException("Token#getMinLength(): Invalid Type: "
					+ this.type);
		}
	}