Examples of org.jquantlib.math.matrixutilities.Matrix

Package org.jquantlib.math.matrixutilities

Examples of org.jquantlib.math.matrixutilities.Matrix

org.jquantlib.math.matrixutilities.Matrix
Bidimensional matrix operations
Performance of multidimensional arrays is a big concern in Java. This is because multidimensional arrays are stored as arrays of arrays, spanning this concept to as many depths as necessary. In C++, a multidimensional array is stored internally as a unidimensional array where depths are stacked together one after another. A very simple calculation is needed in order to map multiple dimensional indexes to an unidimensional index.
This class provides a C/C++ like approach of internal unidimensional array backing a conceptual bidimensional matrix. This mapping is provided by method op(int row, int col) which is responsible for returning the physical address of the desired tuple , given a certain access method.
The mentioned access method is provided by a concrete implementation of {@link Address} which is passed to constructors.Doing so, it is possible to access the same underlying unidimensional data storage in various different ways, which allows us obtain another Matrix (see method {@link Matrix#range(int,int,int,int) and alike}) from an existing Matrix without any need of copying the underlying data. Certain operations benefit a lot from such approach, like {@link Matrix#transpose()} whichpresents constant execution time.
The price we have to pay for such flexibility and benefits is that an access method is necessary, which means that a the bytecode may potentially need a dereference to a class which contain the concrete implementation of method op(int row, int col). In order to keep this cost at minimum, implementation of access method keep indexes at hand whenever possible, in order to being able to calculate the actual unidimensional index as fast as possible. This additional dereference impacts performance more or less in the same ways dereference impacts performance when a bidimensional array (double[][]) is employed. Contrary to the bidimensional implementation, our implementation can potentially benefit from bytecode inlining, which means that calculation of the unidimensional index can be performed potentially faster than calculation of address location when a bidimensional array (double[][]) is used as underlying storage.

Assignment operations
```
 opr method     this    right    result --- ---------- ------- -------- ------ =   assign     Matrix           Matrix (1) +=  addAssign  Matrix  Matrix   this -=  subAssign  Matrix  Matrix   this *=  mulAssign  Matrix  scalar   this /=  divAssign  Matrix  scalar   this 
```
Algebraic products
```
 opr method     this    right    result --- ---------- ------- -------- ------ +   add        Matrix  Matrix   Matrix -   sub        Matrix  Matrix   Matrix -   negative   Matrix           this *   mul        Matrix  scalar   Matrix /   div        Matrix  scalar   Matrix 
```
Vectorial products
```
 method         this    right    result -------------- ------- -------- ------ mul            Matrix  Array    Array mul            Matrix  Matrix   Matrix 
```
Decompositions
```
 method         this    right    result -------------- ------- -------- ------ lu             Matrix           LUDecomposition qr             Matrix           QRDecomposition cholensky      Matrix           CholeskyDecomposition svd            Matrix           SingularValueDecomposition eigenvalue     Matrix           EigenvalueDecomposition 
```
Element iterators
```
 method         this    right    result ------------   ------- -------- ------ rowIterator    Matrix           RowIterator columnIterator Matrix           ColumnIterator 
```
Miscellaneous
```
 method         this    right    result -------------- ------- -------- ------ transpose      Matrix           Matrix diagonal       Matrix           Array determinant    Matrix           double inverse        Matrix           Matrix solve          Matrix           Matrix swap           Matrix  Matrix   this range          Matrix  Matrix   Matrix 
```
(1): clone()
(2): Unary + is equivalent to: array.clone()
(3): Unary ? is equivalent to: array.clone().mulAssign(-1)
@note This class is not thread-safe @author Richard Gomes

    }


    @Override
    // TODO: review iterators
    public Matrix diffusion(/*@Time*/ final double t, final Array x){
        final Matrix pca = corrModel_.pseudoSqrt(t, x);
        // TODO: code review :: use of clone()
        final Array  vol = volaModel_.volatility(t, x);
        for (int i=0; i<size_; ++i) {
            pca.rangeRow(i).mulAssign(vol.get(i));
        }
        return pca;
    }

View Full Code Here


    @Override
    public Matrix covariance(/* @Time */final double t, final Array x) {
        // TODO: code review :: use of clone()
        final Array volatility = volaModel_.volatility(t, x);
        final Matrix correlation = corrModel_.correlation(t, x);


        final Matrix tmp = new Matrix(size_, size_);
        for (int i = 0; i < size_; ++i) {
            for (int j = 0; j < size_; ++j) {
                tmp.set(i, j, volatility.get(i) * correlation.get(i, j) * volatility.get(j));
            }
        }


        return tmp;
    }

View Full Code Here


    @Override
    public final /*@Diffusion*/ Matrix diffusion(final /*@Time*/ double t, /*@Real*/ final Array x) {
        QL.require(x.size()==1 , ARRAY_1D_REQUIRED); // QA:[RG]::verified // TODO: message
        final double v = diffusion(t, x.first());
        return new Matrix(1, 1).fill(v);
    }

View Full Code Here


    @Override
    public final /*@StdDev*/ Matrix stdDeviation(final /*@Time*/ double t0, final /*@Real*/ Array x0, final /*@Time*/ double dt) {
        QL.require(x0.size()==1 , ARRAY_1D_REQUIRED); // QA:[RG]::verified // TODO: message
        final double v = stdDeviation(t0, x0.first(), dt);
        return new Matrix(1, 1).fill(v);
    }

View Full Code Here


    @Override
    public final /*@Covariance*/ Matrix covariance(final /*@Time*/ double t0, final /*@Real*/ Array x0, final /*@Time*/ double dt) {
        QL.require(x0.size()==1 , ARRAY_1D_REQUIRED); // QA:[RG]::verified // TODO: message
        final double v = discretization1D.varianceDiscretization(this, t0, x0.first(), dt);
        return new Matrix(1, 1).fill(v);
    }

View Full Code Here

        this.lowerExtrapolation = lowerExtrapolation;
        this.upperExtrapolation = upperExtrapolation;




        this.times = new Array(dates.length+1); // TODO: verify if length is correct
        this.variances = new Matrix(strikes.size(), dates.length+1); // TODO: verify if length is correct
        this.strikes = new Array(strikes.size()+1); // TODO: verify if length is correct


        for(int i = 1; i < strikes.size()+1; i++) {
            this.strikes.set(i, strikes.get(i-1));
        }

View Full Code Here

                : (discretization_ == Discretization.Reflection)
                ? -Math.sqrt(-x1)
                        : 0.0;
                final double sigma2 = sigmav_ * vol;


                final Matrix result = new Matrix(2, 2);
                result.set(0, 0, vol);
                result.set(0, 1, 0.0);
                result.set(1, 0, rhov_ * sigma2);
                result.set(1, 1, sqrhov_ * sigma2);
                return result;
    }

View Full Code Here

    }


    @Override
    public Array drift(/* @Time */final double t, final Array x) {
        final Array f = new Array(size_);
        final Matrix covariance = lfmParam_.covariance(t, x);
        final int m = 0;//NextA
        for (int k = m; k < size_; ++k) {
            m1.set(k, accrualPeriod_.get(k) * x.get(k) / (1 + accrualPeriod_.get(k) * x.get(k)));
            final double value = m1.innerProduct(covariance.constRangeCol(k), m, k+1-m) - 0.5 * covariance.get(k, k);
            f.set(k, value);
        }
        return f;
    }

View Full Code Here

            throw new UnsupportedOperationException("work in progress");
        final int m   = 0;//nextIndexReset(t0);
        final double sdt = Math.sqrt(dt);


        final Array f = x0.clone();
        final Matrix diff       = lfmParam_.diffusion(t0, x0);
        final Matrix covariance = lfmParam_.covariance(t0, x0);


        // TODO: review iterators
        for (int k=m; k<size_; ++k) {
            final double y = accrualPeriod_.get(k)*x0.get(k);
            m1.set(k,y/(1+y));


            final double d = (m1.innerProduct(covariance.constRangeCol(k), m, k+1-m)-0.5*covariance.get(k, k)) * dt;
            final double r = diff.rangeRow(k).innerProduct(dw)*sdt;
            final double x = y*Math.exp(d + r);
            m2.set(k, x/(1+x));


            final double ip = m2.innerProduct(covariance.constRangeCol(k), m, k+1-m);
            final double value = x0.get(k) * Math.exp(0.5*(d+ip-0.5*covariance.get(k,k))*dt) + r;
            f.set(k, value);
        }


        return f;
    }

View Full Code Here

    public Matrix diffusion(/* @Time */final double t) {
        return diffusion(t, new Array());
    }


    public Matrix covariance(/* @Time */final double t, final Array x) {
        final Matrix sigma = this.diffusion(t, x);
        return sigma.mul(sigma.transpose());
    }

View Full Code Here

0 1 2 3 4 5 6

TOP

Related Classes of org.jquantlib.math.matrixutilities.Matrix

org.jquantlib.legacy.libormarkets.LfmCovarianceProxy

org.jquantlib.legacy.libormarkets.LmLinearExponentialCorrelationModel

org.jquantlib.math.matrixutilities.internal.Address.MatrixAddress.MatrixOffset

org.jquantlib.math.matrixutilities.internal.DirectArrayColAddress

org.jquantlib.math.matrixutilities.internal.DirectArrayRowAddress

org.jquantlib.math.matrixutilities.internal.DirectMatrixAddress

org.jquantlib.math.matrixutilities.internal.MappedMatrixAddress

org.jquantlib.math.optimization.LeastSquareFunction

org.jquantlib.math.statistics.GenericSequenceStatistics

org.jquantlib.methods.lattices.TreeLattice2D

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.