Uses of Class
RdcPanda.Matrix

Packages that use Matrix
RdcPanda   
 

Uses of Matrix in RdcPanda
 

Methods in RdcPanda that return Matrix
 Matrix PdbRdc.bestFit(java.util.Vector<Pdb> pdbVec, java.util.Vector nhRdc, java.util.Vector<Dipolar> cahaRdc, double[] rdc1Cal, double[] rdc2Cal, double[] eigenValues)
          Best fit Two sets of RDC data from one medium such as NH and CH please note that the rotation matrix returned by the eigenValueDecomposition method is rather arbitrary so we need to make sure that only the righ handedone are returned.
 Matrix PdbRdc.bestFit4RDCs(java.util.Vector pdbVec, java.util.Vector nhRdc, java.util.Vector cahaRdc, java.util.Vector cacoRdc, java.util.Vector conRdc, double[] rdc1Cal, double[] rdc2Cal, double[] eigenValues)
          Best fit Two sets of RDC data from one medium such as NH and CH please note that the rotation matrix returned by the eigenValueDecomposition method is rather arbitrary so we need to make sure only the righ handedone are returned.
 Matrix Matrix.copy()
          Make a deep copy of a matrix.
 Matrix PdbRdc.eulerFit_old(java.util.Vector pdbVec, java.util.Vector rdcVec1, java.util.Vector rdcVec2, double Syy, double Szz, double[] rmsds, double resolution, boolean debug)
          Compute three Euler angles using two sets of RDC data and the corresponding Saupe elements Basic steps: extract the NH vectors with the corresponding RDC data as an array (for efficiency) For all the values of three Euler angles first compute the new NH directions after the rotation then compute the RDCs and RMSD from the new NH directions.
 Matrix PdbRdc.eulerFit(java.util.Vector<Pdb> pdbVec, java.util.Vector<Dipolar> rdcVec1, java.util.Vector<Dipolar> rdcVec2, double Syy, double Szz, double[] rmsds, double resolution, boolean debug)
          Note: Lincong's has a serious bug.
 Matrix PdbRdc.eulerFit4RDCs(java.util.Vector<Pdb> pdbVec, java.util.Vector<Dipolar> rdcVec1, java.util.Vector<Dipolar> rdcVec2, java.util.Vector<Dipolar> rdcVecCaCo, java.util.Vector<Dipolar> rdcVecCoN, double Syy, double Szz, double[] rmsds, double resolution, boolean debug)
          Note: Lincong's has a serious bug.
 Matrix PdbRdc.eulerFitHB(java.util.Vector pdbVec, java.util.Vector rdcVec1, java.util.Vector rdcVec2, double[] saupe, Matrix rot, double[] rmsds, double resolution, double weight4HB, java.util.Vector pdbVecS1, java.util.Vector hbVec, Matrix mat4Dirs, boolean debug)
          Compute three Euler angles using two sets of RDC data and the corresponding Saupe elements Basic steps: extract the NH vectors with the corresponding RDC data as an array (for efficiency) For all the values of three Euler angles first compute the new NH directions after the rotation then compute the RDCs and RMSD from the new NH directions.
 Matrix PdbRdc.eulerFitPrintEnsemble(java.util.Vector<Pdb> pdbVec, java.util.Vector<Dipolar> rdcVec1, java.util.Vector<Dipolar> rdcVec2, double Syy, double Szz, double[] rmsds, double resolution, boolean debug, double RdcRmsdThreshold)
          print out all pdb orientations in which rdc rmsd is smaler than some threshold, in grid search.
 Matrix Matrix.eulerMat(double alpha, double beta, double gamma)
          A method for generating an euler Matrix from three Euler angles.
 Matrix PdbRdc.fit4MissingRdc(java.util.Vector pdbVec, java.util.Vector rdcVec1, java.util.Vector rdcVec2, double Syy, double Szz, double[] rmsds, double resolution, boolean debug)
          Compute three Euler angles using two sets of RDC data (pissbile missing) and the corresponding Saupe elements Basic steps: extract the NH vectors with the corresponding RDC data as an array (for efficiency) For all the values of three Euler angles first compute the new NH directions after the rotation then compute the RDCs and RMSD from the new NH directions.
 Matrix PdbRdc.fit4MissingRdcHB(java.util.Vector pdbVec, java.util.Vector rdcVec1, java.util.Vector rdcVec2, double Syy, double Szz, java.util.Vector pdbVecA, double[] rmsds, double resolution, double weight4HB, java.util.Vector hbVec, boolean debug)
          Compute three Euler angles using two sets of RDC data (pissbile missing) and the corresponding Saupe elements Basic steps: extract the NH vectors with the corresponding RDC data as an array (for efficiency) For all the values of three Euler angles first compute the new NH directions after the rotation then compute the RDCs and RMSD from the new NH directions.
 Matrix PdbRdc.fit4MissingRdcHB2(java.util.Vector pdbVec, java.util.Vector rdcVec1, java.util.Vector rdcVec2, double Syy, double Szz, java.util.Vector pdbVecA1, java.util.Vector pdbVecA2, double[] rmsds, double resolution, double weight4HB, java.util.Vector hbVec1, java.util.Vector hbVec2, boolean debug)
          Compute three Euler angles using two sets of RDC data (pissbile missing) and the corresponding Saupe elements Basic steps: extract the NH vectors with the corresponding RDC data as an array (for efficiency) For all the values of three Euler angles first compute the new NH directions after the rotation then compute the RDCs and RMSD from the new NH directions.
 Matrix EigenvalueDecomposition.getD()
          Return the block diagonal eigenvalue matrix
 Matrix SingularValueDecomposition.getS()
          Return the diagonal matrix of singular values.
 Matrix SingularValueDecomposition.getU()
          Return the left singular vectors.
 Matrix SingularValueDecomposition.getV()
          Return the right singular vectors.
 Matrix EigenvalueDecomposition.getV()
          Return the eigenvector matrix
static Matrix Matrix.identity(int m, int n)
          Generate identity matrix.
 Matrix Matrix.minus(Matrix B)
          C = A - B.
 Matrix PhiPsi.newRG(double phi, double psi, Matrix rg)
          Method for the computation of new N->CA vector for residue $i+1$ from the computed \Phi and Psi angles of residue $i$.
 Matrix PhiPsi.newRG(double phi, double psi, Matrix rg, boolean rightHand)
          Method for the computation of new N->CA vector for residue $i+1$ from the computed \Phi and Psi angles of residue $i$.
 Matrix Peak.noeAssignMat(java.util.Vector h1Vec, java.util.Vector asgVec)
          Compute the possbile NOE assignment matrix, an idea not further pursued.
 Matrix Matrix.plus(Matrix B)
          C = A + B.
 Matrix ppGlobal.RgCal(double[] nToh, double gamma)
          compute global rotation (Rg) with two no colinear vectors Rg is the same as the last method Here the input are the NH vector and one Euler angle gamma for the N(i)->CA(i) vector accounting the rotation of the peptide plane along the NH vector.
 Matrix ppGlobal.RgCal(double[] nToh, double[] nToca)
          compute global rotation (Rg) with two noncolinear vectors, Rg is the rotation matrix for rotating the PDB coordinate system into the following system: +z-axis along the bond NH(i)->N(i), "->" means from atom N(i) to atom NH(i).
 Matrix PhiPsi.RgCal(double[] nToh, double[] nToca)
          Compute the global rotation matrix for rotating a coordinate frame such as the PDB frame where the two vectors NH(i)->N(i) (nToh) and N(i)->CA(i) (nToca) defined into the following frame: +Z-axis along the bond NH(i)->N(i), "->" means from nuclear NH(i) to nuclear N(i).
 Matrix ppGlobal.RgCal(double[] nToh, double[] nToca, boolean rightHand)
          Rg cal.
 Matrix PhiPsi.RgCal(double[] nToh, double[] nToca, boolean rightHand)
          Rg cal.
 Matrix Matrix.rotationMat(double theta, java.lang.String axis)
          make a 3x3 rotation matrix with a rotation angle theta and along an axis Please note that only axis only take +/-x, y, z A method by Lincong Wang.
 Matrix[] sp3Carbon.tetrahedral(double[] center, Matrix mat, sp3Carbon atomC)
          Compute the coordinates of sp3 atoms from a sp3Carbon object.
 Matrix Matrix.times(double s)
          Multiply a matrix by a scalar, C = s*A.
 Matrix Matrix.times(Matrix B)
          Linear algebraic matrix multiplication, A * B.
 Matrix Matrix.transpose()
          Matrix transpose.
 Matrix Matrix.uminus()
          -a of every elements.
 

Methods in RdcPanda with parameters of type Matrix
 double PdbRdc.BackCal(java.util.Vector<Pdb> pdbVec, java.util.Vector<Dipolar> rdcVec, java.lang.String atom1, java.lang.String atom2, Matrix mm, double Sxx, double Syy, double Szz, double rdcRatio, double[] rdcBc)
          For back-computing RDCs.
 double PdbRdc.BackCal(java.util.Vector<Pdb> pdbVec, java.util.Vector<Dipolar> rdcVec, java.lang.String atom1, java.lang.String atom2, Matrix mm, double Sxx, double Syy, double Szz, double rdcRatio, double[] rdcBc, double[] squareRmsd, int[] size)
          For back-computing RDCs.
 double PdbRdc.BackCalCACO(java.util.Vector<Pdb> pdbVec, java.util.Vector<Dipolar> rdcVec, java.lang.String atom1, java.lang.String atom2, Matrix mm, double Sxx, double Syy, double Szz, double rdcRatio, double[] rdcBc, double[] squareRmsd, int[] size, boolean isPrint)
          For back-computing RDCs.
 double PdbRdc.BackCalCACOOnePdb(java.util.Vector<Pdb> pdbVec, java.util.Vector<Dipolar> rdcVec, java.lang.String atom1, java.lang.String atom2, Matrix mm, double Sxx, double Syy, double Szz, double rdcRatio)
          compute rdc rmsd for only one pdb.
 double PdbRdc.BackCalCON(java.util.Vector<Pdb> pdbVec, java.util.Vector<Dipolar> rdcVec, java.lang.String atom1, java.lang.String atom2, Matrix mm, double Sxx, double Syy, double Szz, double rdcRatio, double[] rdcBc, double[] squareRmsd, int[] size, boolean isPrint)
          For back-computing RDCs from Co at residue i to N at residue i+1.
 double PdbRdc.BackCalCONOnePdb(java.util.Vector<Pdb> pdbVec, java.util.Vector<Dipolar> rdcVec, java.lang.String atom1, java.lang.String atom2, Matrix mm, double Sxx, double Syy, double Szz, double rdcRatio)
          compute rdc rmsd for only one pdb from Co at residue i to N at residue i+1.
 double PdbRdc.BackCalNH(java.util.Vector<Pdb> pdbVec, java.util.Vector<Dipolar> rdcVec, java.lang.String atom1, java.lang.String atom2, Matrix mm, double Sxx, double Syy, double Szz, double rdcRatio, double[] rdcBc)
          For back-computing NH RDCs since the NH RDC of the fiest residue is NOT used in the DFS-based refinement.
 double PdbRdc.BackCalNH(java.util.Vector<Pdb> pdbVec, java.util.Vector<Dipolar> rdcVec, java.lang.String atom1, java.lang.String atom2, Matrix mm, double Sxx, double Syy, double Szz, double rdcRatio, double[] rdcBc, double[] squareRmsd, int[] size)
          For back-computing NH RDCs since the NH RDC of the fiest residue is NOT used in the DFS-based refinement.
 double PdbRdc.BackCalNHOne(java.util.Vector<Pdb> pdbVec, java.util.Vector<Dipolar> rdcVec, java.lang.String atom1, java.lang.String atom2, Matrix mm, double Sxx, double Syy, double Szz, double rdcRatio, double[] rdcBc, double[] squareRmsd, int[] size)
          compute the RDC deviation for one residue.
 double PdbRdc.BackCalOne(java.util.Vector<Pdb> pdbVec, java.util.Vector<Dipolar> rdcVec, java.lang.String atom1, java.lang.String atom2, Matrix mm, double Sxx, double Syy, double Szz, double rdcRatio, double[] rdcBc, double[] squareRmsd, int[] size)
          compute rdc deviation for one residue For back-computing RDCs.
 double PdbRdc.BackCalOnePdb(java.util.Vector<Pdb> pdbVec, java.util.Vector<Dipolar> rdcVec, java.lang.String atom1, java.lang.String atom2, Matrix mm, double Sxx, double Syy, double Szz, double rdcRatio)
          compute rdc rmsd for only one pdb.
 double[] PdbRdc.BackCalRdcs(java.util.Vector pdbVec, java.util.Vector rdcVec, java.lang.String atom1, java.lang.String atom2, Matrix mm, double Sxx, double Syy, double Szz)
          For back-computing RDCs.
 double[] PhiPsi.ca2caDirCal(double phi, double psi, double[] ca1, Matrix rg)
          A method for computing the the Vector CA(i)-->CA(i+1), between the CA(i) and CA(i+1) begin with an frame defined in the peptide plane i.
 double[] PhiPsi.caByNextPeptidePlane(double[] n1, Matrix rg)
          Ca by next peptide plane.
 Matrix PdbRdc.eulerFitHB(java.util.Vector pdbVec, java.util.Vector rdcVec1, java.util.Vector rdcVec2, double[] saupe, Matrix rot, double[] rmsds, double resolution, double weight4HB, java.util.Vector pdbVecS1, java.util.Vector hbVec, Matrix mat4Dirs, boolean debug)
          Compute three Euler angles using two sets of RDC data and the corresponding Saupe elements Basic steps: extract the NH vectors with the corresponding RDC data as an array (for efficiency) For all the values of three Euler angles first compute the new NH directions after the rotation then compute the RDCs and RMSD from the new NH directions.
 Matrix Matrix.minus(Matrix B)
          C = A - B.
 double[] PhiPsi.newNCA(double phi, double psi, Matrix rg)
          Method for the computation of new N->CA vector for residue $i+1$ from the computed \Phi and Psi angles.
 java.util.Vector Pdb.newPdb(java.util.Vector pdbVec, Matrix R)
          compute new PDB coordinates after the rotation by matrix R.
 Matrix PhiPsi.newRG(double phi, double psi, Matrix rg)
          Method for the computation of new N->CA vector for residue $i+1$ from the computed \Phi and Psi angles of residue $i$.
 Matrix PhiPsi.newRG(double phi, double psi, Matrix rg, boolean rightHand)
          Method for the computation of new N->CA vector for residue $i+1$ from the computed \Phi and Psi angles of residue $i$.
 java.util.Vector PhiPsi.phiCal(double Syy, double Szz, double rdc, Matrix rg)
          Compute the Phi angles.
 java.util.Vector PhiPsi.phiCal(double Syy, double Szz, double rdc, Matrix Rg, boolean isHelix)
          Compute the Phi angles.
 java.util.Vector PhiPsi.phiCal(double Syy, double Szz, double rdc, Matrix Rg, boolean isHelix, int curResNo, java.util.Vector vecTalos)
          Compute the Phi angles.
 java.util.Vector Loops.phiCalAll(double Syy, double Szz, double rdc, Matrix Rg)
          Compute the Phi angles from RDC equations.
 java.util.Vector PhiPsi.phiCalBackward(double Syy, double Szz, double rdc, double psi, Matrix rg)
          Compute the Psi angles.
 java.util.Vector PhiPsi.phiCalLoop(double Syy, double Szz, double rdc, Matrix Rg)
          Compute the Phi angles for loop fragment.
 boolean PhiPsi.phiPsiByCa(Matrix rg, double[] cacaVec, double[][] solutions)
          ********************************************************************************* This method compute the \Phi and \Psi pair from the coordinates of CA(i) and CA(i+1) EXACTLY assuming the six angles are known.
 boolean PhiPsi.phiPsiByPP14(double[] ca1, double[] n4, double[] ca4, double[] nh4, Matrix rg1, Matrix rg4, java.util.Vector solutionVec)
          Compute the CA directions of residues 2 and 3 specified by polar angles (theta, phi), given the CA coordinates for residue 1 and 3 and the theta polar angle for residue 2.
 boolean PhiPsi.phiPsiByRdcNoe(java.util.Vector asgVec, double[][] restraints, double Syy, double Szz, double[] n0, double[] nh0, double[] ca0, Matrix rg, int depth, int N, double[] ppS, java.util.Vector ppVec, double[] nToNHVec2, double[] nToCAVec2, double[] ca2)
          A recusive function to compute all the backbone (phi, psi) angles for an $m$-residue fragment This is a version for real computation, NOT for collecting running statistics.
 boolean PhiPsi.phiPsiChain(double[] rdcArr1, double[] rdcArr2, Matrix rg, double Syy, double Szz, int i, int N, double[] ppS, java.util.Vector ppVec, boolean rightHand, boolean isHelix)
          A recusive function to compute all the backbone (phi, psi) angles for an $N$-residue fragment This is a version for real computation, NOT for collecting running statistics.
 boolean Loops.phiPsiChainAll(double[] rdcArrCH, double[] rdcArrNH, int[] isChRDC, int[] isNhRDC, Matrix rg, double Syy, double Szz, int i, int resNo, int N, double[] ppS, java.util.Vector ppVec, boolean rightHand, int resNoStart)
          A recusive function to compute all the backbone (phi, psi) angles for a fragment.
 boolean PhiPsi.phiPsiChainTalos(double[] rdcArr1, double[] rdcArr2, Matrix rg, double Syy, double Szz, int i, int N, double[] ppS, java.util.Vector ppVec, boolean rightHand, boolean isHelix, int firstResNo, java.util.Vector vecTalos)
          A recusive function to compute all the backbone (phi, psi) angles for an $N$-residue fragment This is a version for real computation, NOT for collecting running statistics.
 Matrix Matrix.plus(Matrix B)
          C = A + B.
 java.util.Vector PhiPsi.psiCal(double Syy, double Szz, double rdc, double phi, Matrix rg)
          Compute the Psi angles.
 java.util.Vector PhiPsi.psiCal(double Syy, double Szz, double rdc, double phi, Matrix rg, boolean isHelix)
          Compute the Psi angles.
 java.util.Vector PhiPsi.psiCal(double Syy, double Szz, double rdc, double phi, Matrix rg, boolean isHelix, int curResNo, java.util.Vector vecTalos)
          Compute the Psi angles.
 java.util.Vector Loops.psiCalAll(double Syy, double Szz, double rdc, double phi, Matrix rg)
          Compute the Psi angles.
 java.util.Vector PhiPsi.psiCalBackward(double Syy, double Szz, double rdc, Matrix rg)
          Compute the Phi angles.
 java.util.Vector PhiPsi.psiCalLoop(double Syy, double Szz, double rdc, double phi, Matrix rg)
          Compute the Psi angles for loops.
 Matrix[] sp3Carbon.tetrahedral(double[] center, Matrix mat, sp3Carbon atomC)
          Compute the coordinates of sp3 atoms from a sp3Carbon object.
 Matrix Matrix.times(Matrix B)
          Linear algebraic matrix multiplication, A * B.
 

Constructors in RdcPanda with parameters of type Matrix
EigenvalueDecomposition(Matrix Arg, boolean issymmetric)
          Check for symmetry, then construct the eigenvalue decomposition
SingularValueDecomposition(Matrix Arg)
          Construct the singular value decomposition.