Uses of Class
jline.util.Matrix

Packages that use Matrix

Package	Description
jline.api	Procedural algorithms for solving stochastic models
jline.io	Input/output from the command line or XML files.
jline.lang	Abstractions to declare basic elements of a model.
jline.lang.layered	This package contains the classes used the specify LayeredNetwork objects
jline.lang.nodes	This package contains the classes used the specify Network objects
jline.lang.processes	This package contains statistical distributions used to specify arrival rates, service rates, and item popularities
jline.lang.sections	Classes that model the individual sections that form a Network node
jline.lang.state	Classes that model the state of a network and its individual nodes
jline.lib.thirdparty	Classes that partially migrate third-party libraries to Java
jline.solvers	Solver superclasses and related data structures.
jline.solvers.ctmc	Solution approaches based on Continuous-Time Markov Chain solution
jline.solvers.fluid	Solution approaches based on mean-field and fluid approximations.
jline.solvers.fluid.analyzers	Classes that embody different fluid ODE analysis algorithms
jline.solvers.fluid.odes	Classes that generate the ordinary differential equations (ODEs) used in the Fluid solver
jline.solvers.fluid.smoothing	Classes that implement the smoothing method for transient fluid analysis
jline.solvers.jmt	Wrapper for the Java Modelling Tools (JMT) suite solvers
jline.solvers.ln	LINE's native Layered Network (LN) solver
jline.solvers.mam	Analysis approaches based on matrix-analytic methods
jline.solvers.mva	Analysis approaches based on Mean-Value Analysis (MVA)
jline.solvers.mva.handlers	Classes for coordinate the execution and performance metric estimation in MVA-based algorithms
jline.solvers.nc	Analysis approaches based on Normalizing Costant (NC) methods
jline.solvers.ssa	Analysis approaches based on the Stochastic Simulation Algorithm (SSA) for Markov chains
jline.util	This package contains some fundamental data structures and utilities

Uses of Matrix in jline.api

Methods in jline.api that return Matrix

Modifier and Type	Method	Description
static Matrix	CACHE.cache_erec(Matrix gamma, Matrix m)	Computes the cache miss rate using an exact recursive method.
static Matrix	CACHE.cache_prob_asy(Matrix gamma, Matrix m)	Estimate asymptotic values of the cache state probabilities at steady-state.
static Matrix	CACHE.cache_prob_erec(Matrix gamma, Matrix m)	Computes the cache state probabilities using an exact recursive method.
static Matrix	CACHE.cache_prob_rayint(Matrix gamma, Matrix m)	Computes the cache state probabilities using the ray method.
static Matrix	CACHE.cache_t_hlru(Matrix gamma, Matrix m)	Computes the characteristic time of each list in the TTL approximation of h-LRU.
static Matrix	CACHE.cache_t_hlru_aux(double[] x, Matrix gamma, Matrix m, int n, int h)	Auxiliary function for cache_t_hlru inner optimization.
static Matrix	CACHE.cache_t_lrum(Matrix gamma, Matrix m)	Computes the characteristic time of each list in the TTL approximation of LRU(m).
static Matrix	CACHE.cache_ttl_hlru(Matrix[] lambda, Matrix m)	Solve hierarchical least-recently-used caches h-LRU using the TTL approximation.
static Matrix	CACHE.cache_ttl_lrua(Matrix[] lambda, Matrix[][] R, Matrix m)
static Matrix	CACHE.cache_ttl_lrum(Matrix[] gamma, Matrix m)	Solve multi-list least-recently-used caches LRU(m) using the TTL approximation.
static Matrix	CACHE.cache_ttl_lrum_map(Matrix[][] D0Matrix, Matrix[][] D1Matrix, Matrix m)
static Matrix	CACHE.cache_xi_bvh(Matrix gamma, Matrix m)	Computes the cache xi terms using the iterative method used in Gast-van Houdt, SIGMETRICS 2015.
static Matrix	MC.ctmc_makeinfgen(Matrix Q)	Normalize the input matrix diagonal to be an infinitesimal generator.
static Matrix	MC.ctmc_rand(int length)	Form a random infinitesimal generator of a CTMC
static Matrix	MC.ctmc_solve(Matrix Q)	Return the steady-state probability of a CTMC.
static Matrix	MC.ctmc_timereverse(Matrix Q)	Compute the infinitesimal generator of the time-reserved CTMC
static Matrix	MC.ctmc_uniformization(Matrix pi0, Matrix Q, double t)	Return the transient probability distribution of the CTMC via the uniformization method.
static Matrix	MC.dtmc_makestochastic(Matrix P)	Normalize a given non-negative matrix into a DTMC
static Matrix	MC.dtmc_rand(int length)	Form a random infinitesimal generator of a DTMC
static Matrix	MC.dtmc_solve(Matrix P)	Returns the steady-state solution of a DTMC.
static Matrix	MC.dtmc_stochcomp(Matrix P, List<Integer> I)	Returns the stochastic complement of a DTMC
static Matrix	MC.dtmc_timereverse(Matrix P)	Compute the infinitesimal generator of the time-reversed DTMC.
static Matrix	FJ.findPaths(NetworkStruct sn, Matrix P, int startNode, int endNode, int r, ArrayList<Integer> toMerge, Matrix QN, Matrix TN, double currentTime, Matrix fjclassmap, Matrix fjforkmap, Network nonfjmodel)	Finds the response times along each path leading out of startNode up to (and not including) endNode
static Matrix	FJ.findPathsCS(NetworkStruct sn, Matrix P, int curNode, int endNode, int curClass, ArrayList<Integer> toMerge, Matrix QN, Matrix TN, double currentTime, Matrix fjclassmap, Matrix fjforkmap, Network nonfjmodel)	Finds the response times along each path leading out of curNode up to (and not including) endNode Variant for models with class switching
static Matrix	CACHE.hlruTime(double[] x, Matrix gamma, Matrix m, int n, int h)
static Matrix	MAM.map_acf(MatrixCell MAP)	Computes the autocorrelation function (ACF) for a given MAP using a default lag of 1.
static Matrix	MAM.map_acf(MatrixCell MAP, Matrix lags)	Computes the autocorrelation function (ACF) for a given MAP at multiple lags using a MatrixCell.
static Matrix	MAM.map_acf(Matrix D0, Matrix D1)	Computes the autocorrelation function (ACF) for a given MAP using a default lag of 1.
static Matrix	MAM.map_acf(Matrix D0, Matrix D1, int lag)	Computes the autocorrelation function (ACF) for a given MAP at a specific lag.
static Matrix	MAM.map_acf(Matrix D0, Matrix D1, Matrix lags)	Computes the autocorrelation function (ACF) for a given MAP at multiple lags.
static Matrix	MAM.map_cdf(MatrixCell MAP, Matrix points)	Computes the cumulative distribution function (CDF) of the inter-arrival times of a MAP stored in a MatrixCell that contains the MAP's transition matrices.
static Matrix	MAM.map_cdf(Matrix D0, Matrix D1, Matrix points)	Computes the cumulative distribution function (CDF) of the inter-arrival times of a Markovian Arrival Process (MAP).
static Matrix	MAM.map_embedded(MatrixCell MAP)	Computes the embedded discrete-time Markov chain (DTMC) matrix of a MAP given as a MatrixCell.
static Matrix	MAM.map_embedded(Matrix D0, Matrix D1)	Computes the embedded discrete-time Markov chain (DTMC) matrix of a MAP.
static Matrix	MAM.map_infgen(MatrixCell MAP)	Computes the infinitesimal generator matrix (Q) of the Continuous-Time Markov Chain (CTMC) underlying a Markovian Arrival Process (MAP).
static Matrix	MAM.map_infgen(Matrix D0, Matrix D1)	Computes the infinitesimal generator matrix (Q) of the Continuous-Time Markov Chain (CTMC) underlying a Markovian Arrival Process (MAP).
static Matrix	MAM.map_pie(MatrixCell MAP)	Computes the steady-state probability vector of the embedded DTMC of a MAP stored in a MatrixCell that contains the MAP's transition matrices.
static Matrix	MAM.map_pie(Matrix D0, Matrix D1)	Computes the steady-state probability vector of the embedded Discrete Time Markov Chain (DTMC) associated with a Markovian Arrival Process (MAP).
static Matrix	MAM.map_piq(MatrixCell MAP)	Computes the steady-state vector (pi) of the Continuous-Time Markov Chain (CTMC) underlying a Markovian Arrival Process (MAP).
static Matrix	MAM.map_piq(Matrix D0, Matrix D1)	Computes the steady-state vector (pi) of the Continuous-Time Markov Chain (CTMC) underlying a Markovian Arrival Process (MAP).
static Matrix	MAM.map_varcount(MatrixCell MAP, Matrix t)	Computes the variance of the counts in a MAP over multiple time periods using a MatrixCell.
static Matrix	MAM.map_varcount(Matrix D0, Matrix D1, Matrix t)	Computes the variance of the counts in a MAP over multiple time periods.
static Matrix	MAM.mmap_backward_moment(MatrixCell MMAP, Matrix ORDERS)	Computes the backward moments of an MMAP for specified orders with normalization.
static Matrix	MAM.mmap_backward_moment(MatrixCell MMAP, Matrix ORDERS, int NORM)	Computes the backward moments of an MMAP for specified orders.
static Matrix	MAM.mmap_count_idc(MatrixCell MMAP, double t)	Computes the index of dispersion for counts (IDC) for a Markovian Arrival Process with marked arrivals (MMAP) over a time period.
static Matrix	MAM.mmap_count_lambda(MatrixCell mmap)	Computes the arrival rate vector of the counting process for the given Marked MAP (MMAP).
static Matrix	MAM.mmap_count_mean(MatrixCell MMAP, double t)	Computes the mean count vector of events of different types in a Markovian Arrival Process with marked arrivals (MMAP) over a time period.
static Matrix	MAM.mmap_count_var(MatrixCell MMAP, double t)	Computes the variance of the count vector of events of different types in a Markovian Arrival Process with marked arrivals (MMAP) over a time period.
static Matrix	MAM.mmap_cross_moment(MatrixCell mmap, int k)	Computes the k-th cross-moment matrix for a given MMAP.
static Matrix	MAM.mmap_forward_moment(MatrixCell MMAP, Matrix ORDERS)	Computes the forward moments of an MMAP for specified orders with normalization.
static Matrix	MAM.mmap_forward_moment(MatrixCell MMAP, Matrix ORDERS, int NORM)	Computes the forward moments of an MMAP for specified orders.
static Matrix	MAM.mmap_idc(MatrixCell MMAP)	Computes the asymptotic index of dispersion for counts (IDC) for a Markovian Arrival Process with marked arrivals (MMAP).
static Matrix	MAM.mmap_lambda(MatrixCell MMAP)	Alias for mmap_count_lambda.
static Matrix	MAM.mmap_pc(MatrixCell MMAP)	Computes the proportion of counts (PC) for each type in a Markovian Arrival Process with marked arrivals (MMAP).
static Matrix	TRACE.mtrace_mean(double[] trace, int ntypes, int[] type)	Computes the mean of a trace, divided by types.
static Matrix	PFQN.pfqn_cdfun(Matrix nvec, Map<Station,SerializableFunction<Matrix,Double>> cdscaling, List<Station> stations)	Evaluate class-dependent (CD) scaling function
protected static Matrix	PFQN.pfqn_le_hessian(Matrix L, Matrix N, Matrix u0)	Auxiliary function to compute the Hessian used in the logistic expansion method
protected static Matrix	PFQN.pfqn_le_hessianZ(Matrix L, Matrix N, Matrix Z, Matrix u, double v)	Auxiliary function to compute the Hessian used in the logistic expansion method in models with delays
static Matrix	PFQN.pfqn_lldfun(Matrix n, Matrix lldscaling, Matrix nservers)	Evaluate limited-load dependent (LLD) function
static Matrix	PFQN.pfqn_mu_ms(int N, int m, int c)
static Matrix	PFQN.pfqn_mushift(Matrix mu, int k)	Shifts a load-dependent scaling vector by one position
static Matrix	PFQN.pfqn_nca(Matrix L, int N, Matrix alpha)
static Matrix	SN.snGetAvgArvRFromTput(NetworkStruct sn, Matrix TN, Matrix TH)	Calculates the average arrival rates at each station from the network throughputs.

Methods in jline.api that return types with arguments of type Matrix

Modifier and Type	Method	Description
static Map<Integer[],Matrix>	MAM.mmap_sigma2(MatrixCell mmap)	Computes the second-order sigma values (covariances) for a given MMAP.
static Map<StatefulNode,Matrix>	SN.snGetStateAggr(NetworkStruct sn)	Aggregates the state of the network.

Methods in jline.api with parameters of type Matrix

Modifier and Type	Method	Description
static Matrix	CACHE.cache_erec(Matrix gamma, Matrix m)	Computes the cache miss rate using an exact recursive method.
static Ret.cacheGammaLp	CACHE.cache_gamma_lp(Matrix[] lambda, Matrix[][] R)	Computes access factors for the cache.
static Ret.cacheMissRayInt	CACHE.cache_miss_rayint(Matrix gamma, Matrix m, MatrixCell lambda)	Estimates the cache miss rate and related metrics using the ray method for PDEs.
static Ret.cacheMVA	CACHE.cache_mva(Matrix gamma, Matrix m)	Exact recursive solution of the caching model.
static Matrix	CACHE.cache_prob_asy(Matrix gamma, Matrix m)	Estimate asymptotic values of the cache state probabilities at steady-state.
static Matrix	CACHE.cache_prob_erec(Matrix gamma, Matrix m)	Computes the cache state probabilities using an exact recursive method.
static Matrix	CACHE.cache_prob_rayint(Matrix gamma, Matrix m)	Computes the cache state probabilities using the ray method.
static Ret.cacheRayInt	CACHE.cache_rayint(Matrix gamma, Matrix m)	Approximate the normalizing constant of the cache steady state distribution using the ray method.
static Matrix	CACHE.cache_t_hlru(Matrix gamma, Matrix m)	Computes the characteristic time of each list in the TTL approximation of h-LRU.
static Matrix	CACHE.cache_t_hlru_aux(double[] x, Matrix gamma, Matrix m, int n, int h)	Auxiliary function for cache_t_hlru inner optimization.
static Matrix	CACHE.cache_t_lrum(Matrix gamma, Matrix m)	Computes the characteristic time of each list in the TTL approximation of LRU(m).
static Matrix	CACHE.cache_ttl_hlru(Matrix[] lambda, Matrix m)	Solve hierarchical least-recently-used caches h-LRU using the TTL approximation.
static Matrix	CACHE.cache_ttl_lrua(Matrix[] lambda, Matrix[][] R, Matrix m)
static Matrix	CACHE.cache_ttl_lrum(Matrix[] gamma, Matrix m)	Solve multi-list least-recently-used caches LRU(m) using the TTL approximation.
static Matrix	CACHE.cache_ttl_lrum_map(Matrix[][] D0Matrix, Matrix[][] D1Matrix, Matrix m)
static Matrix	CACHE.cache_xi_bvh(Matrix gamma, Matrix m)	Computes the cache xi terms using the iterative method used in Gast-van Houdt, SIGMETRICS 2015.
static Ret.cacheXiFp	CACHE.cache_xi_fp(Matrix gamma, Matrix m, Matrix xi)	Estimate cache xi terms using a fixed-point algorithm.
static Ret.pfqnNcXQ	PFQN.compute_norm_const(Matrix L, Matrix N, Matrix Z, SolverOptions options)	Run a normalizing constant solution method in a load-independent model
static Ret.pfqnNc	PFQN.compute_norm_const_ld(Matrix L, Matrix N, Matrix Z, Matrix mu, SolverOptions options)	Run a normalizing constant solution method in a load-dependent model
static Matrix	MC.ctmc_makeinfgen(Matrix Q)	Normalize the input matrix diagonal to be an infinitesimal generator.
static Ret.ctmcSimulation	MC.ctmc_simulate(Matrix Q, double[] pi0, int n)	Form a random infinitesimal generator of CTMC
static Matrix	MC.ctmc_solve(Matrix Q)	Return the steady-state probability of a CTMC.
static Matrix	MC.ctmc_timereverse(Matrix Q)	Compute the infinitesimal generator of the time-reserved CTMC
static Matrix	MC.ctmc_uniformization(Matrix pi0, Matrix Q, double t)	Return the transient probability distribution of the CTMC via the uniformization method.
static Matrix	MC.dtmc_makestochastic(Matrix P)	Normalize a given non-negative matrix into a DTMC
static Matrix	MC.dtmc_solve(Matrix P)	Returns the steady-state solution of a DTMC.
static Matrix	MC.dtmc_stochcomp(Matrix P, List<Integer> I)	Returns the stochastic complement of a DTMC
static Matrix	MC.dtmc_timereverse(Matrix P)	Compute the infinitesimal generator of the time-reversed DTMC.
protected static Ret.pfqnLinearizerCore	PFQN.egflinearizer_core(Matrix L, int M, int R, Matrix N_1, Matrix Z, Matrix Q, Matrix[] Delta, SchedStrategy[] type, double tol, int maxiter, Matrix alpha)	Core method for the extended general form linearizer.
protected static Ret.pfqnLinearizerEstimate	PFQN.egflinearizer_estimate(Matrix L, int M, int R, Matrix N_1, Matrix Z, Matrix Q, Matrix[] Delta, Matrix W, Matrix alpha)	Estimate method for the extended general form linearizer.
protected static Ret.pfqnLinearizerForwardMVA	PFQN.egflinearizer_forwardMVA(Matrix L, int M, int R, SchedStrategy[] type, Matrix N_1, Matrix Z, Matrix[] Q_1)	Forward Mean Value Analysis method for the extended general form linearizer.
static Matrix	FJ.findPaths(NetworkStruct sn, Matrix P, int startNode, int endNode, int r, ArrayList<Integer> toMerge, Matrix QN, Matrix TN, double currentTime, Matrix fjclassmap, Matrix fjforkmap, Network nonfjmodel)	Finds the response times along each path leading out of startNode up to (and not including) endNode
static Matrix	FJ.findPathsCS(NetworkStruct sn, Matrix P, int curNode, int endNode, int curClass, ArrayList<Integer> toMerge, Matrix QN, Matrix TN, double currentTime, Matrix fjclassmap, Matrix fjforkmap, Network nonfjmodel)	Finds the response times along each path leading out of curNode up to (and not including) endNode Variant for models with class switching
static Matrix	CACHE.hlruTime(double[] x, Matrix gamma, Matrix m, int n, int h)
protected static Ret.pfqnLinearizerMSCore	PFQN.linearizerms_core(Matrix L, int M, int R, Matrix N_1, Matrix Z, Matrix nservers, Matrix Q, Matrix P, Matrix PB, Matrix[] Delta, Matrix type, double tol, int maxiter)
protected static Ret.pfqnLinearizerMSEstimate	PFQN.linearizerms_estimate(int M, int R, Matrix N_1, Matrix nservers, Matrix Q, Matrix P, Matrix PB, Matrix[] Delta)
protected static Ret.pfqnLinearizerMSForwardMVA	PFQN.linearizerms_forwardMVA(Matrix L, int M, int R, Matrix N_1, Matrix Z, Matrix nservers, Matrix type, Matrix[] Q_1, Matrix[] P_1, Matrix PB_1)
static Ret.lossnErlangFP	LOSSN.lossn_erlangfp(Matrix nuVec, Matrix Amat, Matrix cVec)	This method calculates the Erlang fixed point approximation for loss networks.
static Matrix	MAM.map_acf(MatrixCell MAP, Matrix lags)	Computes the autocorrelation function (ACF) for a given MAP at multiple lags using a MatrixCell.
static Matrix	MAM.map_acf(Matrix D0, Matrix D1)	Computes the autocorrelation function (ACF) for a given MAP using a default lag of 1.
static Matrix	MAM.map_acf(Matrix D0, Matrix D1, int lag)	Computes the autocorrelation function (ACF) for a given MAP at a specific lag.
static Matrix	MAM.map_acf(Matrix D0, Matrix D1, Matrix lags)	Computes the autocorrelation function (ACF) for a given MAP at multiple lags.
static double[]	MAM.map_acfc(Matrix D0, Matrix D1, int[] lags, double u)	Computes the autocorrelation function coefficients (ACFC) for a MAP counting process.
static Matrix	MAM.map_cdf(MatrixCell MAP, Matrix points)	Computes the cumulative distribution function (CDF) of the inter-arrival times of a MAP stored in a MatrixCell that contains the MAP's transition matrices.
static Matrix	MAM.map_cdf(Matrix D0, Matrix D1, Matrix points)	Computes the cumulative distribution function (CDF) of the inter-arrival times of a Markovian Arrival Process (MAP).
static Matrix	MAM.map_embedded(Matrix D0, Matrix D1)	Computes the embedded discrete-time Markov chain (DTMC) matrix of a MAP.
static double	MAM.map_gamma(Matrix D0, Matrix D1)	Computes the gamma parameter for a MAP, which is the ratio of the ACF values at lag 2 and lag 1.
static double	MAM.map_idc(Matrix D0, Matrix D1)	Computes the asymptotic index of dispersion (IDC) for a Markovian Arrival Process (MAP).
static Matrix	MAM.map_infgen(Matrix D0, Matrix D1)	Computes the infinitesimal generator matrix (Q) of the Continuous-Time Markov Chain (CTMC) underlying a Markovian Arrival Process (MAP).
static double	MAM.map_lambda(Matrix D0, Matrix D1)	Computes the arrival rate (lambda) of a Markovian Arrival Process (MAP).
static MatrixCell	MAM.map_mark(MatrixCell MAP, Matrix prob)	Creates a Marked Markovian Arrival Process (MMAP) by marking a given Markovian Arrival Process (MAP) with additional phases based on specified marking probabilities.
static double	MAM.map_mean(Matrix D0, Matrix D1)	Computes the mean inter-arrival time of a Markovian Arrival Process (MAP).
static double	MAM.map_moment(Matrix D0, Matrix D1, int order)	Computes the raw moments of the inter-arrival times of a Markovian Arrival Process (MAP).
static MatrixCell	MAM.map_normalize(Matrix D0, Matrix D1)	Sanitizes the (D0, D1) matrices of a Markovian Arrival Process (MAP) by ensuring all elements are non-negative and adjusting diagonal elements.
static Matrix	MAM.map_pie(Matrix D0, Matrix D1)	Computes the steady-state probability vector of the embedded Discrete Time Markov Chain (DTMC) associated with a Markovian Arrival Process (MAP).
static Matrix	MAM.map_piq(Matrix D0, Matrix D1)	Computes the steady-state vector (pi) of the Continuous-Time Markov Chain (CTMC) underlying a Markovian Arrival Process (MAP).
static double[]	MAM.map_sample(Matrix D0, Matrix D1, long n, Random random)	Generates samples of inter-arrival times from a MAP using a specified number of samples and a random generator.
static MatrixCell	MAM.map_scale(Matrix D0, Matrix D1, double newMean)	Rescales the mean inter-arrival time of a Markovian Arrival Process (MAP) to a specified new mean.
static double	MAM.map_scv(Matrix D0, Matrix D1)	Computes the squared coefficient of variation (SCV) of the inter-arrival times of a Markovian Arrival Process (MAP).
static double	MAM.map_skew(Matrix D0, Matrix D1)	Computes the skewness of the inter-arrival times for a MAP.
static double	MAM.map_var(Matrix D0, Matrix D1)	Computes the variance of the inter-arrival times for a MAP.
static Matrix	MAM.map_varcount(MatrixCell MAP, Matrix t)	Computes the variance of the counts in a MAP over multiple time periods using a MatrixCell.
static double	MAM.map_varcount(Matrix D0, Matrix D1, double t)	Computes the variance of the counts in a MAP over a time period t.
static Matrix	MAM.map_varcount(Matrix D0, Matrix D1, Matrix t)	Computes the variance of the counts in a MAP over multiple time periods.
static Matrix	MAM.mmap_backward_moment(MatrixCell MMAP, Matrix ORDERS)	Computes the backward moments of an MMAP for specified orders with normalization.
static Matrix	MAM.mmap_backward_moment(MatrixCell MMAP, Matrix ORDERS, int NORM)	Computes the backward moments of an MMAP for specified orders.
static MatrixCell	MAM.mmap_exponential(Matrix lambda)	Fits a Markovian Arrival Process with marked arrivals (MMAP) with a single state based on the given arrival rates for each job class.
static MatrixCell	MAM.mmap_exponential(Matrix lambda, int n)	Fits an order-n Markovian Arrival Process with marked arrivals (MMAP) based on the given arrival rates for each job class.
static Matrix	MAM.mmap_forward_moment(MatrixCell MMAP, Matrix ORDERS)	Computes the forward moments of an MMAP for specified orders with normalization.
static Matrix	MAM.mmap_forward_moment(MatrixCell MMAP, Matrix ORDERS, int NORM)	Computes the forward moments of an MMAP for specified orders.
static MatrixCell	MAM.mmap_hide(MatrixCell MMAP, Matrix types)	Hides specified types of arrivals in a Markovian Arrival Process with marked arrivals (MMAP).
static MatrixCell	MAM.mmap_mark(MatrixCell MMAP, Matrix prob)	Converts a Markovian Arrival Process with marked arrivals (MMAP) into a new MMAP with redefined classes based on a given probability matrix.
static MatrixCell	MAM.mmap_mixture(Matrix alpha, Map<Integer,MatrixCell> MAPs)	Creates a mixture of MMAPs using the given weights (alpha) and MAPs.
static Ret.mamMMAPMixtureFit	MAM.mmap_mixture_fit(Map<Integer[],Matrix> P2, Matrix M1, Matrix M2, Matrix M3)	Fits a mixture of Markovian Arrival Processes (MMAPs) to match the given cross-moments.
static MatrixCell	MAM.mmap_scale(MatrixCell MMAP, Matrix M)	Changes the mean inter-arrival time of a Markovian Arrival Process with marked arrivals (MMAP).
static Ret.FJApprox	FJ.mmt(Network model, Matrix forkLambda)	Fork-Join Transform approach to evaluate queueing networks including fork-join systems.
static Ret.npfqnNonexpApprox	NPFQN.npfqn_nonexp_approx(String method, NetworkStruct sn, Matrix ST, Matrix V, Matrix SCV, Matrix Tin, Matrix Uin, Matrix gamma, Matrix nservers)	Approximates non-product-form queueing networks using the specified method.
static MatrixCell	NPFQN.npfqn_traffic_merge_cs(Map<Integer,MatrixCell> MMAPs, Matrix prob)	Merges MMAP traffic flows with class switching using default parameters.
static MatrixCell	NPFQN.npfqn_traffic_merge_cs(Map<Integer,MatrixCell> MMAPs, Matrix prob, String config)	Merges MMAP traffic flows with class switching.
static Map<Integer,MatrixCell>	NPFQN.npfqn_traffic_split_cs(MatrixCell MMAP, Matrix P)	Splits MMAP traffic flows with class switching.
static Ret.pfqnAMVA	PFQN.pfqn_aql(Matrix L, Matrix N, Matrix Z)	AQL approximate MVA for a closed queueing network model.
static Ret.pfqnAMVA	PFQN.pfqn_aql(Matrix L, Matrix N, Matrix Z, double tol, int maxiter)	AQL approximate MVA for a closed queueing network model.
static Ret.pfqnAMVA	PFQN.pfqn_aql(Matrix L, Matrix N, Matrix Z, int maxiter)	AQL approximate MVA for a closed queueing network model.
static Ret.pfqnAMVA	PFQN.pfqn_bs(Matrix L, Matrix N)	Bard-Schweitzer approximate mean value analysis algorithm
static Ret.pfqnAMVA	PFQN.pfqn_bs(Matrix L, Matrix N, Matrix Z)	Bard-Schweitzer approximate mean value analysis algorithm
static Ret.pfqnAMVA	PFQN.pfqn_bs(Matrix L, Matrix N, Matrix Z, double tol)	Bard-Schweitzer approximate mean value analysis algorithm
static Ret.pfqnAMVA	PFQN.pfqn_bs(Matrix L, Matrix N, Matrix Z, double tol, int maxiter)	Bard-Schweitzer approximate mean value analysis algorithm
static Ret.pfqnAMVA	PFQN.pfqn_bs(Matrix L, Matrix N, Matrix Z, double tol, int maxiter, Matrix QN0)	Bard-Schweitzer approximate mean value analysis algorithm
static Ret.pfqnAMVA	PFQN.pfqn_bs(Matrix L, Matrix N, Matrix Z, double tol, int maxiter, Matrix QN0, SchedStrategy[] type)	Bard-Schweitzer approximate mean value analysis algorithm
static Ret.pfqnNc	PFQN.pfqn_ca(Matrix L, Matrix N)	Compute the normalizing constant using the convolution algorithm
static Ret.pfqnNc	PFQN.pfqn_ca(Matrix L, Matrix N, Matrix Z)	Compute the normalizing constant using the convolution algorithm
static Matrix	PFQN.pfqn_cdfun(Matrix nvec, Map<Station,SerializableFunction<Matrix,Double>> cdscaling, List<Station> stations)	Evaluate class-dependent (CD) scaling function
static Ret.pfqnComomrm	PFQN.pfqn_comomrm(Matrix L, Matrix N, Matrix Z, Integer m, double atol)	Compute the normalizing constant of a repairmen model using COMOM
static Ret.pfqnComomrmLd	PFQN.pfqn_comomrm_ld(Matrix L, Matrix N, Matrix Z, Matrix mu, SolverOptions options)	Run the COMOM normalizing constant solution method on a repairman model
static Ret.pfqnAMVAMS	PFQN.pfqn_conwayms(Matrix L, Matrix N, Matrix Z)
static Ret.pfqnAMVAMS	PFQN.pfqn_conwayms(Matrix L, Matrix N, Matrix Z, int[] nservers)
static Ret.pfqnAMVAMS	PFQN.pfqn_conwayms(Matrix L, Matrix N, Matrix Z, int[] nservers, SchedStrategy[] type, double tol, int maxiter)
static Ret.pfqnCore	PFQN.pfqn_conwayms_core(Matrix L, int M, int R, Matrix N_1, Matrix Z, int[] nservers, Matrix Q, Matrix P, Matrix PB, MatrixCell Delta, SchedStrategy[] type, double tol, int maxiter)
static Ret.pfqnEstimate	PFQN.pfqn_conwayms_estimate(int M, int R, Matrix N_1, int[] nservers, Matrix Q, Matrix P, Matrix PB, MatrixCell Delta, Matrix W)
static Ret.pfqnForwardMVA	PFQN.pfqn_conwayms_forwardmva(Matrix L, int M, int R, Matrix N_1, Matrix Z, int[] nservers, SchedStrategy[] type, MatrixCell Q_1, MatrixCell P_1, Matrix PB_1, Matrix T_1)
static Ret.pfqnNc	PFQN.pfqn_cub(Matrix L, Matrix N, Matrix Z)	Cubature method to compute the normalizing constant of a load-independent closed queueing network model
static Ret.pfqnNc	PFQN.pfqn_cub(Matrix L, Matrix N, Matrix Z, int order, double atol)	Cubature method to compute the normalizing constant of a load-independent closed queueing network model
static Ret.pfqnAMVA	PFQN.pfqn_egflinearizer(Matrix L, Matrix N, Matrix Z, SchedStrategy[] type, double tol, int maxiter, Matrix alpha)	Extended general form linearizer approximate mean value analysis algorithm.
static Ret.pfqnFnc	PFQN.pfqn_fnc(Matrix alpha)	Compute scaling factor of a load-dependent functional server use to calculate the mean
static Ret.pfqnFnc	PFQN.pfqn_fnc(Matrix alpha, Matrix c)	Compute scaling factor of a load-dependent functional server use to calculate the mean instantiated with scaling constant c.
static Ret.pfqnAMVA	PFQN.pfqn_gflinearizer(Matrix L, Matrix N, Matrix Z, SchedStrategy[] type, double tol, int maxiter, double alpha)
static Ret.pfqnNc	PFQN.pfqn_gld(Matrix L, Matrix N, Matrix mu, SolverOptions options)	Compute the normalizing constant of a single-class load-dependent closed queueing network model
static Ret.pfqnNcComplex	PFQN.pfqn_gld_complex(ComplexMatrix L, Matrix N, Matrix mu, SolverOptions options)	Compute the normalizing constant of a single-class load-dependent closed queueing network model with complex demands.
static Ret.pfqnNc	PFQN.pfqn_gldsingle(Matrix L, Matrix N, Matrix mu, SolverOptions options)	Auxiliary function used by pfqn_gld to computer the normalizing constant in a single-class load-dependent model.
static Ret.pfqnNcComplex	PFQN.pfqn_gldsingle_complex(ComplexMatrix L, Matrix N, Matrix mu, SolverOptions options)	Auxiliary function used by pfqn_gld to computer the normalizing constant in a single-class load-dependent model with complex demands.
static Ret.pfqnNc	PFQN.pfqn_kt(Matrix L, Matrix N, Matrix Z)	Knessl-Tier asymptotic expansion of the normalizing constant using the ray method.
static Ret.pfqnNc	PFQN.pfqn_le(Matrix L, Matrix N, Matrix Z)	Logistic expansion method to compute the normalizing constant
protected static Ret.pfqnLeFpi	PFQN.pfqn_le_fpi(Matrix L, Matrix N)	Fixed-point iteration used in the logistic expansion method
protected static Ret.pfqnLeFpiZ	PFQN.pfqn_le_fpiZ(Matrix L, Matrix N, Matrix Z)	Fixed-point iteration used in the logistic expansion method in models with delays
protected static Matrix	PFQN.pfqn_le_hessian(Matrix L, Matrix N, Matrix u0)	Auxiliary function to compute the Hessian used in the logistic expansion method
protected static Matrix	PFQN.pfqn_le_hessianZ(Matrix L, Matrix N, Matrix Z, Matrix u, double v)	Auxiliary function to compute the Hessian used in the logistic expansion method in models with delays
static Ret.pfqnAMVA	PFQN.pfqn_linearizer(Matrix L, Matrix N, Matrix Z, SchedStrategy[] type)	Linearizer approximate mean value analysis algorithm
static Ret.pfqnAMVA	PFQN.pfqn_linearizer(Matrix L, Matrix N, Matrix Z, SchedStrategy[] type, double tol)	Linearizer approximate mean value analysis algorithm
static Ret.pfqnAMVA	PFQN.pfqn_linearizer(Matrix L, Matrix N, Matrix Z, SchedStrategy[] type, double tol, int maxiter)	Linearizer approximate mean value analysis algorithm
static Ret.pfqnAMVAMS	PFQN.pfqn_linearizerms(Matrix L, Matrix N, Matrix Z, Matrix nservers)	Multiserver version of Krzesinski's Linearizer
static Ret.pfqnAMVAMS	PFQN.pfqn_linearizerms(Matrix L, Matrix N, Matrix Z, Matrix nservers, Matrix type)	Multiserver version of Krzesinski's Linearizer
static Ret.pfqnAMVAMS	PFQN.pfqn_linearizerms(Matrix L, Matrix N, Matrix Z, Matrix nservers, Matrix type, double tol)	Multiserver version of Krzesinski's Linearizer
static Ret.pfqnAMVAMS	PFQN.pfqn_linearizerms(Matrix L, Matrix N, Matrix Z, Matrix nservers, Matrix type, double tol, int maxiter)	Multiserver version of Krzesinski's Linearizer as described in Conway 1989, Fast Approximate Solution of Queueing Networks with Multi-Server Chain- Dependent FCFS Queues.
static Ret.pfqnAMVA	PFQN.pfqn_linearizermx(Matrix lambda, Matrix L, Matrix N, Matrix Z, Matrix nservers, SchedStrategy[] type, double tol, int maxiter, String method)	Linearizer method for mixed models with multi-server stations
static Matrix	PFQN.pfqn_lldfun(Matrix n, Matrix lldscaling, Matrix nservers)	Evaluate limited-load dependent (LLD) function
static Ret.pfqnNc	PFQN.pfqn_ls(Matrix L, Matrix N, Matrix Z, long I)	Logistic sampling method to compute the normalizing constant
static Ret.pfqnNc	PFQN.pfqn_ls(Matrix L, Matrix N, Matrix Z, long I, long seed)	Logistic sampling method to compute the normalizing constant
protected static double	PFQN.pfqn_ls_helper(double[] x, int K, int M, double eta, double eN, Matrix L, Matrix N, Matrix Z)	Auxiliary function used in the logistic sampling method
static Ret.pfqnNc	PFQN.pfqn_mci(Matrix D, Matrix N, Matrix Z, int I, String variant)
static Ret.pfqnNc	PFQN.pfqn_mmint2(Matrix L, Matrix N, Matrix Z)
static Ret.pfqnNc	PFQN.pfqn_mmint2_gausslegendre(Matrix L, Matrix N, Matrix Z, Integer m)	Compute the normalizing constant of a repairmen model using Gauss-Legendre integration
static Ret.pfqnNc	PFQN.pfqn_mmsample2(Matrix L, Matrix N, Matrix Z, int samples)
static double	PFQN.pfqn_mu_ms_gnaux(int n, int m, int c, Matrix g)
static Matrix	PFQN.pfqn_mushift(Matrix mu, int k)	Shifts a load-dependent scaling vector by one position
static Ret.pfqnMVA	PFQN.pfqn_mva(Matrix L, Matrix N, Matrix Z)
static Ret.pfqnMVA	PFQN.pfqn_mva(Matrix L, Matrix N, Matrix Z, Matrix mi)	Mean Value Analysis (MVA) Algorithm for closed Product-Form Queueing Networks.
static Ret.pfqnMVALD	PFQN.pfqn_mvald(Matrix L, Matrix N, Matrix Z, Matrix mu)	Mean Value Analysis (MVA) method for closed networks with load dependent service and stabilization
static Ret.pfqnMVALD	PFQN.pfqn_mvald(Matrix L, Matrix N, Matrix Z, Matrix mu, boolean stabilize)	Mean Value Analysis (MVA) method for closed networks with load dependent service
static Ret.pfqnMVA	PFQN.pfqn_mvaldms(Matrix lambda, Matrix D, Matrix N, Matrix Z, Matrix S)	Wrapper for pfqn_mvaldmx that adjusts utilizations to account for multiservers
static Ret.pfqnMVALDMX	PFQN.pfqn_mvaldmx(Matrix lambda, Matrix D, Matrix N, Matrix Z, Matrix mu, Matrix S)	Mean Value Analysis (MVA) method for mixed queueing networks with load-dependent nodes.
protected static Ret.pfqnMVALDMXEC	PFQN.pfqn_mvaldmx_ec(Matrix lambda, Matrix D, Matrix mu)	Auxiliary function used by pfqn_mvaldmx to compute the EC terms
static Ret.pfqnMVA	PFQN.pfqn_mvams(Matrix lambda, Matrix L, Matrix N, Matrix Z, Matrix mi, Matrix S)	General purpose script to handle mixed Query Networks with multiserver nodes.
static Ret.pfqnMVA	PFQN.pfqn_mvamx(Matrix lambda, Matrix D, Matrix N, Matrix Z, Matrix mi)	Mean Value Analysis (MVA) method for open and mixed queueing networks with no multi-server nodes.
static Ret.pfqnNcXQ	PFQN.pfqn_nc(Matrix lambda, Matrix L, Matrix N, Matrix Z, SolverOptions options)	Main method to compute the normalizing constant of a load-independent model
static Ret.pfqnNcSanitize	PFQN.pfqn_nc_sanitize(Matrix lambda, Matrix L, Matrix N, Matrix Z, double atol)	Sanitizes product-form model parameters to avoid degeneracies
static Matrix	PFQN.pfqn_nca(Matrix L, int N, Matrix alpha)
static Ret.pfqnNc	PFQN.pfqn_ncld(Matrix L, Matrix N, Matrix Z, Matrix mu, SolverOptions options)	Main method to compute the normalizing constant of a load-dependent model
static double	PFQN.pfqn_nrl(Matrix L, Matrix N, Matrix Z, Matrix alpha, SolverOptions options)
static double	PFQN.pfqn_nrp(Matrix L, Matrix N, Matrix Z, Matrix alpha, SolverOptions options)
static Ret.pfqnNc	PFQN.pfqn_panacea(Matrix L, Matrix N, Matrix Z)	Compute the PANACEA approximation
static Ret.pfqnNc	PFQN.pfqn_panacea(Matrix L, Matrix N, Matrix Z, SolverOptions options)	Compute the PANACEA approximation
static double	PFQN.pfqn_pff_delay(Matrix Z, Matrix n)	Compute the product-form factor relatively to a Delay station
static Ret.pfqnNcXQ	PFQN.pfqn_propfair(Matrix L, Matrix N, Matrix Z)
static double	PFQN.pfqn_qzgblow(Matrix L, double N, double Z, int i)	Computes the lower Geometric Bound (GB) for the queue length of the given closed single-class queueing networks
static double	PFQN.pfqn_qzgbup(Matrix L, double N, double Z, int i)	Computes the upper Geometric Bound (GB) for the queue length of the given closed single-class queueing networks
static Ret.pfqnRd	PFQN.pfqn_rd(Matrix L, Matrix N, Matrix Z, Matrix mu, SolverOptions options)
static Ret.pfqnNc	PFQN.pfqn_recal(Matrix L, Matrix N)	RECAL method to compute the normalizing constant of a load-independent closed queueing network model
static Ret.pfqnNc	PFQN.pfqn_recal(Matrix L, Matrix N, Matrix Z)	RECAL method to compute the normalizing constant of a load-independent closed queueing network model
static Ret.pfqnNc	PFQN.pfqn_recal(Matrix L, Matrix N, Matrix Z, Matrix m0)	RECAL method to compute the normalizing constant of a load-independent closed queueing network model
static double	PFQN.pfqn_xia(Matrix L, int N, Matrix s, SolverOptions options)
static double	PFQN.pfqn_xzabalow(Matrix L, double N, double Z)	Computes the low ABA for the throughput of the given closed single-class queueing networks
static double	PFQN.pfqn_xzabaup(Matrix L, double N, double Z)	Computes the upper ABA for the throughput of the given closed single-class queueing networks
static double	PFQN.pfqn_xzgsblow(Matrix L, double N, double Z)	Computes the lower Geometric Square-Root Bound (GSB) for the throughput of the given closed single-class queueing networks
static double	PFQN.pfqn_xzgsbup(Matrix L, double N, double Z)	Computes the upper Geometric Square-Root Bound (GSB) for the throughput of the given closed single-class queueing networks
static Ret.snDeaggregateChainResults	SN.snDeaggregateChainResults(NetworkStruct sn, Matrix Lchain, Matrix ST, Matrix STchain, Matrix Vchain, Matrix alpha, Matrix Qchain, Matrix Uchain, Matrix Rchain, Matrix Tchain, Matrix Cchain, Matrix Xchain)	Calculate class-based performance metrics for a queueing network based on performance measures of its chains
static Matrix	SN.snGetAvgArvRFromTput(NetworkStruct sn, Matrix TN, Matrix TH)	Calculates the average arrival rates at each station from the network throughputs.
static NetworkStruct	SN.snRefreshVisits(NetworkStruct sn, Matrix chains, Matrix rt, Matrix rtnodes)	Reculate the visits to each node
static Ret.FJsortForks	FJ.sort_forks(NetworkStruct sn, NetworkStruct nonfjstruct, Matrix fjforkmap, Matrix fjclassmap, Network nonfjmodel)	Determines a directed acyclic graph of relationships among fork nodes.

Method parameters in jline.api with type arguments of type Matrix

Modifier and Type	Method	Description
static Ret.mamMMAPMixtureFit	MAM.mmap_mixture_fit(Map<Integer[],Matrix> P2, Matrix M1, Matrix M2, Matrix M3)	Fits a mixture of Markovian Arrival Processes (MMAPs) to match the given cross-moments.
static Matrix	PFQN.pfqn_cdfun(Matrix nvec, Map<Station,SerializableFunction<Matrix,Double>> cdscaling, List<Station> stations)	Evaluate class-dependent (CD) scaling function

Uses of Matrix in jline.io

Fields in jline.io declared as Matrix

Modifier and Type	Field	Description
Matrix	Ret.snGetDemandsChain.alpha
Matrix	Ret.lossnErlangFP.blockProb
Matrix	Ret.pfqnFnc.c
Matrix	Ret.pfqnAMVA.C
Matrix	Ret.pfqnAMVAMS.C
Matrix	Ret.snDeaggregateChainResults.C
final Matrix	Ret.pfqnLeFpi.d
final Matrix	Ret.pfqnLeFpiZ.d
Matrix	Ret.snGetDemands.D
Matrix	Ret.snGetProductFormChainParams.D
Matrix	Ret.snGetProductFormParams.D
Matrix	Ret.snGetDemandsChain.Dchain
Matrix	Ret.pfqnMVALDMXEC.E
Matrix	Ret.pfqnMVALDMXEC.EC
Matrix	Ret.pfqnMVALDMXEC.Eprime
Matrix	Ret.npfqnNonexpApprox.eta
Matrix	Ret.FJApprox.fjclassmap
Matrix	Ret.FJApprox.fjforkmap
Matrix	Ret.cacheGammaLp.gamma
Matrix	Ret.npfqnNonexpApprox.gamma
Matrix	Ret.pfqnNcSanitize.L
Matrix	Ret.pfqnNcSanitize.lambda
Matrix	Ret.snGetProductFormChainParams.lambda
Matrix	Ret.snGetProductFormParams.lambda
Matrix	Ret.pfqnComomrm.lGbasis
Matrix	Ret.pfqnMVALDMXEC.Lo
Matrix	Ret.lossnErlangFP.lossProb
Matrix	Ret.pfqnFnc.mu
Matrix	Ret.snGetProductFormChainParams.mu
Matrix	Ret.snGetProductFormParams.mu
Matrix	Ret.pfqnNcSanitize.N
Matrix	Ret.snGetProductFormChainParams.N
Matrix	Ret.snGetProductFormParams.N
Matrix	Ret.snGetDemandsChain.Nchain
Matrix	Ret.npfqnNonexpApprox.nservers
Matrix	Ret.FJsortForks.outerForks
final Matrix	Ret.EventResult.outprob
final Matrix	Ret.EventResult.outrate
final Matrix	Ret.EventResult.outspace
final Matrix	Ret.pfqnCore.P
final Matrix	Ret.pfqnForwardMVA.P
Matrix	Ret.pfqnLinearizerMSCore.P
Matrix	Ret.pfqnLinearizerMSForwardMVA.P
Matrix[]	Ret.pfqnLinearizerMSEstimate.P_1
Matrix	Ret.FJsortForks.parentForks
final Matrix	Ret.pfqnCore.PB
final Matrix	Ret.pfqnForwardMVA.PB
Matrix	Ret.pfqnLinearizerMSCore.PB
Matrix	Ret.pfqnLinearizerMSForwardMVA.PB
final Matrix	Ret.pfqnEstimate.PB_1
Matrix	Ret.pfqnLinearizerMSEstimate.PB_1
Matrix	Ret.pfqnMVALDMX.Pc
Matrix	Ret.cacheMVA.pi
Matrix	Ret.pfqnMVALD.pi
Matrix	Ret.cacheMVA.pi0
Matrix	Ret.cacheXiFp.pi0
Matrix	Ret.cacheMVA.pij
Matrix	Ret.cacheXiFp.pij
Matrix	Ret.pfqnComomrmLd.prob
Matrix	Ret.pfqnAMVA.Q
Matrix	Ret.pfqnAMVAMS.Q
final Matrix	Ret.pfqnCore.Q
final Matrix	Ret.pfqnForwardMVA.Q
Matrix	Ret.pfqnLinearizerCore.Q
Matrix	Ret.pfqnLinearizerForwardMVA.Q
Matrix	Ret.pfqnLinearizerMSCore.Q
Matrix	Ret.pfqnLinearizerMSForwardMVA.Q
Matrix	Ret.pfqnMVA.Q
Matrix	Ret.pfqnMVALD.Q
Matrix	Ret.pfqnMVALDMX.Q
Matrix	Ret.pfqnNcXQ.Q
Matrix	Ret.snDeaggregateChainResults.Q
Matrix[]	Ret.pfqnLinearizerEstimate.Q_1
Matrix[]	Ret.pfqnLinearizerMSEstimate.Q_1
Matrix	Ret.lossnErlangFP.qLen
Matrix	Ret.pfqnAMVA.R
Matrix	Ret.pfqnAMVAMS.R
Matrix	Ret.pfqnMVA.R
Matrix	Ret.pfqnMVALD.R
Matrix	Ret.pfqnMVALDMX.R
Matrix	Ret.snDeaggregateChainResults.R
Matrix	Ret.snGetDemandsChain.refstatchain
Matrix	Ret.npfqnNonexpApprox.rho
Matrix	Ret.snGetProductFormChainParams.S
Matrix	Ret.snGetProductFormParams.S
Matrix	Ret.npfqnNonexpApprox.scva
Matrix	Ret.snGetDemandsChain.SCVchain
Matrix	Ret.npfqnNonexpApprox.scvs
Matrix	Ret.npfqnNonexpApprox.ST
Matrix	Ret.snGetDemandsChain.STchain
Matrix	Ret.pfqnAMVA.T
final Matrix	Ret.pfqnForwardMVA.T
Matrix	Ret.pfqnLinearizerCore.T
Matrix	Ret.pfqnLinearizerForwardMVA.T
Matrix	Ret.pfqnLinearizerMSCore.T
Matrix	Ret.pfqnLinearizerMSForwardMVA.T
Matrix	Ret.snDeaggregateChainResults.T
final Matrix	Ret.pfqnEstimate.T_1
Matrix	Ret.pfqnLinearizerEstimate.T_1
Matrix	Ret.cacheMVA.u
final Matrix	Ret.pfqnLeFpi.u
final Matrix	Ret.pfqnLeFpiZ.u
Matrix	Ret.pfqnAMVA.U
Matrix	Ret.pfqnAMVAMS.U
Matrix	Ret.pfqnMVA.U
Matrix	Ret.pfqnMVALD.U
Matrix	Ret.pfqnMVALDMX.U
Matrix	Ret.snDeaggregateChainResults.U
Matrix	Ret.snGetProductFormChainParams.V
Matrix	Ret.snGetProductFormParams.V
Matrix	Ret.snGetDemandsChain.Vchain
final Matrix	Ret.pfqnCore.W
final Matrix	Ret.pfqnForwardMVA.W
Matrix	Ret.pfqnLinearizerCore.W
Matrix	Ret.pfqnLinearizerForwardMVA.W
Matrix	Ret.pfqnLinearizerMSCore.W
Matrix	Ret.pfqnLinearizerMSForwardMVA.W
Matrix	Ret.cacheMVA.x
Matrix	Ret.pfqnAMVA.X
Matrix	Ret.pfqnAMVAMS.X
final Matrix	Ret.pfqnCore.X
Matrix	Ret.pfqnMVA.X
Matrix	Ret.pfqnMVALD.X
Matrix	Ret.pfqnMVALDMX.X
Matrix	Ret.pfqnNcXQ.X
Matrix	Ret.snDeaggregateChainResults.X
Matrix	Ret.cacheRayInt.xi
Matrix	Ret.cacheXiFp.xi
Matrix	Ret.pfqnNcSanitize.Z
Matrix	Ret.snGetDemands.Z
Matrix	Ret.snGetProductFormChainParams.Z
Matrix	Ret.snGetProductFormParams.Z

Constructors in jline.io with parameters of type Matrix

Modifier	Constructor	Description
	cacheGammaLp(Matrix gamma, int u, int n, int h)	Constructor for initializing the cacheGammaLpReturn object.
	cacheMVA(Matrix pi, Matrix pi0, Matrix pij, Matrix x, Matrix u, int E)	Constructor for initializing the cacheMVAReturn object.
	cacheRayInt(double Z, double lZ, Matrix xi)	Constructor for initializing the cacheRayIntReturn object.
	cacheXiFp(Matrix xi, Matrix pi0, Matrix pij, int it)	Constructor for initializing the cacheXiFpReturn object.
	EventResult(Matrix outspace, Matrix outrate, Matrix outprob)
	FJApprox(Network nonfjmodel, Matrix fjclassmap, Matrix fjforkmap, Map<Integer,Integer> fj_auxiliary_delays, Map<Integer,Integer> fanout)
	FJsortForks(Matrix outerForks, Matrix parentForks)
	lossnErlangFP(Matrix q, Matrix l, Matrix b, int n)
	npfqnNonexpApprox(Matrix ST, Matrix gamma, Matrix nservers, Matrix rho, Matrix scva, Matrix scvs, Matrix eta)
	pfqnAMVA(Matrix Q, Matrix U, Matrix R, Matrix T, Matrix C, Matrix X, int totiter)
	pfqnAMVAMS(Matrix Q, Matrix U, Matrix R, Matrix C, Matrix X, int totiter)
	pfqnComomrm(double lG, Matrix lGbasis)
	pfqnComomrmLd(double GN, double lG, Matrix prob)
	pfqnCore(Matrix Q, Matrix W, Matrix X, Matrix P, Matrix PB, int iter)
	pfqnCUB(Matrix L, double Nt, Matrix beta)
	pfqnEstimate(MatrixCell Q_1, MatrixCell P_1, Matrix PB_1, Matrix T_1)
	pfqnFnc(Matrix mu, Matrix c)
	pfqnForwardMVA(Matrix Q, Matrix W, Matrix T, Matrix P, Matrix PB)
	pfqnLeFpi(Matrix u, Matrix d)
	pfqnLeFpiZ(Matrix u, double v, Matrix d)
	pfqnLinearizerCore(Matrix Q, Matrix W, Matrix T, int iter)
	pfqnLinearizerEstimate(Matrix[] Q_1, Matrix T_1)
	pfqnLinearizerForwardMVA(Matrix Q, Matrix W, Matrix T)
	pfqnLinearizerMSCore(Matrix Q, Matrix W, Matrix T, Matrix P, Matrix PB, int iter)
	pfqnLinearizerMSEstimate(Matrix[] Q_1, Matrix[] P_1, Matrix PB_1)
	pfqnLinearizerMSForwardMVA(Matrix Q, Matrix W, Matrix T, Matrix P, Matrix PB)
	pfqnMVA(Matrix XN, Matrix QN, Matrix UN, Matrix RN, double lGN)
	pfqnMVALD(Matrix XN, Matrix QN, Matrix UN, Matrix RN, List<Double> lG, boolean isNumStable, Matrix pi)
	pfqnMVALDMX(Matrix XN, Matrix QN, Matrix UN, Matrix RN, double lG, Matrix Pc)
	pfqnMVALDMXEC(Matrix EC, Matrix E, Matrix Eprime, Matrix Lo)
	pfqnNcSanitize(Matrix lambda, Matrix L, Matrix N, Matrix Z, double lGremaind)
	pfqnNcXQ(Double G, Double lG, Matrix X, Matrix Q, String method)
	pfqnNcXQ(Double lG, Matrix X, Matrix Q, String method)
	snDeaggregateChainResults(Matrix q, Matrix u, Matrix r, Matrix t, Matrix c, Matrix x)
	snGetDemandsChain(Matrix dchain, Matrix sTchain, Matrix vchain, Matrix alpha, Matrix nchain, Matrix sCVchain, Matrix refstatchain)

Uses of Matrix in jline.lang

Subclasses of Matrix in jline.lang

Modifier and Type	Class	Description
class	ClassSwitchMatrix	Class representing a probabilistic routing matrix

Fields in jline.lang declared as Matrix

Modifier and Type	Field	Description
Matrix[][]	NodeParam.accost
Matrix	NodeParam.actualhitprob
Matrix	NodeParam.actualmissprob
Matrix	NetworkStruct.cap
Matrix	Network.routingMatrixReturn.chains
Matrix	NetworkStruct.chains
Matrix	NetworkStruct.classcap
Matrix	NetworkStruct.classprio
protected Matrix	Chain.completes
Matrix	NetworkStruct.connmatrix
Matrix	NetworkStruct.csmask
Matrix	NodeParam.fireweight
Matrix	NodeParam.firingphases
Matrix	NodeParam.firingprio
Matrix	NetworkStruct.fj
Matrix	NodeParam.hitclass
Matrix	NetworkStruct.isslc
Matrix	NetworkStruct.isstatedep
Matrix	NetworkStruct.isstateful
Matrix	NetworkStruct.isstation
Matrix	NodeParam.itemcap
Matrix	Network.routingMatrixReturn.linksmat
Matrix	NetworkStruct.lldscaling
Matrix	NodeParam.missclass
protected Matrix	Chain.njobs
Matrix	NetworkStruct.njobs
Matrix	NodeParam.nmodeservers
Matrix	NetworkStruct.nodeToStateful
Matrix	NetworkStruct.nodeToStation
Matrix	NetworkStruct.nservers
Matrix	NetworkStruct.nvars
Matrix	NetworkStruct.phases
Matrix	NetworkStruct.phaseshift
Matrix	NetworkStruct.phasessz
Matrix	Env.probEnv
Matrix	Env.probOrig
Matrix	NetworkStruct.rates
Matrix	NetworkStruct.refclass
Matrix	NetworkStruct.refstat
Matrix	Network.routingMatrixReturn.rt
Matrix	NetworkStruct.rt
Matrix	Network.routingMatrixReturn.rtnodes
Matrix	NetworkStruct.rtnodes
Matrix	NetworkStruct.schedparam
Matrix	NetworkStruct.scv
protected Matrix	Event.state
Matrix	NetworkStruct.statefulToNode
Matrix	NetworkStruct.stationToNode
Matrix	NetworkStruct.stationToStateful
protected Matrix	Chain.visits

Fields in jline.lang with type parameters of type Matrix

Modifier and Type	Field	Description
Map<Station,SerializableFunction<Matrix,Double>>	NetworkStruct.cdscaling
List<Matrix>	NodeParam.enabling
List<Matrix>	NodeParam.firing
Map<Integer,Matrix>	NetworkStruct.inchain
List<Matrix>	NodeParam.inhibiting
Map<Station,Map<JobClass,Matrix>>	NetworkStruct.mu
Map<Integer,Matrix>	NetworkStruct.nodevisits
Map<JobClass,Matrix>	NodeParam.outlinks
Map<Station,Map<JobClass,Matrix>>	NetworkStruct.phi
Map<Station,Map<JobClass,Matrix>>	NetworkStruct.pie
protected SerializableFunction<Pair<Map<Node,Matrix>,Map<Node,Matrix>>,Double>	Event.probFun
protected SerializableFunction<Pair<Map<Node,Matrix>,Map<Node,Matrix>>,Double>	Event.probFun
Map<JobClass,Map<JobClass,Matrix>>	Network.routingMatrixReturn.rtNodesByClass
Map<Node,Map<Node,Matrix>>	Network.routingMatrixReturn.rtNodesByStation
Map<JobClass,Map<JobClass,Matrix>>	NetworkStruct.rtorig
Map<Station,Matrix>	NetworkStruct.space
Map<StatefulNode,Matrix>	NetworkStruct.state
Map<StatefulNode,Matrix>	NetworkStruct.stateprior
Map<Integer,Matrix>	NetworkStruct.visits
Map<JobClass,Matrix>	NodeParam.weights
Map<JobClass,Matrix>	NodeParam.withMemory

Methods in jline.lang that return Matrix

Modifier and Type	Method	Description
Matrix	RoutingMatrix.get(JobClass jobclass1, JobClass jobclass2)
Matrix	Network.getClassSwitchingMask()
Matrix	Network.getConnectionMatrix()
Matrix	Network.getCsMatrix()
Matrix	Network.getDemandsChain()
Matrix	Network.getForkJoins()
Matrix	Network.getLimitedLoadDependence()
Matrix	Network.getNumberOfJobs()
Matrix	Network.getReferenceClasses()
Matrix	Network.getReferenceStations()
Matrix	Event.getState()
Matrix	Network.getStationServers()
Matrix	Env.ResetQueueLengthsFunction.reset(Matrix input)

Methods in jline.lang that return types with arguments of type Matrix

Modifier and Type	Method	Description
Map<Station,SerializableFunction<Matrix,Double>>	Network.getLimitedClassDependence()
Map<JobClass,Map<JobClass,Matrix>>	Network.getLinkedRoutingMatrix()
SerializableFunction<Pair<Map<Node,Matrix>,Map<Node,Matrix>>,Double>	Event.getProbFun()
SerializableFunction<Pair<Map<Node,Matrix>,Map<Node,Matrix>>,Double>	Event.getProbFun()

Methods in jline.lang with parameters of type Matrix

Modifier and Type	Method	Description
static Network	Network.cyclic(Matrix N, Matrix D, SchedStrategy[] strategy, Matrix S)
static Network	Network.cyclicFcfs(Matrix N, Matrix D, Matrix S)
static Network	Network.cyclicFcfsInf(Matrix N, Matrix D, Matrix Z)
static Network	Network.cyclicFcfsInf(Matrix N, Matrix D, Matrix Z, Matrix S)
static Network	Network.cyclicPs(Matrix N, Matrix D, Matrix S)
static Network	Network.cyclicPsInf(Matrix N, Matrix D, Matrix S)
static Network	Network.cyclicPsInf(Matrix N, Matrix D, Matrix Z, Matrix S)
Network.routingMatrixReturn	Network.getRoutingMatrix(Matrix arvRates, int returnVal)
void	Network.initFromAvgQLen(Matrix AvgQLen)
void	Network.initFromMarginal(Matrix n)
void	Network.initFromMarginalAndRunning(Matrix n, Matrix s)
void	Network.initFromMarginalAndStarted(Matrix n, Matrix s)
void	Network.refreshRoutingMatrix(Matrix rates)
Markovian	Env.ResetEnvRatesFunction.reset(Markovian originalDist, Matrix QExit, Matrix UExit, Matrix TExit)
Matrix	Env.ResetQueueLengthsFunction.reset(Matrix input)
void	RoutingMatrix.set(JobClass jobclass1, JobClass jobclass2, Matrix rt)
void	RoutingMatrix.set(JobClass jobclass, Matrix rt)
void	Network.setConnectionMatrix(Matrix connection)
void	Network.setCsMatrix(Matrix csMatrix)
void	Event.setState(Matrix state)
double	Network.sub_jsq(int ind, int jnd, int r, int s, Matrix linksmat, Map<Node,Matrix> state_before, Map<Node,Matrix> state_after)
double	Network.sub_rr_wrr(int ind, int jnd, int r, int s, Matrix linksmat, Map<Node,Matrix> state_before, Map<Node,Matrix> state_after)
static Network	Network.tandem(Matrix lambda, Matrix D, SchedStrategy[] strategy, Matrix S)
static Network	Network.tandemFcfs(Matrix lambda, Matrix D, Matrix S)
static Network	Network.tandemFcfsInf(Matrix lambda, Matrix D)
static Network	Network.tandemFcfsInf(Matrix lambda, Matrix D, Matrix Z)
static Network	Network.tandemFcfsInf(Matrix lambda, Matrix D, Matrix Z, Matrix S)
static Network	Network.tandemPs(Matrix lambda, Matrix D, Matrix S)
static Network	Network.tandemPsInf(Matrix lambda, Matrix D)
static Network	Network.tandemPsInf(Matrix lambda, Matrix D, Matrix Z)
static Network	Network.tandemPsInf(Matrix lambda, Matrix D, Matrix Z, Matrix S)

Method parameters in jline.lang with type arguments of type Matrix

Modifier and Type	Method	Description
double	Event.getProb(Pair<Map<Node,Matrix>,Map<Node,Matrix>> state)
double	Event.getProb(Pair<Map<Node,Matrix>,Map<Node,Matrix>> state)
void	Event.setProbFun(SerializableFunction<Pair<Map<Node,Matrix>,Map<Node,Matrix>>,Double> probFun)
void	Event.setProbFun(SerializableFunction<Pair<Map<Node,Matrix>,Map<Node,Matrix>>,Double> probFun)
double	Network.sub_jsq(int ind, int jnd, int r, int s, Matrix linksmat, Map<Node,Matrix> state_before, Map<Node,Matrix> state_after)
double	Network.sub_rr_wrr(int ind, int jnd, int r, int s, Matrix linksmat, Map<Node,Matrix> state_before, Map<Node,Matrix> state_after)

Constructors in jline.lang with parameters of type Matrix

Modifier	Constructor	Description
	ClassSwitchMatrix(Matrix matrix)
	Event(EventType event, int nodeIdx, int jobclassIdx, double prob, Matrix state, double t, double job)
	Event(EventType event, int nodeIdx, int jobclassIdx, SerializableFunction<Pair<Map<Node,Matrix>,Map<Node,Matrix>>,Double> probFun, Matrix state, double t, double job)
	routingMatrixReturn(Matrix rt, Matrix rtnodes, Matrix linksmat, Matrix chains, Map<JobClass,Map<JobClass,Matrix>> rtNodesByClass, Map<Node,Map<Node,Matrix>> rtNodesByStation)

Constructor parameters in jline.lang with type arguments of type Matrix

Modifier	Constructor	Description
	Event(EventType event, int nodeIdx, int jobclassIdx, SerializableFunction<Pair<Map<Node,Matrix>,Map<Node,Matrix>>,Double> probFun, Matrix state, double t, double job)
	Event(EventType event, int nodeIdx, int jobclassIdx, SerializableFunction<Pair<Map<Node,Matrix>,Map<Node,Matrix>>,Double> probFun, Matrix state, double t, double job)
	routingMatrixReturn(Matrix rt, Matrix rtnodes, Matrix linksmat, Matrix chains, Map<JobClass,Map<JobClass,Matrix>> rtNodesByClass, Map<Node,Map<Node,Matrix>> rtNodesByStation)

Uses of Matrix in jline.lang.layered

Fields in jline.lang.layered declared as Matrix

Modifier and Type	Field	Description
Matrix	LayeredNetworkStruct.actposttype
Matrix	LayeredNetworkStruct.actpretype
protected Matrix	Activity.asyncCallMeans
Matrix	LayeredNetworkStruct.callpair
Matrix	LayeredNetworkStruct.conntasks
Matrix	LayeredNetworkStruct.graph
Matrix	LayeredNetworkStruct.isasynccaller
Matrix	LayeredNetworkStruct.iscache
Matrix	LayeredNetworkStruct.iscaller
Matrix	LayeredNetworkStruct.isref
Matrix	LayeredNetworkStruct.issynccaller
Matrix	LayeredNetworkStruct.mult
Matrix	LayeredNetworkStruct.nitems
Matrix	LayeredNetworkStruct.parent
protected Matrix	ActivityPrecedence.postParams
protected Matrix	ActivityPrecedence.preParams
Matrix	LayeredNetworkStruct.repl
Matrix	LayeredNetworkStruct.replacement
Matrix	LayeredNetworkStruct.replygraph
Matrix	LayeredNetworkStruct.schedid
protected Matrix	Activity.scheduling
protected Matrix	Entry.scheduling
protected Matrix	Activity.syncCallMeans
Matrix	LayeredNetworkStruct.taskgraph
Matrix	LayeredNetworkStruct.type

Methods in jline.lang.layered with parameters of type Matrix

Modifier and Type	Method	Description
static ActivityPrecedence	ActivityPrecedence.AndFork(String preAct, List<String> postActs, Matrix fanout)	Creates an ActivityPrecedence object representing an AND-fork relationship with a specified fanout matrix.
static ActivityPrecedence	ActivityPrecedence.AndJoin(List<String> preActs, String postAct, Matrix quorum)	Creates an ActivityPrecedence object representing an AND-join relationship with a specified quorum matrix.
static ActivityPrecedence	ActivityPrecedence.Loop(String preAct, String loopAct, String endAct, Matrix nloops)	Creates an ActivityPrecedence object representing a loop relationship.
static ActivityPrecedence	ActivityPrecedence.Loop(String preAct, List<String> postActs, Matrix nloops)	Creates an ActivityPrecedence object representing a loop relationship.
static ActivityPrecedence	ActivityPrecedence.OrFork(String preAct, List<String> postActs, Matrix probs)	/** Creates an ActivityPrecedence object representing an OR-fork relationship with a specified probability matrix.
static ActivityPrecedence	ActivityPrecedence.Xor(String preAct, List<String> postActs, Matrix probs)	Creates an ActivityPrecedence object representing an XOR relationship.

Constructors in jline.lang.layered with parameters of type Matrix

Modifier	Constructor	Description
	ActivityPrecedence(boolean isActivity, List<Activity> preActs, List<Activity> postActs, String preType, String postType, Matrix preParams)	Constructs an ActivityPrecedence using activity objects instead of strings, without postParams.
	ActivityPrecedence(boolean isActivity, List<Activity> preActs, List<Activity> postActs, String preType, String postType, Matrix preParams, Matrix postParams)	Constructs an ActivityPrecedence using activity objects instead of strings, with all parameters.
	ActivityPrecedence(List<String> preActs, List<String> postActs, String preType, String postType, Matrix preParams)	Constructs an ActivityPrecedence with the specified parameters, without postParams.
	ActivityPrecedence(List<String> preActs, List<String> postActs, String preType, String postType, Matrix preParams, Matrix postParams)	Constructs an ActivityPrecedence with the specified parameters.

Uses of Matrix in jline.lang.nodes

Fields in jline.lang.nodes declared as Matrix

Modifier and Type	Field	Description
Matrix[][]	Cache.accessProb
Matrix	Transition.firingPriorities
Matrix	Transition.firingWeights
protected Matrix	Station.lldScaling

Fields in jline.lang.nodes with type parameters of type Matrix

Modifier and Type	Field	Description
Map<Mode,Matrix>	Transition.enablingConditions
Map<Mode,Matrix>	Transition.firingOutcomes
Map<Mode,Matrix>	Transition.inhibitingConditions
protected SerializableFunction<Matrix,Double>	Station.lcdScaling

Methods in jline.lang.nodes that return Matrix

Modifier and Type	Method	Description
Matrix	Cache.getAccessProb(int i, int j)
Matrix[]	Cache.getGraph()
Matrix	Cache.getHitClass()	For an incoming job of class r, HITCLASS[r] is the new class of that job after a hit
Matrix	Cache.getHitRatio()
Matrix	Cache.getItemLevelCap()
Matrix	Station.getLimitedLoadDependence()
Matrix	Cache.getMissClass()	For an incoming job of class r, MISSCLASS[r] is the new class of that job after a miss
Matrix	Cache.getMissRatio()
Matrix	Transition.getNumberOfModeServers()
Matrix	StatefulNode.getState()
Matrix	StatefulNode.getStatePrior()

Methods in jline.lang.nodes that return types with arguments of type Matrix

Modifier and Type	Method	Description
SerializableFunction<Matrix,Double>	Station.getLimitedClassDependence()

Methods in jline.lang.nodes with parameters of type Matrix

Modifier and Type	Method	Description
void	Cache.setAccessProb(Matrix[][] R)
void	Station.setLimitedLoadDependence(Matrix alpha)
void	Queue.setLoadDependence(Matrix alpha)
void	Cache.setResultHitProb(Matrix actualHitProb)
void	Cache.setResultMissProb(Matrix actualMissProb)
void	StatefulNode.setState(Matrix state)
void	StatefulNode.setStatePrior(Matrix prior)

Method parameters in jline.lang.nodes with type arguments of type Matrix

Modifier and Type	Method	Description
void	Queue.setClassDependence(SerializableFunction<Matrix,Double> beta)
void	Station.setLimitedClassDependence(SerializableFunction<Matrix,Double> gamma)

Constructors in jline.lang.nodes with parameters of type Matrix

Modifier	Constructor	Description
	Cache(Network model, String name, int nitems, int itemLevelCap, ReplacementStrategy replPolicy, Matrix[] graph)
	Cache(Network model, String name, int nitems, Matrix itemLevelCap, ReplacementStrategy replPolicy)
	Cache(Network model, String name, int nitems, Matrix itemLevelCap, ReplacementStrategy replPolicy, Matrix[] graph)
	ClassSwitch(Network model, String name, Matrix csFun)

Uses of Matrix in jline.lang.processes

Fields in jline.lang.processes with type parameters of type Matrix

Modifier and Type	Field	Description
protected Map<Integer,Matrix>	Det.process

Methods in jline.lang.processes that return Matrix

Modifier and Type	Method	Description
Matrix	MAP.D(int i)
Matrix	Marked.D(int i)
Matrix	Marked.D(int i, int k)
Matrix	Markovian.D(int i)
Matrix	MMPP2.D(int i)
Matrix	MarkovModulated.evalACFT(int[] lags, double timescale)
Matrix	MMPP2.evalACFT(int[] lags, double timescale)
Matrix	DiscreteDistribution.evalPMF(List<Double> t)
Matrix	DiscreteSampler.evalPMF(List<Double> t)
Matrix	Zipf.evalPMF()
Matrix	Zipf.evalPMF(List<Double> t)	Evaluates the probability mass function at t
Matrix	Markovian.getACF(Matrix lags)
Matrix	Marked.getD1k(int k)
Matrix	Markovian.getEmbedded()
Matrix	MMPP2.getEmbedded()
Matrix	Markovian.getEmbeddedProb()
Matrix	MMPP2.getEmbeddedProb()
Matrix	APH.getInitProb()
Matrix	Markovian.getInitProb()
Matrix	PH.getInitProb()
Matrix	Coxian.getMu()
Matrix	Markovian.getMu()
Matrix	Coxian.getPhi()
Matrix	Markovian.getPhi()
Matrix	Markovian.getSubgenerator()
Matrix	PH.getSubgenerator()

Methods in jline.lang.processes that return types with arguments of type Matrix

Modifier and Type	Method	Description
Map<Integer,Matrix>	Immediate.getPH()
Map<Integer,Matrix>	Det.getProcess()

Methods in jline.lang.processes with parameters of type Matrix

Modifier and Type	Method	Description
Matrix	Markovian.getACF(Matrix lags)
double	MMPP2.getACFDecay(Matrix lags)

Method parameters in jline.lang.processes with type arguments of type Matrix

Modifier and Type	Method	Description
void	Det.setProcess(Map<Integer,Matrix> proc)

Constructors in jline.lang.processes with parameters of type Matrix

Modifier	Constructor	Description
	APH(List<Double> alpha, Matrix T)
	APH(Matrix alpha, Matrix T)
	Coxian(Matrix mu0, Matrix phi0)
	DiscreteSampler(Matrix p)
	DiscreteSampler(Matrix p, Matrix x)	Constructs a discrete distribution from a finite probability vector p at the points specified in vector x
	MAP(Matrix D0, Matrix D1)
	PH(Matrix alpha, Matrix T)

Uses of Matrix in jline.lang.sections

Fields in jline.lang.sections declared as Matrix

Modifier and Type	Field	Description
Matrix	CacheClassSwitcher.actualHitProb
Matrix	CacheClassSwitcher.actualMissProb
Matrix	CacheClassSwitcher.hitClass
Matrix	CacheClassSwitcher.missClass
Matrix	ClassSwitcher.CSFunInput.state
Matrix	ClassSwitcher.CSFunInput.statedep

Methods in jline.lang.sections with parameters of type Matrix

Modifier and Type	Method	Description
double	CacheClassSwitcher.simpleHitMiss(int r, int s, Matrix state)
double	CacheClassSwitcher.simpleHitMiss(int r, int s, Matrix state, Matrix statep)
void	StatelessClassSwitcher.updateClassSwitch(Matrix csMatrix)

Constructors in jline.lang.sections with parameters of type Matrix

Modifier	Constructor	Description
	CacheClassSwitcher(List<JobClass> jobClasses, int items, Matrix capacity)
	CacheClassSwitcher(List<JobClass> jobClasses, int items, Matrix capacity, int levels)
	CSFunInput(int r, int s, Matrix state, Matrix statedep)
	StatelessClassSwitcher(List<JobClass> jobClasses, Matrix csMatrix)

Uses of Matrix in jline.lang.state

Fields in jline.lang.state declared as Matrix

Modifier and Type	Field	Description
Matrix	State.StateSpaceGeneratorResult.Adj
final Matrix	EventCacheKey.inspace
Matrix	State.StateMarginalStatistics.ni
Matrix	State.StateMarginalStatistics.nir
Matrix	State.AfterEventResult.outhash
Matrix	State.AfterEventResult.outprob
Matrix	State.AfterEventResult.outrate
Matrix	State.StateMarginalStatistics.sir
Matrix	State.StateSpaceGeneratorResult.SS
Matrix	State.StateSpaceGeneratorResult.SSh

Fields in jline.lang.state with type parameters of type Matrix

Modifier and Type	Field	Description
final Map<StatefulNode,Matrix>	State.initialState
List<Matrix>	State.StateMarginalStatistics.kir
final Map<StatefulNode,Matrix>	State.priorInitialState
Map<Station,Matrix>	State.StateSpaceGeneratorResult.QNC.space

Methods in jline.lang.state that return Matrix

Modifier and Type	Method	Description
static Matrix	State.fromMarginal(NetworkStruct sn, int ind, Matrix n)
static Matrix	State.fromMarginalAndRunning(Network sn, int ind, Matrix n, Matrix s)
static Matrix	State.fromMarginalAndRunning(NetworkStruct sn, int ind, Matrix n, Matrix s)
static Matrix	State.fromMarginalAndRunning(NetworkStruct sn, int ind, Matrix n, Matrix s, boolean optionsForce)
static Matrix	State.fromMarginalAndStarted(Network network, int ind, Matrix n, Matrix s)
static Matrix	State.fromMarginalAndStarted(NetworkStruct sn, int ind, Matrix n, Matrix s)
static Matrix	State.fromMarginalAndStarted(NetworkStruct sn, int ind, Matrix n, Matrix s, Boolean optionsForce)
static Matrix	State.fromMarginalBounds(NetworkStruct sn, int ind, Matrix ub, double cap, SolverOptions options)
static Matrix	State.spaceClosedMulti(int M, Matrix N)
static Matrix	State.spaceClosedMultiCS(int M, Matrix N, Matrix chains)

Methods in jline.lang.state with parameters of type Matrix

Modifier and Type	Method	Description
static Ret.EventResult	State.afterEvent(NetworkStruct sn, int ind, Matrix inspace, EventType event, int jobClass, boolean isSimulation)
static Ret.EventResult	State.afterEvent(NetworkStruct sn, int ind, Matrix inspace, EventType event, int jobClass, boolean isSimulation, EventCache eventCache)
static int	State.cpos(Matrix matrix, int i, int j)
static Matrix	State.fromMarginal(NetworkStruct sn, int ind, Matrix n)
static Matrix	State.fromMarginalAndRunning(Network sn, int ind, Matrix n, Matrix s)
static Matrix	State.fromMarginalAndRunning(NetworkStruct sn, int ind, Matrix n, Matrix s)
static Matrix	State.fromMarginalAndRunning(NetworkStruct sn, int ind, Matrix n, Matrix s, boolean optionsForce)
static Matrix	State.fromMarginalAndStarted(Network network, int ind, Matrix n, Matrix s)
static Matrix	State.fromMarginalAndStarted(NetworkStruct sn, int ind, Matrix n, Matrix s)
static Matrix	State.fromMarginalAndStarted(NetworkStruct sn, int ind, Matrix n, Matrix s, Boolean optionsForce)
static Matrix	State.fromMarginalBounds(NetworkStruct sn, int ind, Matrix ub, double cap, SolverOptions options)
static boolean	State.isinf(Matrix matrix)
static boolean	State.isValid(Network sn, Matrix n, Matrix s)
static boolean	State.isValid(NetworkStruct sn, Matrix n, Matrix s)
static Matrix	State.spaceClosedMulti(int M, Matrix N)
static Matrix	State.spaceClosedMultiCS(int M, Matrix N, Matrix chains)
static State.spaceGeneratorNodesResult	State.spaceGeneratorNodes(NetworkStruct sn, Matrix cutoff, SolverOptions options)
static State.StateMarginalStatistics	State.toMarginal(NetworkStruct sn, int ind, Matrix state_i, Matrix phasesz, Matrix phaseshift, Matrix space_buf, Matrix space_srv, Matrix space_var)
static State.StateMarginalStatistics	State.toMarginalAggr(NetworkStruct sn, int ind, Matrix state_i, Matrix K, Matrix Ks, Matrix space_buf, Matrix space_srv, Matrix space_var)

Constructors in jline.lang.state with parameters of type Matrix

Modifier	Constructor	Description
	AfterEventResult(Matrix outhash, Matrix outrate, Matrix outprob)
	EventCacheKey(int ind, Matrix inspace, EventType event, int jobClass, boolean isSimulation)
	spaceGeneratorNodesResult(Map<Station,Matrix> nodeStateSpace, NetworkStruct sn, Matrix capacityc)
	StateMarginalStatistics(Matrix ni, Matrix nir, Matrix sir, List<Matrix> kir)
	StateSpaceGeneratorResult(Matrix ss, Matrix sSh, NetworkStruct sn)

Constructor parameters in jline.lang.state with type arguments of type Matrix

Modifier	Constructor	Description
	spaceGeneratorNodesResult(Map<Station,Matrix> nodeStateSpace, NetworkStruct sn, Matrix capacityc)
	State(Map<StatefulNode,Matrix> initialState, Map<StatefulNode,Matrix> priorInitialState)
	StateMarginalStatistics(Matrix ni, Matrix nir, Matrix sir, List<Matrix> kir)

Uses of Matrix in jline.lib.thirdparty

Methods in jline.lib.thirdparty that return Matrix

Modifier and Type	Method	Description
static Matrix	BUTOOLS.MomsFromFactorialMoms(Matrix fm)
static Matrix	BUTOOLS.poly(Matrix x)
static Matrix	SMCSolver.QBD_NI_Sylvest(Matrix A, Matrix B, Matrix C, Matrix D)
static Matrix	BUTOOLS.SimilarityMatrixForVectors(Matrix vecA, Matrix vecB)
static Matrix	SMCSolver.stat(Matrix A)

Methods in jline.lib.thirdparty that return types with arguments of type Matrix

Modifier and Type	Method	Description
static Map<String,Matrix>	BUTOOLS.FluidFundamentalMatrices(Matrix Fpp, Matrix Fpm, Matrix Fmp, Matrix Fmm, Double precision_, Integer maxNumIt_, String method_)
static Map<String,Map<Integer,Matrix>>	BUTOOLS.MMAPPH1FCFS(MatrixCell D, Map<Integer,Matrix> sigma, Map<Integer,Matrix> S, Integer numOfQLMoms, Integer numOfQLProbs, Integer numOfSTMoms, Matrix stDistr, Boolean stDistrME, Boolean stDistrPH, Double prec, Matrix classes_)
static Map<String,Map<Integer,Matrix>>	BUTOOLS.MMAPPH1NPPR(MatrixCell D, MatrixCell sigma, MatrixCell S, Integer numOfQLMoms, Integer numOfQLProbs, Integer numOfSTMoms, Matrix stCdfPoints, Double prec, Integer erlMaxOrder_, Matrix classes_)
static Map<String,Matrix>	SMCSolver.QBD_CR(Matrix A0, Matrix A1, Matrix A2, Integer MaxNumIt_, Integer Verbose_, String Mode_, Integer RAPComp_)
static Map<String,Matrix>	SMCSolver.QBD_EG(Matrix A0, Matrix A1, Matrix A2, Boolean optVerbose)
static Map<String,Matrix>	SMCSolver.QBD_FI(Matrix A0, Matrix A1, Matrix A2, Integer MaxNumIt_, Integer Verbose_, String Mode_, Matrix StartValue_, Integer RAPComp_)
static Map<String,Matrix>	SMCSolver.QBD_IS(Matrix A0, Matrix A1, Matrix A2, Integer MaxNumIt_, Integer Verbose_, String Mode_, Integer RAPComp_)
static Map<String,Matrix>	SMCSolver.QBD_LR(Matrix A0, Matrix A1, Matrix A2, Integer MaxNumIt_, Integer Verbose_, String Mode_, Integer RAPComp_)
static Map<String,Matrix>	SMCSolver.QBD_NI(Matrix A0, Matrix A1, Matrix A2, Integer MaxNumIt_, Integer Verbose_, String Mode_, Integer RAPComp_)
static Map<String,Matrix>	BUTOOLS.QBDFundamentalMatrices(Matrix B, Matrix L, Matrix F, Double precision_, Integer maxNumIt_, String method_, Integer Verbose_)

Methods in jline.lib.thirdparty with parameters of type Matrix

Modifier and Type	Method	Description
static Map<String,Matrix>	BUTOOLS.FluidFundamentalMatrices(Matrix Fpp, Matrix Fpm, Matrix Fmp, Matrix Fmm, Double precision_, Integer maxNumIt_, String method_)
static Map<String,Map<Integer,Matrix>>	BUTOOLS.MMAPPH1FCFS(MatrixCell D, Map<Integer,Matrix> sigma, Map<Integer,Matrix> S, Integer numOfQLMoms, Integer numOfQLProbs, Integer numOfSTMoms, Matrix stDistr, Boolean stDistrME, Boolean stDistrPH, Double prec, Matrix classes_)
static Map<String,Map<Integer,Matrix>>	BUTOOLS.MMAPPH1NPPR(MatrixCell D, MatrixCell sigma, MatrixCell S, Integer numOfQLMoms, Integer numOfQLProbs, Integer numOfSTMoms, Matrix stCdfPoints, Double prec, Integer erlMaxOrder_, Matrix classes_)
static Matrix	BUTOOLS.MomsFromFactorialMoms(Matrix fm)
static Matrix	BUTOOLS.poly(Matrix x)
static double	SMCSolver.QBD_CAUDAL(Matrix A0, Matrix A1, Matrix A2)
static double	SMCSolver.QBD_CAUDAL(Matrix A0, Matrix A1, Matrix A2, Boolean Dual)
static Map<String,Matrix>	SMCSolver.QBD_CR(Matrix A0, Matrix A1, Matrix A2, Integer MaxNumIt_, Integer Verbose_, String Mode_, Integer RAPComp_)
static Map<String,Matrix>	SMCSolver.QBD_EG(Matrix A0, Matrix A1, Matrix A2, Boolean optVerbose)
static Map<String,Matrix>	SMCSolver.QBD_FI(Matrix A0, Matrix A1, Matrix A2, Integer MaxNumIt_, Integer Verbose_, String Mode_, Matrix StartValue_, Integer RAPComp_)
static Map<String,Matrix>	SMCSolver.QBD_IS(Matrix A0, Matrix A1, Matrix A2, Integer MaxNumIt_, Integer Verbose_, String Mode_, Integer RAPComp_)
static Map<String,Matrix>	SMCSolver.QBD_LR(Matrix A0, Matrix A1, Matrix A2, Integer MaxNumIt_, Integer Verbose_, String Mode_, Integer RAPComp_)
static Map<String,Matrix>	SMCSolver.QBD_NI(Matrix A0, Matrix A1, Matrix A2, Integer MaxNumIt_, Integer Verbose_, String Mode_, Integer RAPComp_)
static Matrix	SMCSolver.QBD_NI_Sylvest(Matrix A, Matrix B, Matrix C, Matrix D)
static void	SMCSolver.QBD_ParsePara(Matrix A0, Matrix A1, Matrix A2)
static Map<String,Matrix>	BUTOOLS.QBDFundamentalMatrices(Matrix B, Matrix L, Matrix F, Double precision_, Integer maxNumIt_, String method_, Integer Verbose_)
static Matrix	BUTOOLS.SimilarityMatrixForVectors(Matrix vecA, Matrix vecB)
static Matrix	SMCSolver.stat(Matrix A)

Method parameters in jline.lib.thirdparty with type arguments of type Matrix

Modifier and Type	Method	Description
static Map<String,Map<Integer,Matrix>>	BUTOOLS.MMAPPH1FCFS(MatrixCell D, Map<Integer,Matrix> sigma, Map<Integer,Matrix> S, Integer numOfQLMoms, Integer numOfQLProbs, Integer numOfSTMoms, Matrix stDistr, Boolean stDistrME, Boolean stDistrPH, Double prec, Matrix classes_)

Uses of Matrix in jline.solvers

Fields in jline.solvers declared as Matrix

Modifier and Type	Field	Description
Matrix	SolverResult.AN
Matrix	SolverResult.CN
Matrix[][]	SolverResult.CNt
Matrix	SolverOptions.init_sol
Matrix	LayeredSolverResult.PN
Matrix	SolverResult.QN
Matrix[][]	SolverResult.QNt
Matrix	SolverResult.RN
Matrix[][]	SolverResult.RNt
Matrix	LayeredSolverResult.SN
Matrix	SolverResult.t
Matrix	SolverResult.TN
Matrix[][]	SolverResult.TNt
Matrix	SolverResult.UN
Matrix[][]	SolverResult.UNt
Matrix	SolverResult.WN
Matrix	SolverResult.XN
Matrix[][]	SolverResult.XNt

Methods in jline.solvers that return Matrix

Modifier and Type	Method	Description
final Matrix	NetworkSolver.getAvgArvR()
final Matrix	NetworkSolver.getAvgArvRChain()
final Matrix	NetworkSolver.getAvgNodeArvRChain()
final Matrix	NetworkSolver.getAvgNodeQLenChain()
final Matrix	NetworkSolver.getAvgNodeRespTChain()
final Matrix	NetworkSolver.getAvgNodeTputChain()
final Matrix	NetworkSolver.getAvgNodeUtilChain()
final Matrix	NetworkSolver.getAvgQLen()
final Matrix	NetworkSolver.getAvgQLenChain()
final Matrix	NetworkSolver.getAvgResidT()
final Matrix	NetworkSolver.getAvgRespT()
final Matrix	NetworkSolver.getAvgRespTChain()
final Matrix	NetworkSolver.getAvgSysRespT()
final Matrix	NetworkSolver.getAvgSysTput()
final Matrix	NetworkSolver.getAvgTput()
final Matrix	NetworkSolver.getAvgTputChain()
final Matrix	NetworkSolver.getAvgUtil()
final Matrix	NetworkSolver.getAvgUtilChain()
final Matrix	NetworkSolver.getAvgWaitT()
Matrix	AvgTable.toMatrix()

Methods in jline.solvers with parameters of type Matrix

Modifier and Type	Method	Description
void	NetworkSolver.setAvgResults(Matrix Q, Matrix U, Matrix R, Matrix T, Matrix A, Matrix W, Matrix C, Matrix X, double runtime, String method, int iter)
final void	NetworkSolver.setTranAvgResults(Matrix[][] Qt, Matrix[][] Ut, Matrix[][] Rt, Matrix[][] Tt, Matrix[][] Ct, Matrix[][] Xt, double runtimet)

Constructors in jline.solvers with parameters of type Matrix

Modifier	Constructor	Description
	AvgTable(Matrix table)

Uses of Matrix in jline.solvers.ctmc

Fields in jline.solvers.ctmc declared as Matrix

Modifier and Type	Field	Description
Matrix	SolverCTMC.AnalyzerResult.CN
Matrix	CTMCResult.infGen
Matrix	SolverCTMC.generatorResult.infGen
Matrix	SolverCTMC.symbolicResult.infGen
Matrix	SolverCTMC.AnalyzerResult.InfGen
Matrix	CTMCResult.Prob.joint
Matrix	CTMCResult.Prob.marginal
Matrix	SolverCTMC.StochCompResult.Q11
Matrix	SolverCTMC.StochCompResult.Q12
Matrix	SolverCTMC.StochCompResult.Q21
Matrix	SolverCTMC.StochCompResult.Q22
Matrix	SolverCTMC.AnalyzerResult.QN
Matrix	SolverCTMC.AnalyzerResult.RN
Matrix	SolverCTMC.StochCompResult.S
Matrix	CTMCResult.solverSpecific
Matrix	CTMCResult.space
Matrix	CTMCResult.spaceAggr
Matrix	SolverCTMC.StateSpace.stateSpace
Matrix	SolverCTMC.symbolicResult.stateSpace
protected Matrix	SolverCTMCResult.stateSpace
Matrix	SolverCTMC.AnalyzerResult.StateSpace
Matrix	SolverCTMC.AnalyzerResult.StateSpaceAggr
Matrix	SolverCTMC.AnalyzerResult.TN
Matrix	SolverCTMC.AnalyzerResult.UN
Matrix	SolverCTMC.AnalyzerResult.XN

Fields in jline.solvers.ctmc with type parameters of type Matrix

Modifier and Type	Field	Description
Map<Integer,Matrix>	CTMCResult.eventFilt
Map<Integer,Matrix>	SolverCTMC.generatorResult.eventFilt
Map<Integer,Matrix>	SolverCTMC.symbolicResult.eventFilt
Map<Integer,Matrix>	SolverCTMC.AnalyzerResult.EventFiltration
Map<Integer,Matrix>	SolverCTMC.StateSpace.localStateSpace
Map<Station,Matrix>	CTMCResult.nodeSpace
Map<Integer,Matrix>	SolverCTMC.symbolicResult.nodeStateSpace
Map<Integer,Map<Integer,Matrix>>	CTMCResult.AVG.Q
Map<Integer,Map<Integer,Matrix>>	CTMCResult.AVG.T
Map<Integer,Map<Integer,Matrix>>	CTMCResult.AVG.U

Methods in jline.solvers.ctmc that return Matrix

Modifier and Type	Method	Description
Matrix	SolverCTMC.SolverCtmcJointResult.getPnir()
Matrix	SolverCTMCResult.getQ()
Matrix	SolverCTMC.CtmcSsgResult.getStateSpace()
Matrix	SolverCTMCResult.getStateSpace()
Matrix	SolverCTMC.CtmcSsgResult.getStateSpaceAggr()
Matrix	SolverCTMCResult.getStateSpaceAggr()
Matrix	SolverCTMC.CtmcSsgResult.getStateSpaceHashed()

Methods in jline.solvers.ctmc that return types with arguments of type Matrix

Modifier and Type	Method	Description
Map<Integer,Matrix>	SolverCTMCResult.getDfilt()

Methods in jline.solvers.ctmc with parameters of type Matrix

Modifier and Type	Method	Description
void	SolverCTMC.printInfGen(Matrix Q, Matrix SS)
static double[][][]	SolverCTMC.removeRows(double[][][] array, Matrix rowsToRemove)
void	SolverCTMC.setAvgResults(Matrix Q, Matrix U, Matrix R, Matrix T, Matrix A, Matrix W, Matrix C, Matrix X, double runtime, String method, int iter)

Constructors in jline.solvers.ctmc with parameters of type Matrix

Modifier	Constructor	Description
	AnalyzerResult(Matrix QN, Matrix UN, Matrix RN, Matrix TN, Matrix CN, Matrix XN, Matrix InfGen, Matrix StateSpace, Matrix StateSpaceAggr, Map<Integer,Matrix> EventFiltration, double runtime, String fname, NetworkStruct sncopy)
	CtmcSsgResult(Matrix stateSpace, Matrix stateSpaceAggr, Matrix stateSpaceHashed, Map<Station,Matrix> nodeStateSpace, NetworkStruct sn)
	generatorResult(Matrix infGen, Map<Integer,Matrix> eventFilt, Map<Integer,Sync> ev)
	SolverCtmcJointResult(Matrix pnir, double runtime, String fname)
	SolverCTMCResult(Matrix q, Matrix stateSpace, Matrix stateSpaceAggr, Map<Integer,Matrix> dfilt, double[][][] arvRates, double[][][] depRates, NetworkStruct sn)
	StateSpace(Matrix stateSpace, Map<Integer,Matrix> localStateSpace)
	StochCompResult(Matrix S, Matrix Q11, Matrix Q12, Matrix Q21, Matrix Q22, Matrix T)
	symbolicResult(Matrix infGen, Map<Integer,Matrix> eventFilt, Map<Integer,Sync> syncInfo, Matrix stateSpace, Map<Integer,Matrix> nodeStateSpace)

Constructor parameters in jline.solvers.ctmc with type arguments of type Matrix

Modifier	Constructor	Description
	AnalyzerResult(Matrix QN, Matrix UN, Matrix RN, Matrix TN, Matrix CN, Matrix XN, Matrix InfGen, Matrix StateSpace, Matrix StateSpaceAggr, Map<Integer,Matrix> EventFiltration, double runtime, String fname, NetworkStruct sncopy)
	CtmcSsgResult(Matrix stateSpace, Matrix stateSpaceAggr, Matrix stateSpaceHashed, Map<Station,Matrix> nodeStateSpace, NetworkStruct sn)
	generatorResult(Matrix infGen, Map<Integer,Matrix> eventFilt, Map<Integer,Sync> ev)
	SolverCTMCResult(Matrix q, Matrix stateSpace, Matrix stateSpaceAggr, Map<Integer,Matrix> dfilt, double[][][] arvRates, double[][][] depRates, NetworkStruct sn)
	StateSpace(Matrix stateSpace, Map<Integer,Matrix> localStateSpace)
	symbolicResult(Matrix infGen, Map<Integer,Matrix> eventFilt, Map<Integer,Sync> syncInfo, Matrix stateSpace, Map<Integer,Matrix> nodeStateSpace)

Uses of Matrix in jline.solvers.fluid

Fields in jline.solvers.fluid declared as Matrix

Modifier and Type	Field	Description
Matrix[][]	SolverFluidResult.distribC
Matrix	SolverFluidResult.odeStateVec

Uses of Matrix in jline.solvers.fluid.analyzers

Fields in jline.solvers.fluid.analyzers declared as Matrix

Modifier and Type	Field	Description
Matrix	ClosingAndStateDepMethodsAnalyzer.xvec_it
Matrix	MatrixMethodAnalyzer.xvec_it
Matrix	ClosingAndStateDepMethodsAnalyzer.xvec_t
Matrix	MatrixMethodAnalyzer.xvec_t

Methods in jline.solvers.fluid.analyzers that return Matrix

Modifier and Type	Method	Description
Matrix	ClosingAndStateDepMethodsAnalyzer.getXVecIt()
Matrix	MatrixMethodAnalyzer.getXVecIt()
Matrix	MethodAnalyzer.getXVecIt()

Methods in jline.solvers.fluid.analyzers with parameters of type Matrix

Modifier and Type	Method	Description
boolean	ClosingAndStateDepMethodsAnalyzer.detectStiffnessUsingOstrowski(NetworkStruct sn, Matrix rate)

Uses of Matrix in jline.solvers.fluid.odes

Fields in jline.solvers.fluid.odes declared as Matrix

Modifier and Type	Field	Description
Matrix	MethodStepHandler.tVec
Matrix	TransientDataHandler.tVec
Matrix	MethodStepHandler.xVec
Matrix	TransientDataHandler.xVec

Constructors in jline.solvers.fluid.odes with parameters of type Matrix

Modifier	Constructor	Description
	ClosingAndStateDepMethodsODE(NetworkStruct sn, Map<Station,Map<JobClass,Matrix>> mu, Map<Station,Map<JobClass,Matrix>> phi, Map<Station,Map<JobClass,MatrixCell>> proc, Matrix rt, Matrix S, SolverOptions options)
	ClosingAndStateDepMethodsODE(NetworkStruct sn, Map<Station,Map<JobClass,Matrix>> mu, Map<Station,Map<JobClass,Matrix>> phi, Map<Station,Map<JobClass,MatrixCell>> proc, Matrix rt, Matrix S, SolverOptions options, int numDimensions)
	MatrixMethodODE(Matrix W, Matrix SQ, Matrix S, Matrix Qa, Matrix ALambda, int numDimensions)
	MatrixMethodODE(Matrix W, Matrix SQ, Matrix S, Matrix Qa, Matrix ALambda, int numDimensions, NetworkStruct sn, List<Double> pStarValues)

Constructor parameters in jline.solvers.fluid.odes with type arguments of type Matrix

Modifier	Constructor	Description
	ClosingAndStateDepMethodsODE(NetworkStruct sn, Map<Station,Map<JobClass,Matrix>> mu, Map<Station,Map<JobClass,Matrix>> phi, Map<Station,Map<JobClass,MatrixCell>> proc, Matrix rt, Matrix S, SolverOptions options)
	ClosingAndStateDepMethodsODE(NetworkStruct sn, Map<Station,Map<JobClass,Matrix>> mu, Map<Station,Map<JobClass,Matrix>> phi, Map<Station,Map<JobClass,MatrixCell>> proc, Matrix rt, Matrix S, SolverOptions options, int numDimensions)

Uses of Matrix in jline.solvers.fluid.smoothing

Methods in jline.solvers.fluid.smoothing that return Matrix

Modifier and Type	Method	Description
Matrix	PStarSearcher.generateTargetQueueLengths(Network model)

Methods in jline.solvers.fluid.smoothing with parameters of type Matrix

Modifier and Type	Method	Description
org.apache.commons.math3.optim.PointValuePair	PStarSearcher.findPStarValues(Network model, Matrix targetQueueLengths)

Constructors in jline.solvers.fluid.smoothing with parameters of type Matrix

Modifier	Constructor	Description
	CMAESObjectiveFunction(Matrix targetQueueLengths, Network model, boolean stiff)
	PStarOptimisationFunction(Matrix QNSSA, Network model, boolean stiff)

Uses of Matrix in jline.solvers.jmt

Methods in jline.solvers.jmt that return Matrix

Modifier and Type	Method	Description
Matrix	SolverJMT.getCdfRespT()
Matrix	SolverJMT.getCdfRespT(Map<Station,Map<JobClass,Metric>> R)
Matrix	SolverJMT.getTranCdfPassT()
Matrix	SolverJMT.getTranCdfPassT(Map<Station,Map<JobClass,Metric>> R)
Matrix	SolverJMT.getTranCdfRespT()
Matrix	SolverJMT.getTranCdfRespT(Map<Station,Map<JobClass,Metric>> R)

Methods in jline.solvers.jmt with parameters of type Matrix

Modifier and Type	Method	Description
double	SolverJMT.getProbAggr(Node node, Matrix state_a)

Uses of Matrix in jline.solvers.ln

Fields in jline.solvers.ln declared as Matrix

Modifier and Type	Field	Description
Matrix	SolverLN.arvproc_classes_updmap
Matrix	SolverLN.call_classes_updmap
Matrix	SolverLN.callresidt
Matrix	SolverLN.ilscaling
Matrix	SolverLN.njobs
Matrix	SolverLN.njobsorig
Matrix	SolverLN.ptaskcallers
Matrix	SolverLN.route_prob_updmap
Matrix	SolverLN.servt
Matrix	SolverLN.servt_classes_updmap
Matrix	SolverLN.servtmatrix
Matrix	SolverLN.thinkt
Matrix	SolverLN.thinkt_classes_updmap
Matrix	SolverLN.tput
Matrix	SolverLN.unique_route_prob_updmap
Matrix	SolverLN.util

Fields in jline.solvers.ln with type parameters of type Matrix

Modifier and Type	Field	Description
Map<Integer,Matrix>	SolverLN.ptaskcallers_step

Methods in jline.solvers.ln that return Matrix

Modifier and Type	Method	Description
Matrix	SolverLN.getArvproc_classes_updmap()
Matrix	SolverLN.getCall_classes_updmap()
Matrix	SolverLN.getEntryServiceMatrix()
Matrix	SolverLN.getEntryServiceMatrixRecursion(LayeredNetworkStruct lqn, int aidx, int eidx, Matrix U)
Matrix	SolverLN.getRoute_prob_updmap()
Matrix	SolverLN.getServt_classes_updmap()
Matrix	SolverLN.getThinkt_classes_updmap()
Matrix	SolverLN.integerMapToMatrix(Map<Integer,List<Integer[]>> cell)

Methods in jline.solvers.ln with parameters of type Matrix

Modifier and Type	Method	Description
Matrix	SolverLN.getEntryServiceMatrixRecursion(LayeredNetworkStruct lqn, int aidx, int eidx, Matrix U)

Uses of Matrix in jline.solvers.mam

Methods in jline.solvers.mam with parameters of type Matrix

Modifier and Type	Method	Description
static double	SolverMAM.qna_superpos(Matrix lambda, Matrix a2)

Uses of Matrix in jline.solvers.mva

Fields in jline.solvers.mva declared as Matrix

Modifier and Type	Field	Description
Matrix	SolverMVAResult.hitProb
Matrix	SolverMVAResult.missProb

Uses of Matrix in jline.solvers.mva.handlers

Methods in jline.solvers.mva.handlers that return types with arguments of type Matrix

Modifier and Type	Method	Description
Pair<Matrix,Matrix>	AMVALDHandler.solver_amvald_forward(List<Matrix> gamma, Matrix tau, Matrix Qchain_in, Matrix Xchain_in, Matrix Uchain_in, Matrix STchain_in, Matrix Vchain_in, Matrix Nchain_in, Matrix SCVchain_in, double Nt, double delta, Matrix deltaclass, List<Integer> ocl, List<Integer> ccl, List<Integer> nnzclasses, Map<Integer,List<Integer>> nnzclasses_eprio, Map<Integer,List<Integer>> nnzclasses_hprio, Map<Integer,List<Integer>> nnzclasses_ehprio, NetworkStruct sn, SolverOptions options)
Pair<Matrix,Matrix>	AMVALDHandler.solver_amvald_forward(List<Matrix> gamma, Matrix tau, Matrix Qchain_in, Matrix Xchain_in, Matrix Uchain_in, Matrix STchain_in, Matrix Vchain_in, Matrix Nchain_in, Matrix SCVchain_in, double Nt, double delta, Matrix deltaclass, List<Integer> ocl, List<Integer> ccl, List<Integer> nnzclasses, Map<Integer,List<Integer>> nnzclasses_eprio, Map<Integer,List<Integer>> nnzclasses_hprio, Map<Integer,List<Integer>> nnzclasses_ehprio, NetworkStruct sn, SolverOptions options)

Methods in jline.solvers.mva.handlers with parameters of type Matrix

Modifier and Type	Method	Description
static double	QNAHandler.qna_superpos(Matrix lambda, Matrix a2)
Pair<Matrix,Matrix>	AMVALDHandler.solver_amvald_forward(List<Matrix> gamma, Matrix tau, Matrix Qchain_in, Matrix Xchain_in, Matrix Uchain_in, Matrix STchain_in, Matrix Vchain_in, Matrix Nchain_in, Matrix SCVchain_in, double Nt, double delta, Matrix deltaclass, List<Integer> ocl, List<Integer> ccl, List<Integer> nnzclasses, Map<Integer,List<Integer>> nnzclasses_eprio, Map<Integer,List<Integer>> nnzclasses_hprio, Map<Integer,List<Integer>> nnzclasses_ehprio, NetworkStruct sn, SolverOptions options)

Method parameters in jline.solvers.mva.handlers with type arguments of type Matrix

Modifier and Type	Method	Description
Pair<Matrix,Matrix>	AMVALDHandler.solver_amvald_forward(List<Matrix> gamma, Matrix tau, Matrix Qchain_in, Matrix Xchain_in, Matrix Uchain_in, Matrix STchain_in, Matrix Vchain_in, Matrix Nchain_in, Matrix SCVchain_in, double Nt, double delta, Matrix deltaclass, List<Integer> ocl, List<Integer> ccl, List<Integer> nnzclasses, Map<Integer,List<Integer>> nnzclasses_eprio, Map<Integer,List<Integer>> nnzclasses_hprio, Map<Integer,List<Integer>> nnzclasses_ehprio, NetworkStruct sn, SolverOptions options)

Uses of Matrix in jline.solvers.nc

Fields in jline.solvers.nc declared as Matrix

Modifier and Type	Field	Description
Matrix	SolverNC.SolverNCLDReturn.C
Matrix	SolverNCResult.hitProb
Matrix	SolverNC.SolverNCMargReturn.lPr
Matrix	SolverNCResult.missProb
Matrix	SolverNC.SolverNCLDReturn.Q
Matrix	SolverNC.SolverNCReturn.Q
Matrix	SolverNCResult.Q
Matrix	SolverNC.SolverNCLDReturn.R
Matrix	SolverNC.SolverNCReturn.R
Matrix	SolverNCResult.R
Matrix	SolverNC.SolverNCReturn.STeff
Matrix	SolverNCResult.STeff
Matrix	SolverNC.SolverNCLDReturn.T
Matrix	SolverNC.SolverNCReturn.T
Matrix	SolverNCResult.T
Matrix	SolverNC.SolverNCLDReturn.U
Matrix	SolverNC.SolverNCReturn.U
Matrix	SolverNCResult.U
Matrix	SolverNC.SolverNCLDReturn.X
Matrix	SolverNC.SolverNCReturn.X
Matrix	SolverNCResult.X

Methods in jline.solvers.nc with parameters of type Matrix

Modifier and Type	Method	Description
Double	SolverNC.getProb(Node node, Matrix state)

Constructors in jline.solvers.nc with parameters of type Matrix

Modifier	Constructor	Description
	SolverNCLDReturn(Matrix Q, Matrix U, Matrix R, Matrix T, Matrix C, Matrix X, double lG, double runtime, int it, String method)
	SolverNCMargReturn(Matrix lPr, double G, double runtime)
	SolverNCReturn(Matrix Q, Matrix U, Matrix R, Matrix T, int C, Matrix X, double lG, Matrix STeff, int it, double runtime, String method)

Uses of Matrix in jline.solvers.ssa

Fields in jline.solvers.ssa declared as Matrix

Modifier and Type	Field	Description
final Matrix	SSAValues.pi
final Matrix	SSAValues.SSq
Matrix	SolverSSAResult.tranSync
final Matrix	SSAValues.tranSync

Fields in jline.solvers.ssa with type parameters of type Matrix

Modifier and Type	Field	Description
final Map<Integer,Matrix>	SSAValues.arvRates
final Map<Integer,Matrix>	SSAValues.depRates
Map<Station,Matrix>	SolverSSAResult.space
Map<Integer,Matrix>	SolverSSAResult.tranSysState
final Map<Integer,Matrix>	SSAValues.tranSysState

Constructors in jline.solvers.ssa with parameters of type Matrix

Modifier	Constructor	Description
	SolverSSAResult(Matrix QN, Matrix UN, Matrix RN, Matrix TN, Matrix CN, Matrix XN, Map<Integer,Matrix> tranSysState, Matrix tranSync, NetworkStruct sn)
	SSAValues(Matrix pi, Matrix SSq, Map<Integer,Matrix> arvRates, Map<Integer,Matrix> depRates, Map<Integer,Matrix> tranSysState, Matrix tranSync, NetworkStruct sn)

Constructor parameters in jline.solvers.ssa with type arguments of type Matrix

Modifier	Constructor	Description
	SolverSSAResult(Matrix QN, Matrix UN, Matrix RN, Matrix TN, Matrix CN, Matrix XN, Map<Integer,Matrix> tranSysState, Matrix tranSync, NetworkStruct sn)
	SSAValues(Matrix pi, Matrix SSq, Map<Integer,Matrix> arvRates, Map<Integer,Matrix> depRates, Map<Integer,Matrix> tranSysState, Matrix tranSync, NetworkStruct sn)

Uses of Matrix in jline.util

Fields in jline.util declared as Matrix

Modifier and Type	Field	Description
Matrix	Maths.infradius_h.alpha
Matrix	Maths.infradius_hnorm.alpha
Matrix	Maths.laplaceApproxReturn.H
Matrix	ComplexMatrix.im
Matrix	Maths.infradius_h.L
Matrix	Maths.infradius_hnorm.L
Matrix	Maths.nrl_h.L
Matrix	Maths.nrp_h.L
Matrix	PopulationLattice.sprodResult.n
Matrix	Maths.infradius_h.N
Matrix	Maths.infradius_hnorm.N
Matrix	ComplexMatrix.real
Matrix	PopulationLattice.sprodResult.s
Matrix	PopulationLattice.sprodResult.S
final Matrix	UniqueRowResult.sortedMatrix
Matrix	Maths.nrl_h.tsubtb
Matrix	Maths.nrp_h.tsubtb
final Matrix	UniqueRowResult.vi

Methods in jline.util that return Matrix

Modifier and Type	Method	Description
Matrix	Matrix.add(double alpha, Matrix matrix)
Matrix	Matrix.add(Matrix matrix)
static Matrix	Matrix.allbut(Matrix y, int k)	Returns all elements in a matrix except the first ones
static Matrix	Matrix.cartesian(Matrix matrixA, Matrix matrixB)	Cartesian product of two matrices.
Matrix	Matrix.ceil()	Computes the matrix resulted from ceiling every member of the current matrix
Matrix	Matrix.ceilEq()	Computes the matrix resulted from ceiling every member of the current matrix
static Matrix	Matrix.cell2mat(Map<Integer,Matrix> cellArray)
static Matrix	Matrix.cellsum(Map<Integer,Matrix> cell_array)
static Matrix	Maths.circul(int c)
static Matrix	Maths.circul(Matrix c)
Matrix	Matrix.clone()
static Matrix	Matrix.col_vector_add_row_vector(Matrix col_vector, Matrix row_vector)
Matrix	Matrix.colon()
Matrix	Matrix.columnMajorOrder()	Equivalent to the colon operator in MATLAB: (:).
Matrix	Matrix.compatible_sizes_add(Matrix b)
Matrix	Matrix.concatCols(Matrix other)	Concatenates the columns of two matrices
static Matrix	Matrix.concatColumns(Matrix left, Matrix right, Matrix out)
static Matrix	Matrix.concatRows(Matrix top, Matrix bottom, Matrix out)
Matrix	Matrix.countEachRow(double val)
Matrix	Matrix.createBlockDiagonal(Matrix matrix2)
static Matrix	Matrix.createLike(Matrix B)
Matrix	Matrix.cumsumViaCol()
Matrix	Matrix.cumsumViaRow()
static Matrix	Matrix.diag(double... values)
static Matrix	Matrix.diagMatrix(Matrix A, double[] values, int offset, int length)
Matrix	Matrix.div(Matrix den)
Matrix	Matrix.eigenvalue()
Matrix	Matrix.eigenvector()
Matrix	Matrix.element_divide(Matrix b)
Matrix	Matrix.element_power(double a)
Matrix	Matrix.elementDiv(Matrix B)	Performs element-wise division
Matrix	Matrix.elementIncrease(double val)
Matrix	Matrix.elementMult(Matrix B)
Matrix	Matrix.elementMult(Matrix B, Matrix output)
Matrix	Matrix.elementMultWithVector(Matrix B)	Performs element-wise multiplication Note that B is a row vector, and the result is A_{ij} = \sum_{j=1}^n A_{ij} * B(i)
Matrix	Matrix.elementPower(double t)
Matrix	Matrix.exp()
Matrix	Matrix.expm()	Adapted from jblas and IHMC Original documentation:
static Matrix	Matrix.expm(Matrix m)
static Matrix	Matrix.extract(Matrix src, int srcX0, int srcX1, int srcY0, int srcY1)
static Matrix	Matrix.extractColumn(Matrix A, int column, Matrix out)
static Matrix	Matrix.extractColumns(Matrix A, int col0, int col1)
static Matrix	Matrix.extractColumns(Matrix A, int col0, int col1, Matrix out)
static Matrix	Matrix.extractRows(Matrix A, int row0, int row1)
static Matrix	Matrix.extractRows(Matrix A, int row0, int row1, Matrix out)
static Matrix	Matrix.eye(int length)
Matrix	Matrix.fact()
Matrix	Matrix.factln()
static Matrix	Matrix.factln(Matrix n)	Computes log(x!) of all elements x of the input matrix
Matrix	Matrix.fill(double val)
Matrix	Matrix.find()
Matrix	Matrix.findNonNegative()
Matrix	Matrix.findNumber(double number)
Matrix	Matrix.findZero()
Matrix	Matrix.fromArray2D(double[][] matrix)
Matrix	Matrix.fromArray2D(int[][] matrix)
Matrix	MatrixCell.get(int i)
Matrix	Matrix.getColumn(int j)
Matrix	Matrix.getRow(int i)
Matrix	Matrix.getRowElements(int row)
Matrix	Matrix.getRowsFrom(int row)
Matrix	Matrix.getSlice(boolean[] rowFlags, boolean[] colFlags)
Matrix	Matrix.getSlice(int rowStart, int rowEnd, int colStart, int colEnd)
Matrix	Matrix.getSubMatrix(Matrix rows, Matrix cols)
Matrix	Matrix.hadamard(Matrix B)
static Matrix	Maths.hist(Matrix v, int minVal, int maxVal)	Implementation of MATLAB "hist": puts elements of v into k bins
Matrix	Matrix.inv()
static Matrix	Matrix.inv(Matrix m)
Matrix	Matrix.kron(Matrix b)
Matrix	Matrix.krons(Matrix other)
Matrix	Matrix.left_matrix_divide(Matrix b)
Matrix	Matrix.log()
Matrix	MatrixEquation.lookupSimple(String token)
static Matrix	Matrix.lyap(Matrix A, Matrix B, Matrix C, Matrix D)
static Matrix	Matrix.matrix_add_vector(Matrix matrix, Matrix vector)
Matrix	Matrix.meanCol()
Matrix	Matrix.meanRow()
Matrix	Matrix.mult(Matrix B)
Matrix	Matrix.mult(Matrix B, Matrix out)
static Matrix	Maths.multichoose(double n, double k)
static Matrix	Maths.multiChooseCon(Matrix n, double S)
static Matrix	Maths.nchoosek(Matrix v, int k)	Computes the combinations of the elements in v taken k at a time
static Matrix	Matrix.negative(Matrix a)
static Matrix	Maths.num_grad_h(Matrix x0, double h, SerializableFunction<Matrix,Matrix> hfun)
static Matrix	Maths.num_hess_h(Matrix x0, double h, SerializableFunction<Matrix,Matrix> hfun)
static Matrix	Matrix.oneMinusMatrix(Matrix matrix)
static Matrix	Matrix.oner(Matrix N, Integer s)	Decrease by one an element of an integer vector.
static Matrix	Matrix.oner(Matrix N, List<Integer> r)	Decrease by one an element of an integer vector.
static Matrix	Matrix.ones(int rows, int cols)
static Matrix	Maths.perms(Matrix vec)
static Matrix	Matrix.pow(Matrix a, int b)
static Matrix	PopulationLattice.pprod(Matrix n)
static Matrix	PopulationLattice.pprod(Matrix n, Matrix N)
static Matrix	Matrix.readFromFile(String fileName)
Matrix	Matrix.reciprocal()
Matrix	Matrix.repmat(int rows, int cols)
Matrix	Matrix.reverse()	For a vector, return a matrix with reversed index positions.
Matrix	Matrix.reverseRows()
Matrix	Matrix.right_matrix_divide(Matrix b)
Matrix	Matrix.safe_mult(Matrix B)
Matrix	Matrix.scale(double scalar)
static Matrix	Matrix.scale_mult(Matrix a, double n)
Matrix	MatrixCell.set(int i, Matrix D)
Matrix	Matrix.setColumn(int j, Matrix col)
Matrix	Matrix.setColumns(int j0, int j1, Matrix cols)
Matrix	Matrix.setRow(int j, Matrix row)
Matrix	Matrix.setRows(int i0, int i1, Matrix rows)
Matrix	Matrix.setSlice(int rowStart, int rowEnd, int colStart, int colEnd, Matrix newSlice)
static Matrix	Matrix.singleton(double value)
Matrix	Matrix.sort()	Sort the elements of the matrix
Matrix	Matrix.sortEq()	Sort the elements of the matrix
Matrix	Matrix.sqrt()
Matrix	Matrix.square()
Matrix	Matrix.sub(double x)
Matrix	Matrix.sub(double alpha, Matrix matrix)
Matrix	Matrix.sub(Matrix matrix)
Matrix	Matrix.sumCols()
Matrix	Matrix.sumCols(int startRow, int endRow)
Matrix	Matrix.sumRows()
Matrix	Matrix.sumRows(int startCol, int endCol)
static Matrix	Matrix.sylv(Matrix A, Matrix B, Matrix C)
Matrix	Matrix.transpose()
Matrix	Matrix.uniqueInCol(int colIdx)
Matrix	Matrix.uniqueInRow(int rowIdx)
Matrix	Matrix.uniqueNonNegativeInCol(int colIdx)
Matrix	Matrix.uniqueNonNegativeInRow(int rowIdx)
Matrix	Matrix.uniqueNonZerosInCol(int colIdx)
Matrix	Matrix.uniqueNonZerosInRow(int rowIdx)
static Matrix	Maths.uniquePerms(Matrix vec)
static Matrix	Matrix.zeros(int rows, int cols)

Methods in jline.util that return types with arguments of type Matrix

Modifier and Type	Method	Description
Map<String,Matrix>	Matrix.qr()
Map<String,Matrix>	Matrix.schur()
Map<String,Matrix>	Matrix.schur(String method, Integer it_)
Map<Integer,Matrix>	MatrixCell.toMap()

Methods in jline.util with parameters of type Matrix

Modifier and Type	Method	Description
Matrix	Matrix.add(double alpha, Matrix matrix)
Matrix	Matrix.add(Matrix matrix)
void	Matrix.addEq(double alpha, Matrix matrix)
void	Matrix.addEq(Matrix matrix)
static Matrix	Matrix.allbut(Matrix y, int k)	Returns all elements in a matrix except the first ones
ComplexMatrix	Maths.infradius_h.apply(Matrix x)
ComplexMatrix	Maths.infradius_hnorm.apply(Matrix x)
org.apache.commons.math3.complex.Complex	Maths.nrl_h.apply(Matrix x)
org.apache.commons.math3.complex.Complex	Maths.nrp_h.apply(Matrix x)
static Matrix	Matrix.cartesian(Matrix matrixA, Matrix matrixB)	Cartesian product of two matrices.
static Matrix	Maths.circul(Matrix c)
static Matrix	Matrix.col_vector_add_row_vector(Matrix col_vector, Matrix row_vector)
static double[]	Matrix.columnMatrixToDoubleArray(Matrix columnMatrix)
static boolean	Matrix.compare(Matrix A, Matrix B, String op)
boolean	Matrix.compareMatrix(Matrix matrix)
Matrix	Matrix.compatible_sizes_add(Matrix b)
Matrix	Matrix.concatCols(Matrix other)	Concatenates the columns of two matrices
static Matrix	Matrix.concatColumns(Matrix left, Matrix right, Matrix out)
static Matrix	Matrix.concatRows(Matrix top, Matrix bottom, Matrix out)
Matrix	Matrix.createBlockDiagonal(Matrix matrix2)
static Matrix	Matrix.createLike(Matrix B)
static Matrix	Matrix.diagMatrix(Matrix A, double[] values, int offset, int length)
Matrix	Matrix.div(Matrix den)
void	Matrix.divEq(Matrix den)
void	Matrix.divide(double scalar, Matrix outputB, boolean flag)
Matrix	Matrix.element_divide(Matrix b)
Matrix	Matrix.elementDiv(Matrix B)	Performs element-wise division
static double	Matrix.elementMinNonZero(Matrix matrix)
Matrix	Matrix.elementMult(Matrix B)
Matrix	Matrix.elementMult(Matrix B, Matrix output)
Matrix	Matrix.elementMultWithVector(Matrix B)	Performs element-wise multiplication Note that B is a row vector, and the result is A_{ij} = \sum_{j=1}^n A_{ij} * B(i)
static Matrix	Matrix.expm(Matrix m)
static Matrix	Matrix.extract(Matrix src, int srcX0, int srcX1, int srcY0, int srcY1)
static void	Matrix.extract(Matrix src, int srcX0, int srcX1, int srcY0, int srcY1, Matrix dst, int dstY0, int dstX0)
static Matrix	Matrix.extractColumn(Matrix A, int column, Matrix out)
static Matrix	Matrix.extractColumns(Matrix A, int col0, int col1)
static Matrix	Matrix.extractColumns(Matrix A, int col0, int col1, Matrix out)
static void	Matrix.extractDiag(Matrix A, Matrix outputB)
static Matrix	Matrix.extractRows(Matrix A, int row0, int row1)
static Matrix	Matrix.extractRows(Matrix A, int row0, int row1, Matrix out)
static Matrix	Matrix.factln(Matrix n)	Computes log(x!) of all elements x of the input matrix
static List<Integer>	Matrix.findIndexWithZeroSum(Matrix matrix, boolean isRow)
static List<Integer>	Matrix.findRows(Matrix matrix, Matrix row)
static double	Matrix.first_norm(Matrix a)
Matrix	Matrix.getSubMatrix(Matrix rows, Matrix cols)
Matrix	Matrix.hadamard(Matrix B)
static int	PopulationLattice.hashpop(Matrix n, Matrix N)
static int	PopulationLattice.hashpop(Matrix n, Matrix N, int R, Matrix prods)
static Matrix	Maths.hist(Matrix v, int minVal, int maxVal)	Implementation of MATLAB "hist": puts elements of v into k bins
static double	Matrix.inf_norm(Matrix a)
void	Matrix.insert_sub_matrix(int start_row, int start_col, int end_row, int end_col, Matrix matrix_to_be_inserted)
static List<Double>	Matrix.intersect(Matrix matrixA, Matrix matrixB)	Interesection of two matrices.
static Matrix	Matrix.inv(Matrix m)
boolean	Matrix.isEqualTo(Matrix m)	Checks if two matrices are equal
boolean	Matrix.isEqualToTol(Matrix m, double tol)	Checks if two matrices are equal within a tolerance
Matrix	Matrix.kron(Matrix b)
Matrix	Matrix.krons(Matrix other)
static Maths.laplaceApproxReturn	Maths.laplaceapprox_h(Matrix x0, SerializableFunction<Matrix,Matrix> h)
static Maths.laplaceApproxComplexReturn	Maths.laplaceapprox_h_complex(Matrix x0, SerializableFunction<Matrix,ComplexMatrix> h)
Matrix	Matrix.left_matrix_divide(Matrix b)
static double	Maths.logmeanexp(Matrix x)
static double	Matrix.logSum(Matrix matrix)
static double	Matrix.logsumexp(Matrix x)	Computes log(sum_i exp(x_i)) of all elements x_i of the input matrix
static Matrix	Matrix.lyap(Matrix A, Matrix B, Matrix C, Matrix D)
static double	Utils.mape(Matrix approx, Matrix exact)
static int	Matrix.matchrow(Matrix matrix, Matrix row)	Returns the position of the given row in the corresponding matrix
static Matrix	Matrix.matrix_add_vector(Matrix matrix, Matrix vector)
static double	Matrix.maxAbsDiff(Matrix a, Matrix b)
Matrix	Matrix.mult(Matrix B)
Matrix	Matrix.mult(Matrix B, Matrix out)
void	Matrix.multEq(Matrix B)
static Matrix	Maths.multiChooseCon(Matrix n, double S)
static double	Maths.multinomialln(Matrix n)
static Matrix	Maths.nchoosek(Matrix v, int k)	Computes the combinations of the elements in v taken k at a time
static Matrix	Matrix.negative(Matrix a)
static Matrix	Maths.num_grad_h(Matrix x0, double h, SerializableFunction<Matrix,Matrix> hfun)
static ComplexMatrix	Maths.num_grad_h_complex(Matrix x0, double h, SerializableFunction<Matrix,ComplexMatrix> hfun)
static Matrix	Maths.num_hess_h(Matrix x0, double h, SerializableFunction<Matrix,Matrix> hfun)
static ComplexMatrix	Maths.num_hess_h_complex(Matrix x0, double h, SerializableFunction<Matrix,ComplexMatrix> hfun)
static Matrix	Matrix.oneMinusMatrix(Matrix matrix)
static Matrix	Matrix.oner(Matrix N, Integer s)	Decrease by one an element of an integer vector.
static Matrix	Matrix.oner(Matrix N, List<Integer> r)	Decrease by one an element of an integer vector.
static Matrix	Maths.perms(Matrix vec)
static Matrix	Matrix.pow(Matrix a, int b)
static Matrix	PopulationLattice.pprod(Matrix n)
static Matrix	PopulationLattice.pprod(Matrix n, Matrix N)
Matrix	Matrix.right_matrix_divide(Matrix b)
static org.apache.commons.math3.complex.Complex[]	Maths.roots(Matrix coefficients)
Matrix	Matrix.safe_mult(Matrix B)
static Matrix	Matrix.scale_mult(Matrix a, double n)
void	Matrix.scaleEq(double scalar, Matrix output)
Matrix	MatrixCell.set(int i, Matrix D)
Matrix	Matrix.setColumn(int j, Matrix col)
Matrix	Matrix.setColumns(int j0, int j1, Matrix cols)
Matrix	Matrix.setRow(int j, Matrix row)
Matrix	Matrix.setRows(int i0, int i1, Matrix rows)
Matrix	Matrix.setSlice(int rowStart, int rowEnd, int colStart, int colEnd, Matrix newSlice)
void	Matrix.setSliceEq(int rowStart, int rowEnd, int colStart, int colEnd, Matrix newSlice)
void	Matrix.setTo(Matrix m)	Copy values of the input matrix
static double	Maths.simplex_fun(double[] x, Matrix L, Matrix N)
static boolean	Matrix.solve(Matrix a, Matrix b, Matrix x)
static PopulationLattice.sprodResult	PopulationLattice.sprod(int M, Matrix N)
static PopulationLattice.sprodResult	PopulationLattice.sprod(Matrix s, Matrix S, MatrixCell D)
Matrix	Matrix.sub(double alpha, Matrix matrix)
Matrix	Matrix.sub(Matrix matrix)
static List<Integer>	Maths.sub2ind(Matrix dims, Matrix row, Matrix col)
void	Matrix.subEq(double alpha, Matrix matrix)
void	Matrix.subEq(Matrix matrix)
static double	Matrix.sumCumprod(Matrix matrix)
static Matrix	Matrix.sylv(Matrix A, Matrix B, Matrix C)
org.ejml.data.DMatrixSparseCSC	Matrix.toDMatrixSparseCSC(Matrix matrix)
static Matrix	Maths.uniquePerms(Matrix vec)
static UniqueRowResult	Matrix.uniqueRowIndexes(Matrix m)
static UniqueRowResult	Matrix.uniqueRows(Matrix m)
static Set<Set<Integer>>	Matrix.weaklyConnect(Matrix param, Set<Integer> colsToIgnore)	Weakly-connected components of a sub-matrix.

Method parameters in jline.util with type arguments of type Matrix

Modifier and Type	Method	Description
static Matrix	Matrix.cell2mat(Map<Integer,Matrix> cellArray)
static Matrix	Matrix.cellsum(Map<Integer,Matrix> cell_array)
static int	Matrix.getColIndexSum(Map<Integer,Matrix> cellArray)
static Maths.laplaceApproxReturn	Maths.laplaceapprox_h(Matrix x0, SerializableFunction<Matrix,Matrix> h)
static Maths.laplaceApproxReturn	Maths.laplaceapprox_h(Matrix x0, SerializableFunction<Matrix,Matrix> h)
static Maths.laplaceApproxComplexReturn	Maths.laplaceapprox_h_complex(Matrix x0, SerializableFunction<Matrix,ComplexMatrix> h)
static Matrix	Maths.num_grad_h(Matrix x0, double h, SerializableFunction<Matrix,Matrix> hfun)
static Matrix	Maths.num_grad_h(Matrix x0, double h, SerializableFunction<Matrix,Matrix> hfun)
static ComplexMatrix	Maths.num_grad_h_complex(Matrix x0, double h, SerializableFunction<Matrix,ComplexMatrix> hfun)
static Matrix	Maths.num_hess_h(Matrix x0, double h, SerializableFunction<Matrix,Matrix> hfun)
static Matrix	Maths.num_hess_h(Matrix x0, double h, SerializableFunction<Matrix,Matrix> hfun)
static ComplexMatrix	Maths.num_hess_h_complex(Matrix x0, double h, SerializableFunction<Matrix,ComplexMatrix> hfun)

Constructors in jline.util with parameters of type Matrix

Modifier	Constructor	Description
	ComplexMatrix(Matrix real)
	ComplexMatrix(Matrix real, Matrix im)
	infradius_h(Matrix L, Matrix N, Matrix alpha)
	infradius_hnorm(Matrix L, Matrix N, Matrix alpha)
	laplaceApproxReturn(Matrix H, double I, double logI)
	Matrix(Matrix matrix)
	MatrixCell(Matrix[] x)
	MatrixCell(Matrix D0, Matrix D1)
	nrl_h(Matrix L, Matrix tsubtb, double Nt, Matrix alpha)
	nrp_h(Matrix L, Matrix tsubtb, double Nt, Matrix alpha)
	sprodResult(Matrix s, Matrix n, Matrix S, MatrixCell D)
	UndirectedGraph(Matrix param)
	UndirectedGraph(Matrix param, Set<Integer> colsToIgnore)
	UniqueRowResult(Matrix sortedMatrix, Matrix vi, Map<Integer,List<Integer>> vj)