C# Class Scimark_Csharp_Android.LU

LU matrix factorization. (Based on TNT implementation.) Decomposes a matrix A into a triangular lower triangular factor (L) and an upper triangular factor (U) such that A = L*U. By convnetion, the main diagonal of L consists of 1's so that L and U can be stored compactly in a NxN matrix.

Mostra file Open project: zanew/MonovsDalvik

Public Methods

Method	Description
LU ( double A ) : System	Initalize LU factorization from matrix.
factor ( double A, int pivot ) : int	LU factorization (in place).
new_copy ( int x ) : int[]
num_flops ( int N ) : double	Returns a copy of the compact LU factorization. (useful mainly for debugging.)
solve ( double b ) : double[]	Solve a linear system, with pre-computed factorization.
solve ( double A, int pvt, double b ) : void	Solve a linear system, using a prefactored matrix in LU form.

Protected Methods

Method	Description
insert_copy ( double B, double A ) : void
new_copy ( double x ) : double[]
new_copy ( double A ) : double[][]

Method Details

LU() public method

Initalize LU factorization from matrix.

public LU ( double A ) : System
A	double	/// (in) the matrix to associate with this factorization. /// ///
return	System

factor() public static method

LU factorization (in place).

public static factor ( double A, int pivot ) : int
A	double	/// (in/out) On input, the matrix to be factored. /// On output, the compact LU factorization. ///
pivot	int	/// (out) The pivot vector records the /// reordering of the rows of A during factorization. ///
return	int

insert_copy() protected static method

protected static insert_copy ( double B, double A ) : void
B	double
A	double
return	void

new_copy() protected static method

protected static new_copy ( double x ) : double[]
x	double
return	double[]

new_copy() protected static method

protected static new_copy ( double A ) : double[][]
A	double
return	double[][]

new_copy() public static method

public static new_copy ( int x ) : int[]
x	int
return	int[]

num_flops() public static method

Returns a copy of the compact LU factorization. (useful mainly for debugging.)

public static num_flops ( int N ) : double
N	int
return	double

solve() public method

Solve a linear system, with pre-computed factorization.

public solve ( double b ) : double[]
b	double	/// (in) the right-hand side. ///
return	double[]

solve() public static method

Solve a linear system, using a prefactored matrix in LU form.

public static solve ( double A, int pvt, double b ) : void
A	double	(in) the factored matrix in LU form. ///
pvt	int
b	double	(in/out) On input, the right-hand side. /// On output, the solution vector. /// ///
return	void