This method returns the realization of the process at a certain time index.

@param timeIndex Time index at which the process should be observed
@return A vector of process realizations (on path)
174151
public RandomVariableInterface[] getProcessValue(int timeIndex)
	{
		// Thread safe lazy initialization
		synchronized(this) {
			if(discreteProcess == null || discreteProcess.length == 0)
			{
				doPrecalculateProcess();
			}
		}

		// Return value of process
		return discreteProcess[timeIndex];
	}
74792
public RTObject getTemporaryVariableWithName(String name, int contextIndex) {
		if (contextIndex == -1)
			contextIndex = getCurrentElementIndex() + 1;

		Element contextElement = getCallStack().get(contextIndex - 1);
		RTObject varValue = contextElement.temporaryVariables.get(name);

		return varValue;
	}
202302
private RandomVariableInterface getDrift(int timeIndex, int componentIndex, RandomVariableInterface[] realizationAtTimeIndex, RandomVariableInterface[] realizationPredictor) {

		// Check if this LIBOR is already fixed
		if(getTime(timeIndex) >= this.getLiborPeriod(componentIndex)) {
			return null;
		}

		/*
		 * We implemented several different methods to calculate the drift
		 */
		if(driftApproximationMethod == Driftapproximation.PREDICTOR_CORRECTOR && realizationPredictor != null) {
			RandomVariableInterface drift					= getDriftEuler(timeIndex, componentIndex, realizationAtTimeIndex);
			RandomVariableInterface driftEulerWithPredictor	= getDriftEuler(timeIndex, componentIndex, realizationPredictor);
			drift = drift.add(driftEulerWithPredictor).div(2.0);

			return drift;
		}
		else if(driftApproximationMethod == Driftapproximation.LINE_INTEGRAL && realizationPredictor != null) {
			return getDriftLineIntegral(timeIndex, componentIndex, realizationAtTimeIndex, realizationPredictor);
		}
		else {
			return getDriftEuler(timeIndex, componentIndex, realizationAtTimeIndex);
		}
	}
288209
@SuppressWarnings("unchecked")
	@Override
	public <T> T get(int index) {
		return (T) array.get(index).getObject();
	}
350081
public static String getSerializedVectorClocks(List<VectorClock> vectorClocks) {
        List<VectorClockWrapper> vectorClockWrappers = new ArrayList<VectorClockWrapper>();
        for(VectorClock vc: vectorClocks) {
            vectorClockWrappers.add(new VectorClockWrapper(vc));
        }
        String serializedVC = "";
        try {
            serializedVC = mapper.writeValueAsString(vectorClockWrappers);
        } catch(Exception e) {
            e.printStackTrace();
        }
        return serializedVC;
    }
95402
@Override
    public AtlasGraphIndex getGraphIndex(String indexName) {
        TitanGraphIndex index = management.getGraphIndex(indexName);
        return GraphDbObjectFactory.createGraphIndex(index);
    }
1202826
public Timestamp getTimestamp( int index ) throws OdaException
	{
		java.util.Date value = (java.util.Date) getFieldValue(index);
		return value==null?new Timestamp(0):new Timestamp(value.getTime());
	}
357258
public Reactor getReactorByIndex(int index) {
		if (index < 0 || index > reactorSet.length - 1) {
			throw new ArrayIndexOutOfBoundsException();
		}
		return reactorSet[index];
	}
455639
public <T extends MPBase> T getByIndex(int index) {
        T resource = (T) _resourceArray.get(index);
        return resource;
    }
1214161
@Override
	public RandomVariable getBrownianIncrement(int timeIndex, int factor) {
		RandomVariable brownianIncrement = new RandomVariableFromDoubleArray(0.0);
		for(int factorIndex=0; factorIndex<factorLoadings[factor].length; factorIndex++) {
			if(factorLoadings[factor][factorIndex] != 0) {
				RandomVariable independentFactor = uncollelatedFactors.getBrownianIncrement(timeIndex, factorIndex);
				brownianIncrement = brownianIncrement.addProduct(independentFactor, factorLoadings[factor][factorIndex]);
			}
		}
		return brownianIncrement;
	}
156576
public IVector getVectorFromRow(int index) {
        IVector result = new IVector(columns);
        for (int i = 0; i < columns; i++) {
            result.realvector[i] = realmatrix[index][i];
            result.imagvector[i] = imagmatrix[index][i];
        }
        return result;
    }
1105729
public Vector3D getVertex(int index) {
        tmpV.setX(cornerX.get(index));
        tmpV.setY(cornerY.get(index));
        tmpV.setZ(cornerZ.get(index));
        calcG();
        return tmpV;
    }
431208
@SuppressWarnings("unchecked")
    public <A extends Comparable<?>> TimePath<A> get(TimePath<A> path) {
        TimePath<A> newPath = getTime(toString(path), (Class<A>) path.getType());
        return addMetadataOf(newPath, path);
    }
1223780
private synchronized Long getMinTransformedProcessId() {
        if (!CollectionUtils.isEmpty(progress)) {
            Long processId = Collections.min(progress.keySet());
            StageProgress stage = progress.get(processId);
            // stage可能为空，针对select未完成时，对应的值就为null
            if (stage != null && stage != nullProgress && stage.getStage().isTransform()) {
                return processId;
            }
        }

        return null;
    }
1295473
@Bench(runs = RUNS, beforeEachRun = "vectorAdd")
    public void vectorGet() {
        for (int i = 0; i < vector.size(); i++) {
            vector.get(i);
        }
    }
35458
@Override
	public RandomVariable getProcessValue(int timeIndex, int componentIndex) {
		// Thread safe lazy initialization
		synchronized(this) {
			if (discreteProcess == null || discreteProcess.length == 0) {
				doPrecalculateProcess();
			}
		}

		if(discreteProcess[timeIndex][componentIndex] == null) {
			throw new NullPointerException("Generation of process component " + componentIndex + " at time index " + timeIndex + " failed. Likely due to out of memory");
		}

		// Return value of process
		return discreteProcess[timeIndex][componentIndex];
	}
981846
@Override
	public CallSequence get(int index)
	{
		if (indics == null)
		{
			size();
		}
		Pair<Integer, Integer> v = indics.get(index);

		int r = v.first;

		if (r == 0)
		{
			CallSequence seq = getVariables();
			seq.add(AstFactory.newASkipStm(new LexLocation()));
			return seq;

		} else
		{

			TestSequence rtests = repeat.getTests();
			int count = rtests.size();
			int[] c = new int[r];

			for (int i = 0; i < r; i++)
			{
				c[i] = count;
			}

			Permutor p = new Permutor(c);
			int[] select = null;
			for (int i = 0; i < v.second; i++)
			{
				select = p.next();
			}

			CallSequence seq = getVariables();

			for (int i = 0; i < r; i++)
			{
				seq.addAll(rtests.get(select[i]));
			}
			return seq;
		}

	}