Psi4
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
psi Namespace Reference

This is all defined in python.cc initialize. More...

Namespaces

 adc
 
 ccdensity
 
 ccenergy
 
 cceom
 
 cchbar
 
 cclambda
 
 ccresponse
 
 cctransort
 
 cctriples
 
 dcft
 
 detcas
 
 detci
 
 dfep2
 
 dfmp2
 
 dfoccwave
 
 dft_integrators
 
 fcidump
 
 filesystem
 
 fisapt
 
 fnocc
 
 libfock
 
 linalg
 
 mcscf
 
 mrcc
 
 occwave
 
 pk
 
 PointGroups
 
 psimrcc
 
 sapt
 
 scf
 
 scfgrad
 
 SpaceBuilder
 
 SymmOps
 

Classes

class  PluginFileManager
 
class  Cholesky
 
class  CholeskyMatrix
 
class  CholeskyERI
 
class  CholeskyMP2
 
class  CholeskyDelta
 
class  CholeskyLocal
 
class  Denominator
 
class  LaplaceDenominator
 
class  CholeskyDenominator
 
class  SAPTDenominator
 
class  SAPTLaplaceDenominator
 
class  SAPTCholeskyDenominator
 
class  TLaplaceDenominator
 
class  DFHelper
 
class  FittingMetric
 
class  DFTensor
 
class  CubicScalarGrid
 
class  CubeProperties
 
class  DIISEntry
 The DIISManager class is used to manage DIIS quantities and their corresponding error vectors. More...
 
class  DIISManager
 The DIISManager class handles DIIS extrapolations. More...
 
class  Dispersion
 
struct  dpdparams4
 
struct  dpdfile4
 
struct  dpdshift4
 
struct  dpdbuf4
 
struct  dpdtrans4
 
struct  dpdparams2
 
struct  dpdfile2
 
struct  dpd_file4_cache_entry
 
struct  dpd_file2_cache_entry
 
struct  dpd_data
 
struct  thread_data
 
struct  dpd_gbl
 
class  DPD
 
class  DPDMOSpace
 
struct  dpdpair
 
class  RBase
 
class  RCIS
 
class  RTDHF
 
class  RCPHF
 
class  RCPKS
 
class  RTDA
 
class  RTDDFT
 
class  RadialPruneMgr
 
struct  MassPoint
 
class  MolecularGrid
 
class  PseudospectralGrid
 
class  DFTGrid
 
class  RadialGrid
 
class  SphericalGrid
 
class  BlockOPoints
 
class  BasisExtents
 
class  GridBlocker
 
class  NaiveGridBlocker
 
class  OctreeGridBlocker
 
struct  MinimalInterface
 
class  Hamiltonian
 
class  RHamiltonian
 
class  UHamiltonian
 
class  MatrixRHamiltonian
 
class  MatrixUHamiltonian
 
class  CISRHamiltonian
 
class  TDHFRHamiltonian
 
class  CPHFRHamiltonian
 
class  TDARHamiltonian
 
class  TDDFTRHamiltonian
 
class  CPKSRHamiltonian
 
class  USTABHamiltonian
 
class  JK
 
class  DiskJK
 
class  PKJK
 
class  DirectJK
 
class  GTFockJK
 Derived class extending the JK object to GTFock. More...
 
class  DiskDFJK
 
class  CDJK
 
class  MemDFJK
 
class  BasisFunctions
 
class  PointFunctions
 
class  RKSFunctions
 
class  UKSFunctions
 
class  Solver
 
class  RSolver
 
class  USolver
 
class  CGRSolver
 
class  DLRSolver
 
class  RayleighRSolver
 
class  DLRXSolver
 
class  DLUSolver
 
class  SOMCSCF
 
class  DFSOMCSCF
 
class  DiskSOMCSCF
 
class  IncoreSOMCSCF
 
class  VBase
 
class  RV
 
class  UV
 
class  Functional
 
class  LibXCFunctional
 
class  SuperFunctional
 
struct  iwlbuf
 
class  IWL
 
class  ThreeCenterOverlapInt
 Three center overlap integral. More...
 
class  AngularMomentumInt
 
class  BasisSet
 Basis set container class. More...
 
class  BesselFunction
 Computes a modified spherical Bessel function of the first kind. More...
 
class  CartesianIter
 
class  RedundantCartesianIter
 
class  RedundantCartesianSubIter
 
class  CdSalc
 
class  CdSalcWRTAtom
 
class  CdSalcList
 
class  CoordValue
 
class  NumberValue
 
class  VariableValue
 
class  CoordEntry
 
class  CartesianEntry
 
class  ZMatrixEntry
 
class  CorrelationTable
 
class  CorrelatedFunctor
 
class  ScfRestrictedFunctor
 
class  ScfAndDfCorrelationRestrictedFunctor
 
class  ScfUnrestrictedFunctor
 
class  Deriv
 
class  Dimension
 
class  Slice
 Slicing for Matrices and Vectors objects. More...
 
class  DipoleInt
 Computes dipole integrals. More...
 
class  ShellPairData
 Stores the (shifted) angular momenta, number of cartesians in a shell pair, and shifted centers. More...
 
class  AngularIntegral
 Calculates and stores the angular integrals needed for ECP integration. More...
 
class  RadialIntegral
 Abstracts the calculation of radial integrals for ECP integration. More...
 
class  ECPInt
 
class  ECPSOInt
 
class  EFPMultipolePotentialInt
 
class  ElectricFieldInt
 Computes electric field integrals. More...
 
class  ElectrostaticInt
 
class  Element_to_Z
 
struct  ShellPair_typ
 
class  TwoElectronInt
 
class  ERI
 Capable of computing two-electron repulsion integrals. More...
 
class  F12
 
class  F12Scaled
 
class  F12Squared
 
class  F12G12
 
class  F12DoubleCommutator
 
class  ErfERI
 
class  ErfComplementERI
 
class  ExternalPotential
 
class  MatrixFactory
 A class for creating Matrix and Vector objects. More...
 
class  Fjt
 Evaluates the Boys function F_j(T) More...
 
class  Taylor_Fjt
 Uses Taylor interpolation of up to 8-th order to compute the Boys function. More...
 
class  FJT
 
class  GaussianFundamental
 
class  F12Fundamental
 
class  F12ScaledFundamental
 
class  F12SquaredFundamental
 
class  F12G12Fundamental
 
class  F12DoubleCommutatorFundamental
 
class  ErfFundamental
 
class  ErfComplementFundamental
 
class  GCQuadrature
 Performs adaptive Gauss-Chebyshev quadrature for any given function. More...
 
class  GridBlock
 Integration Point/Weight container class (blocks, not individual) More...
 
class  ShellInfo
 This class has the same behavior as GaussianShell, but implements everything using slower data structures, which are easier to construct. These are used to build the basis set, which builds more efficient pointer-based GaussianShell objects. More...
 
class  GaussianShell
 Gaussian orbital shell. More...
 
class  SphericalTransformComponent
 
class  SphericalTransform
 
class  ISphericalTransform
 This describes a solid harmonic to Cartesian transformation. More...
 
class  SphericalTransformIter
 
class  AOIntegralsIterator
 
class  AOShellCombinationsIterator
 
class  SOShellCombinationsIterator
 
class  SO_PQ_Iterator
 
class  SO_RS_Iterator
 
class  IntegralFactory
 
class  IntegralParameters
 
class  CorrelationFactor
 
class  FittedSlaterCorrelationFactor
 
class  KineticInt
 Computes kinetic integrals. More...
 
class  Localizer
 
class  BoysLocalizer
 
class  PMLocalizer
 
class  Matrix
 Makes using matrices just a little easier. More...
 
class  IWLWriter
 
class  MintsHelper
 
class  Molecule
 Molecule information class. More...
 
struct  TwoIndex
 Templated skeleton two index array for convenience. More...
 
struct  ThreeIndex
 Templated skeleton three index array for convenience. More...
 
struct  FiveIndex
 Templated skeleton five index array for convenience. More...
 
struct  SevenIndex
 Templated skeleton seven index array for convenience. More...
 
class  MultipoleInt
 Computes arbitrary-order multipole integrals. More...
 
class  OperatorSymmetry
 
class  MultipoleSymmetry
 
class  NablaInt
 
class  GridIterator
 The GridIterator class: A class to iterate over a user-provided grid for computing electrostatic properties. More...
 
class  Prop
 
class  TaskListComputer
 
class  MultipolePropCalc
 
class  PopulationAnalysisCalc
 
class  ESPPropCalc
 
class  OEProp
 
class  OneBodyAOInt
 
class  OrbitalSpace
 The OrbitalSpace class. More...
 
class  OverlapOrthog
 
class  ObaraSaikaTwoCenterRecursion
 Generic Obara and Saika recursion object. More...
 
class  ObaraSaikaTwoCenterMIRecursion
 Obara and Saika recursion object for moment integrals. Currently not used by DipoleInt, hopefully soon. THIS CLASS HAS NOT BEEN TESTED!!! More...
 
class  ObaraSaikaTwoCenterVIRecursion
 Obara and Saika recursion object for potential integrals. More...
 
class  ObaraSaikaTwoCenterVIDerivRecursion
 Obara and Saika recursion object for computing potential derivatives. More...
 
class  ObaraSaikaTwoCenterVIDeriv2Recursion
 
class  ObaraSaikaTwoCenterElectricField
 Obara and Saika recursion object for computing electric field integrals. More...
 
class  ObaraSaikaTwoCenterElectricFieldGradient
 Obara and Saika recursion object for computing electric field gradient integrals. More...
 
class  ObaraSaikaTwoCenterEFPRecursion
 Obara and Saika recursion object for potential integrals, and electric derivatives thereof, required in EFP. More...
 
class  ObaraSaikaThreeCenterRecursion
 
class  OverlapInt
 This class computes overlap integrals and soon overlap integral derivatives. Use an IntegralFactory to create this object. More...
 
struct  lin_comb
 
struct  contribution
 
struct  SO
 
struct  SO_block
 
struct  SOCoefficients
 
class  PetiteList
 
class  SymmetryOperation
 
class  SymRep
 
class  IrreducibleRepresentation
 
class  CharacterTable
 
class  PointGroup
 
class  PotentialInt
 Computes potential integrals. Use an IntegralFactory to create this object. More...
 
class  PotentialSOInt
 
class  PCMPotentialInt
 
class  PrintIntegralsFunctor
 
class  ContractOverDensityFunctor
 
class  ContractOverChargesFunctor
 
class  PseudospectralInt
 
class  QuadrupoleInt
 Computes quadrupole integrals. At last check this may not be working. Use an IntegralFactory to create this object. More...
 
class  RelPotentialInt
 Computes relativistic potential integrals. Use an IntegralFactory to create this object. More...
 
class  RelPotentialSOInt
 
class  ShellRotation
 
class  ERISieve
 
class  SimintTwoElectronInt
 
class  SimintERI
 
class  SOTransformFunction
 
class  AOTransformFunction
 
class  SOTransformShell
 
class  SOTransform
 
class  AOTransform
 
class  SOBasisSet
 
class  OneBodySOInt
 
class  TwoBodySOInt
 
class  TracelessQuadrupoleInt
 Computes quadrupole integrals. At last check this may not be working. Use an IntegralFactory to create this object. More...
 
class  TwoBodyAOInt
 
class  Vector
 
class  IntVector
 
class  Vector3
 
class  Wavefunction
 Simple wavefunction base class. More...
 
class  FCHKWriter
 
class  MoldenWriter
 
class  MOWriter
 
class  NBOWriter
 
class  X2CInt
 Computes the 1e-X2C kinetic and potential integrals. More...
 
class  ModelSpace
 
class  MOInfo
 
class  MOInfoBase
 
class  MOInfoSCF
 
class  SlaterDeterminant
 
class  DataTypeException
 
class  IndexException
 
class  DuplicateKeyException
 
class  OptionsException
 
class  DataType
 
class  BooleanDataType
 
class  IntDataType
 
class  DoubleDataType
 
class  StringDataType
 
class  IStringDataType
 
class  Data
 
class  ArrayType
 
class  MapType
 
class  Options
 
struct  plugin_info_struct
 
class  PsiException
 
class  NotImplementedException_
 
class  SanityCheckError
 
class  SystemError
 
class  FeatureNotImplemented
 
class  LimitExceeded
 
class  StepSizeError
 
class  MaxIterationsExceeded
 
class  ConvergenceError
 
class  ResourceAllocationError
 
class  InputException
 
class  Timer
 
struct  AllocationEntry
 
class  MemoryManager
 
class  Process
 
class  PsiOutStream
 
class  AIOHandler
 
struct  psio_address
 
struct  psio_vol
 
struct  psio_entry
 
struct  psio_ud
 
class  PSIOManager
 
class  PSIO
 
struct  String
 
struct  StringSet
 
struct  SlaterDet
 
struct  _SlaterDetSet
 
struct  SlaterDetVector
 
class  Timer_thread
 
class  Timer_Structure
 
class  IntegralTransform
 
class  FrozenCoreAndFockRestrictedFunctor
 
class  FrozenCoreAndFockUnrestrictedFunctor
 
class  DPDFillerFunctor
 
class  NullFunctor
 
class  MOSpace
 
class  PythonDataType
 

Typedefs

using SharedMatrix = std::shared_ptr< Matrix >
 
using SharedVector = std::shared_ptr< Vector >
 
typedef _SlaterDetSet SlaterDetSet
 
typedef short int Label
 
typedef double Value
 
typedef struct psi::ShellPair_typ ShellPair
 
typedef std::shared_ptr
< GridBlock
SharedGridBlock
 
typedef PopulationAnalysisCalc PAC
 
typedef std::shared_ptr
< OneBodyAOInt
SharedOneBodyAOInt
 
typedef std::shared_ptr
< OneBodySOInt
SharedOneBodySOInt
 
typedef std::shared_ptr
< TwoBodySOInt
SharedTwoBodySOInt
 
typedef std::vector< std::pair
< int, int > > 
ShellPairBlock
 
typedef std::shared_ptr
< TwoBodyAOInt
SharedTwoBodyAOInt
 
using SharedIntVector = std::shared_ptr< IntVector >
 
using SharedWavefunction = std::shared_ptr< Wavefunction >
 
using SharedMolecule = std::shared_ptr< Molecule >
 
typedef SharedWavefunction(* plugin_t )(SharedWavefunction, Options &)
 
typedef int(* read_options_t )(std::string, Options &)
 
typedef struct
psi::plugin_info_struct 
plugin_info
 
typedef std::vector< std::string > strvec
 
typedef struct psi::psio_entry psio_tocentry
 
using clock = std::chrono::high_resolution_clock
 
typedef std::vector
< std::shared_ptr< MOSpace > > 
SpaceVec
 

Enumerations

enum  indices {
  pqrs, pqsr, prqs, prsq,
  psqr, psrq, qprs, qpsr,
  qrps, qrsp, qspr, qsrp,
  rqps, rqsp, rpqs, rpsq,
  rsqp, rspq, sqrp, sqpr,
  srqp, srpq, spqr, sprq
}
 
enum  pattern {
  abc, acb, cab, cba,
  bca, bac
}
 
enum  GCTYPE { ONEPOINT, TWOPOINT }
 
enum  PrimitiveType { Normalized, Unnormalized }
 
enum  GaussianType { Cartesian = 0, Pure = 1 }
 
enum  ShellType { Gaussian = 0, ECPType1 = 1, ECPType2 = 2 }
 
enum  diagonalize_order { evals_only_ascending = 0, ascending = 1, evals_only_descending = 2, descending = 3 }
 
enum  AxisName { XAxis, YAxis, ZAxis }
 
enum  RotorType {
  RT_ASYMMETRIC_TOP, RT_SYMMETRIC_TOP, RT_SPHERICAL_TOP, RT_LINEAR,
  RT_ATOM
}
 
enum  FullPointGroup {
  PG_ATOM, PG_Cinfv, PG_Dinfh, PG_C1,
  PG_Cs, PG_Ci, PG_Cn, PG_Cnv,
  PG_Cnh, PG_Sn, PG_Dn, PG_Dnd,
  PG_Dnh, PG_Td, PG_Oh, PG_Ih
}
 
enum  PermutedOrder {
  ABCD = 0, BACD = 1, ABDC = 2, BADC = 3,
  CDAB = 4, CDBA = 5, DCAB = 6, DCBA = 7
}
 
enum  ReferenceType { AllRefs, UniqueRefs, ClosedShellRefs, UniqueOpenShellRefs }
 
enum  Timer_Status { OFF, ON, PARALLEL }
 
enum  PsiReturnType { Success, Failure, Balk, EndLoop }
 

Functions

int read_options (const std::string &name, Options &options, bool suppress_printing=false)
 
void create_new_plugin (std::string name, const std::string &template_name)
 
void create_new_plugin_makefile ()
 
template<class T >
bool from_string (T &t, const std::string &s, std::ios_base &(*f)(std::ios_base &))
 
PSI_API double ** block_matrix (size_t n, size_t m, bool memlock)
 
void PSI_API free_block (double **array)
 
void eigout (double **a, double *b, double *c, int m, int n, std::string out)
 
void PSI_API eigsort (double *d, double **v, int n)
 
void mosort (double *d, double **v, int *sym, int nso, int nmo)
 
void eivout (double **a, const double *b, int m, int n, std::string out)
 
void ludcmp (double **, int, int *, double *)
 
void lubksb (double **, int, int *, double *)
 
void flin (double **a, double *b, int in, int im, double *det)
 
double * init_array (size_t size)
 
double ** init_matrix (size_t n, size_t m)
 
void free_matrix (double **array, size_t)
 
PSI_API int * init_int_array (int size)
 
void zero_int_array (int *a, int size)
 
PSI_API int ** init_int_matrix (int rows, int cols)
 
void PSI_API free_int_matrix (int **array)
 
void zero_int_matrix (int **array, int rows, int cols)
 
void print_int_mat (int **a, int m, int n, std::string out)
 
PSI_API int psi_start (FILE **infile, FILE **outfile, char **psi_file_prefix, int argc, char *argv[], int overwrite_output)
 
PSI_API int psi_stop (FILE *infile, FILE *outfile, char *psi_file_prefix)
 
PSI_API char * psi_ifname ()
 
PSI_API char * psi_ofname ()
 
PSI_API char * psi_fprefix ()
 
PSI_API void balance (double **a, int n)
 
PSI_API void mat_to_arr (double **a, double *b, int m, int n)
 
PSI_API void arr_to_mat (double **a, double *b, int m, int n)
 
PSI_API void print_array (double *a, int m, std::string out)
 
PSI_API void print_mat (double **a, int rows, int cols, std::string out)
 
PSI_API void rsp (int nm, int n, int nv, double *array, double *evals, int matz, double **evecs, double toler)
 
PSI_API void sq_rsp (int nm, int n, double **array, double *evals, int matz, double **evecs, double toler)
 
PSI_API void sq_to_tri (double **bmat, double *amat, int size)
 
PSI_API void tri_to_block (double *a, double **b, int num_ir, int *num_so, int *ioff)
 
PSI_API void block_to_tri (double *a, double **b, int num_ir, int *num_so, int *ioff)
 
PSI_API void tri_to_sq (double *amat, double **bmat, int size)
 
void tstart ()
 
void tstop ()
 
PSI_API void zero_arr (double *a, int size)
 
PSI_API void zero_mat (double **a, int rows, int cols)
 
PSI_API long int * init_long_int_array (int size)
 
PSI_API void zero_long_int_array (long int *a, int size)
 
PSI_API long int ** init_long_int_matrix (int rows, int cols)
 
PSI_API void free_long_int_matrix (long int **array)
 
PSI_API void zero_long_int_matrix (long int **array, int rows, int cols)
 
PSI_API void print_long_int_mat (long int **a, int m, int n, std::string out)
 
PSI_API void fndcor (long int *maxcrb, std::string out_fname)
 
void tred2 (int n, double **a, double *d, double *e, int matz)
 
void tqli (int n, double *d, double **z, double *e, int matz, double toler)
 
void cc3_sigma_RHF_ic_thread (thread_data &)
 
PSI_API int dpd_set_default (int dpd_num)
 
int dpd_init (int dpd_num, int nirreps, long int memory, int cachetype, int *cachefiles, int **cachelist, dpd_file4_cache_entry *priority, int num_subspaces, std::vector< int * > &spaceArrays)
 
int dpd_close (int dpd_num)
 
long int PSI_API dpd_memfree ()
 
void dpd_memset (long int memory)
 
bool operator== (const string &c, const DPDMOSpace &rhs)
 
bool operator== (const char *c, const DPDMOSpace &rhs)
 
std::vector< std::string > dpd_split (const std::string &indices)
 
dpd_file4_cache_entrydpd_file4_cache_find_low ()
 
static std::string & dpd_ltrim (std::string &s)
 
static std::string & dpd_rtrim (std::string &s)
 
static std::string & dpd_trim (std::string &s)
 
template<class T >
void _set_dfjk_options (T *jk, Options &options)
 
void set_do_wK (bool do_wK)
 
void PSI_API iwl_buf_close (struct iwlbuf *Buf, int keep)
 
void PSI_API iwl_buf_fetch (struct iwlbuf *Buf)
 
void iwl_buf_flush (struct iwlbuf *Buf, int lastbuf)
 
void PSI_API iwl_buf_init (struct iwlbuf *Buf, int itape, double cutoff, int oldfile, int readflag)
 
void iwl_buf_put (struct iwlbuf *Buf)
 
void iwl_buf_wrt_val (struct iwlbuf *Buf, int p, int q, int r, int s, double value, int printflag, std::string out, int dirac)
 
int iwl_rdone (int itap, const char *label, double *ints, int ntri, int erase, int printflg, std::string out)
 
void benchmark_blas1 (int N, double min_time)
 
void benchmark_blas2 (int N, double min_time)
 
void benchmark_blas3 (int N, double min_time, int max_threads)
 
void benchmark_disk (int N, double min_time)
 
void benchmark_math (double min_time)
 
void benchmark_integrals (int max_am, double min_time)
 
PSI_API bool operator== (const Dimension &a, const Dimension &b)
 
PSI_API bool operator!= (const Dimension &a, const Dimension &b)
 
PSI_API Dimension operator+ (const Dimension &a, const Dimension &b)
 
PSI_API Dimension operator- (const Dimension &a, const Dimension &b)
 
static TwoIndex< double > realSphericalHarmonics (int lmax, double x, double phi)
 
static TwoIndex< double > realSphericalHarmonics (int lmax, double x, double phi)
 
std::string PSI_API get_writer_file_prefix (const std::string &molecule_name)
 
int str_to_int (const std::string &s)
 
double str_to_double (const std::string &s)
 
void set_block (Slice rows, Slice cols, SharedMatrix block)
 
std::regex realNumber_ ("(?:[-+]?\\d*\\.\\d+(?:[DdEe][-+]?\\d+)?)|(?:[-+]?\\d+\\.\\d*(?:[DdEe][-+]?\\d+)?)|(?:[-+]?\\d+(?:[DdEe][-+]?\\d+)?"")", std::regex_constants::icase)
 
std::regex integerNumber_ ("(-?\\d+)", std::regex_constants::icase)
 
void if_to_invert_axis (const Vector3 &v1, int &must_invert, int &should_invert, double &maxproj)
 
static AxisName like_world_axis (Vector3 &axis, const Vector3 &worldxaxis, const Vector3 &worldyaxis, const Vector3 &worldzaxis)
 
int matrix_3d_rotation_Cn (Matrix &coord, Vector3 axis, bool reflect, double TOL, int max_Cn_to_check=-1)
 
bool atom_present_in_geom (Matrix &geom, Vector3 &b, double tol)
 
int ** compute_shell_map (int **atom_map, const std::shared_ptr< BasisSet > &basis)
 
void delete_shell_map (int **shell_map, const std::shared_ptr< BasisSet > &basis)
 
int64_t ij_offset64 (int64_t i, int64_t j)
 
int64_t i_offset64 (int64_t i)
 
void PSI_DGBMV (int irrep, char trans, int m, int n, int kl, int ku, double alpha, SharedMatrix a, int lda, std::shared_ptr< Vector > x, int incx, double beta, std::shared_ptr< Vector > y, int incy)
 PSI_DGBMV, a wrapper to C_DGBMV using objects. More...
 
void PSI_DGEMM (int irrep, char transa, char transb, int m, int n, int k, double alpha, SharedMatrix a, int lda, SharedMatrix b, int ldb, double beta, SharedMatrix c, int ldc)
 PSI_DGEMM, a wrapper to C_DGEMM using objects. More...
 
void PSI_DGEMV (int irrep, char trans, int m, int n, double alpha, SharedMatrix a, int lda, std::shared_ptr< Vector > x, int incx, double beta, std::shared_ptr< Vector > y, int incy)
 PSI_DGEMV, a wrapper to C_DGEMV using objects. More...
 
void PSI_DGER (int irrep, int m, int n, double alpha, std::shared_ptr< Vector > x, int incx, std::shared_ptr< Vector > y, int incy, SharedMatrix a, int lda)
 PSI_DGER, a wrapper to C_DGER using objects. More...
 
void PSI_DSBMV (int irrep, char uplo, int n, int k, double alpha, SharedMatrix a, int lda, std::shared_ptr< Vector > x, int incx, double beta, std::shared_ptr< Vector > y, int incy)
 PSI_DSBMV, a wrapper to C_DSBMV using objects. More...
 
void PSI_DSYMM (int irrep, char side, char uplo, int m, int n, double alpha, SharedMatrix a, int lda, SharedMatrix b, int ldb, double beta, SharedMatrix c, int ldc)
 PSI_DSYMM, a wrapper to C_DSYMM using objects. More...
 
void PSI_DSYMV (int irrep, char uplo, int n, double alpha, SharedMatrix a, int lda, std::shared_ptr< Vector > x, int incx, double beta, std::shared_ptr< Vector > y, int incy)
 PSI_DSYMV, a wrapper to C_DSYMV using objects. More...
 
void PSI_DSYR (int irrep, char uplo, int n, double alpha, std::shared_ptr< Vector > x, int incx, SharedMatrix a, int lda)
 PSI_DSYR, a wrapper to C_DSYR using objects. More...
 
void PSI_DSYR2 (int irrep, char uplo, int n, double alpha, std::shared_ptr< Vector > x, int incx, std::shared_ptr< Vector > y, int incy, SharedMatrix a, int lda)
 PSI_DSYR2, a wrapper to C_DSYR2 using objects. More...
 
void PSI_DSYR2K (int irrep, char uplo, char trans, int n, int k, double alpha, SharedMatrix a, int lda, SharedMatrix b, int ldb, double beta, SharedMatrix c, int ldc)
 PSI_DSYR2K, a wrapper to C_DSYR2K using objects. More...
 
void PSI_DSYRK (int irrep, char uplo, char trans, int n, int k, double alpha, SharedMatrix a, int lda, double beta, SharedMatrix c, int ldc)
 PSI_DSYRK, a wrapper to C_DSYRK using objects. More...
 
void PSI_DTBMV (int irrep, char uplo, char trans, char diag, int n, int k, SharedMatrix a, int lda, std::shared_ptr< Vector > x, int incx)
 PSI_DTBMV, a wrapper to C_DTBMV using objects. More...
 
void PSI_DTBSV (int irrep, char uplo, char trans, char diag, int n, int k, SharedMatrix a, int lda, std::shared_ptr< Vector > x, int incx)
 PSI_DTBSV, a wrapper to C_DTBSV using objects. More...
 
void PSI_DTRMM (int irrep, char side, char uplo, char transa, char diag, int m, int n, double alpha, SharedMatrix a, int lda, SharedMatrix b, int ldb)
 PSI_DTRMM, a wrapper to C_DTRMM using objects. More...
 
void PSI_DTRMV (int irrep, char uplo, char trans, char diag, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > x, int incx)
 PSI_DTRMV, a wrapper to C_DTRMV using objects. More...
 
void PSI_DTRSM (int irrep, char side, char uplo, char transa, char diag, int m, int n, double alpha, SharedMatrix a, int lda, SharedMatrix b, int ldb)
 PSI_DTRSM, a wrapper to C_DTRSM using objects. More...
 
void PSI_DTRSV (int irrep, char uplo, char trans, char diag, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > x, int incx)
 PSI_DTRSV, a wrapper to C_DTRSV using objects. More...
 
void PSI_DROT (int irrep, size_t n, std::shared_ptr< Vector > x, int incx, std::shared_ptr< Vector > y, int incy, double c, double s)
 PSI_DROT, a wrapper to C_DROT using objects. More...
 
void PSI_DSWAP (int irrep, size_t n, std::shared_ptr< Vector > x, int incx, std::shared_ptr< Vector > y, int incy)
 PSI_DSWAP, a wrapper to C_DSWAP using objects. More...
 
void PSI_DCOPY (int irrep, size_t n, std::shared_ptr< Vector > x, int incx, std::shared_ptr< Vector > y, int incy)
 PSI_DCOPY, a wrapper to C_DCOPY using objects. More...
 
void PSI_DSCAL (int irrep, size_t n, double alpha, std::shared_ptr< Vector > x, int incx)
 PSI_DSCAL, a wrapper to C_DSCAL using objects. More...
 
void PSI_DAXPY (int irrep, size_t n, double alpha, std::shared_ptr< Vector > x, int incx, std::shared_ptr< Vector > y, int incy)
 PSI_DAXPY, a wrapper to C_DAXPY using objects. More...
 
double PSI_DDOT (int irrep, size_t n, std::shared_ptr< Vector > x, int incx, std::shared_ptr< Vector > y, int incy)
 PSI_DDOT, a wrapper to C_DDOT using objects. More...
 
double PSI_DNRM2 (int irrep, size_t n, std::shared_ptr< Vector > x, int incx)
 PSI_DNRM2, a wrapper to C_DNRM2 using objects. More...
 
double PSI_DASUM (int irrep, size_t n, std::shared_ptr< Vector > x, int incx)
 PSI_DASUM, a wrapper to C_DASUM using objects. More...
 
size_t PSI_IDAMAX (int irrep, size_t n, std::shared_ptr< Vector > x, int incx)
 PSI_IDAMAX, a wrapper to C_IDAMAX using objects. More...
 
int PSI_DBDSDC (int irrep, char uplo, char compq, int n, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, SharedMatrix u, int ldu, SharedMatrix vt, int ldvt, std::shared_ptr< Vector > q, std::shared_ptr< IntVector > iq, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 
int PSI_DBDSQR (int irrep, char uplo, int n, int ncvt, int nru, int ncc, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, SharedMatrix vt, int ldvt, SharedMatrix u, int ldu, SharedMatrix c, int ldc, std::shared_ptr< Vector > work)
 PSI_DBDSQR, a wrapper to return C_DBDSQR using objects. More...
 
int PSI_DDISNA (int irrep, char job, int m, int n, std::shared_ptr< Vector > d, std::shared_ptr< Vector > sep)
 PSI_DDISNA, a wrapper to return C_DDISNA using objects. More...
 
int PSI_DGBBRD (int irrep, char vect, int m, int n, int ncc, int kl, int ku, SharedMatrix ab, int ldab, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, SharedMatrix q, int ldq, SharedMatrix pt, int ldpt, SharedMatrix c, int ldc, std::shared_ptr< Vector > work)
 PSI_DGBBRD, a wrapper to return C_DGBBRD using objects. More...
 
int PSI_DGBCON (int irrep, char norm, int n, int kl, int ku, SharedMatrix ab, int ldab, std::shared_ptr< IntVector > ipiv, double anorm, std::shared_ptr< Vector > rcond, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DGBCON, a wrapper to return C_DGBCON using objects. More...
 
int PSI_DGBEQU (int irrep, int m, int n, int kl, int ku, SharedMatrix ab, int ldab, std::shared_ptr< Vector > r, std::shared_ptr< Vector > c, std::shared_ptr< Vector > rowcnd, std::shared_ptr< Vector > colcnd, std::shared_ptr< Vector > amax)
 PSI_DGBEQU, a wrapper to return C_DGBEQU using objects. More...
 
int PSI_DGBRFS (int irrep, char trans, int n, int kl, int ku, int nrhs, SharedMatrix ab, int ldab, SharedMatrix afb, int ldafb, std::shared_ptr< IntVector > ipiv, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > ferr, std::shared_ptr< Vector > berr, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DGBRFS, a wrapper to return C_DGBRFS using objects. More...
 
int PSI_DGBSV (int irrep, int n, int kl, int ku, int nrhs, SharedMatrix ab, int ldab, std::shared_ptr< IntVector > ipiv, SharedMatrix b, int ldb)
 PSI_DGBSV, a wrapper to return C_DGBSV using objects. More...
 
int PSI_DGBSVX (int irrep, char fact, char trans, int n, int kl, int ku, int nrhs, SharedMatrix ab, int ldab, SharedMatrix afb, int ldafb, std::shared_ptr< IntVector > ipiv, char equed, std::shared_ptr< Vector > r, std::shared_ptr< Vector > c, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > rcond, std::shared_ptr< Vector > ferr, std::shared_ptr< Vector > berr, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DGBSVX, a wrapper to return C_DGBSVX using objects. More...
 
int PSI_DGBTRF (int irrep, int m, int n, int kl, int ku, SharedMatrix ab, int ldab, std::shared_ptr< IntVector > ipiv)
 PSI_DGBTRF, a wrapper to return C_DGBTRF using objects. More...
 
int PSI_DGBTRS (int irrep, char trans, int n, int kl, int ku, int nrhs, SharedMatrix ab, int ldab, std::shared_ptr< IntVector > ipiv, SharedMatrix b, int ldb)
 PSI_DGBTRS, a wrapper to return C_DGBTRS using objects. More...
 
int PSI_DGEBAK (int irrep, char job, char side, int n, int ilo, int ihi, std::shared_ptr< Vector > scale, int m, SharedMatrix v, int ldv)
 PSI_DGEBAK, a wrapper to return C_DGEBAK using objects. More...
 
int PSI_DGEBAL (int irrep, char job, int n, SharedMatrix a, int lda, std::shared_ptr< IntVector > ilo, std::shared_ptr< IntVector > ihi, std::shared_ptr< Vector > scale)
 PSI_DGEBAL, a wrapper to return C_DGEBAL using objects. More...
 
int PSI_DGEBRD (int irrep, int m, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, std::shared_ptr< Vector > tauq, std::shared_ptr< Vector > taup, std::shared_ptr< Vector > work, int lwork)
 PSI_DGEBRD, a wrapper to return C_DGEBRD using objects. More...
 
int PSI_DGECON (int irrep, char norm, int n, SharedMatrix a, int lda, double anorm, std::shared_ptr< Vector > rcond, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DGECON, a wrapper to return C_DGECON using objects. More...
 
int PSI_DGEEQU (int irrep, int m, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > r, std::shared_ptr< Vector > c, std::shared_ptr< Vector > rowcnd, std::shared_ptr< Vector > colcnd, std::shared_ptr< Vector > amax)
 PSI_DGEEQU, a wrapper to return C_DGEEQU using objects. More...
 
int PSI_DGEES (int irrep, char jobvs, char sort, int n, SharedMatrix a, int lda, std::shared_ptr< IntVector > sdim, std::shared_ptr< Vector > wr, std::shared_ptr< Vector > wi, SharedMatrix vs, int ldvs, std::shared_ptr< Vector > work, int lwork)
 PSI_DGEES, a wrapper to return C_DGEES using objects. More...
 
int PSI_DGEESX (int irrep, char jobvs, char sort, char sense, int n, SharedMatrix a, int lda, std::shared_ptr< IntVector > sdim, std::shared_ptr< Vector > wr, std::shared_ptr< Vector > wi, SharedMatrix vs, int ldvs, std::shared_ptr< Vector > rconde, std::shared_ptr< Vector > rcondv, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, int liwork)
 PSI_DGEESX, a wrapper to return C_DGEESX using objects. More...
 
int PSI_DGEEV (int irrep, char jobvl, char jobvr, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > wr, std::shared_ptr< Vector > wi, SharedMatrix vl, int ldvl, SharedMatrix vr, int ldvr, std::shared_ptr< Vector > work, int lwork)
 PSI_DGEEV, a wrapper to return C_DGEEV using objects. More...
 
int PSI_DGEEVX (int irrep, char balanc, char jobvl, char jobvr, char sense, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > wr, std::shared_ptr< Vector > wi, SharedMatrix vl, int ldvl, SharedMatrix vr, int ldvr, std::shared_ptr< IntVector > ilo, std::shared_ptr< IntVector > ihi, std::shared_ptr< Vector > scale, std::shared_ptr< Vector > abnrm, std::shared_ptr< Vector > rconde, std::shared_ptr< Vector > rcondv, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork)
 PSI_DGEEVX, a wrapper to return C_DGEEVX using objects. More...
 
int PSI_DGEGS (int irrep, char jobvsl, char jobvsr, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< Vector > alphar, std::shared_ptr< Vector > alphai, std::shared_ptr< Vector > beta, SharedMatrix vsl, int ldvsl, SharedMatrix vsr, int ldvsr, std::shared_ptr< Vector > work, int lwork)
 PSI_DGEGS, a wrapper to return C_DGEGS using objects. More...
 
int PSI_DGEGV (int irrep, char jobvl, char jobvr, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< Vector > alphar, std::shared_ptr< Vector > alphai, std::shared_ptr< Vector > beta, SharedMatrix vl, int ldvl, SharedMatrix vr, int ldvr, std::shared_ptr< Vector > work, int lwork)
 PSI_DGEGV, a wrapper to return C_DGEGV using objects. More...
 
int PSI_DGEHRD (int irrep, int n, int ilo, int ihi, SharedMatrix a, int lda, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work, int lwork)
 PSI_DGEHRD, a wrapper to return C_DGEHRD using objects. More...
 
int PSI_DGELQF (int irrep, int m, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work, int lwork)
 PSI_DGELQF, a wrapper to return C_DGELQF using objects. More...
 
int PSI_DGELS (int irrep, char trans, int m, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< Vector > work, int lwork)
 PSI_DGELS, a wrapper to return C_DGELS using objects. More...
 
int PSI_DGELSD (int irrep, int m, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< Vector > s, double rcond, std::shared_ptr< IntVector > rank, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork)
 PSI_DGELSD, a wrapper to return C_DGELSD using objects. More...
 
int PSI_DGELSS (int irrep, int m, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< Vector > s, double rcond, std::shared_ptr< IntVector > rank, std::shared_ptr< Vector > work, int lwork)
 PSI_DGELSS, a wrapper to return C_DGELSS using objects. More...
 
int PSI_DGELSX (int irrep, int m, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< IntVector > jpvt, double rcond, std::shared_ptr< IntVector > rank, std::shared_ptr< Vector > work)
 PSI_DGELSX, a wrapper to return C_DGELSX using objects. More...
 
int PSI_DGELSY (int irrep, int m, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< IntVector > jpvt, double rcond, std::shared_ptr< IntVector > rank, std::shared_ptr< Vector > work, int lwork)
 PSI_DGELSY, a wrapper to return C_DGELSY using objects. More...
 
int PSI_DGEQLF (int irrep, int m, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work, int lwork)
 PSI_DGEQLF, a wrapper to return C_DGEQLF using objects. More...
 
int PSI_DGEQP3 (int irrep, int m, int n, SharedMatrix a, int lda, std::shared_ptr< IntVector > jpvt, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work, int lwork)
 PSI_DGEQP3, a wrapper to return C_DGEQP3 using objects. More...
 
int PSI_DGEQPF (int irrep, int m, int n, SharedMatrix a, int lda, std::shared_ptr< IntVector > jpvt, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work)
 PSI_DGEQPF, a wrapper to return C_DGEQPF using objects. More...
 
int PSI_DGERFS (int irrep, char trans, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix af, int ldaf, std::shared_ptr< IntVector > ipiv, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > ferr, std::shared_ptr< Vector > berr, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DGERFS, a wrapper to return C_DGERFS using objects. More...
 
int PSI_DGERQF (int irrep, int m, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work, int lwork)
 PSI_DGERQF, a wrapper to return C_DGERQF using objects. More...
 
int PSI_DGESDD (int irrep, char jobz, int m, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > s, SharedMatrix u, int ldu, SharedMatrix vt, int ldvt, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork)
 PSI_DGESDD, a wrapper to return C_DGESDD using objects. More...
 
int PSI_DGESV (int irrep, int n, int nrhs, SharedMatrix a, int lda, std::shared_ptr< IntVector > ipiv, SharedMatrix b, int ldb)
 PSI_DGESV, a wrapper to return C_DGESV using objects. More...
 
int PSI_DGESVX (int irrep, char fact, char trans, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix af, int ldaf, std::shared_ptr< IntVector > ipiv, char equed, std::shared_ptr< Vector > r, std::shared_ptr< Vector > c, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > rcond, std::shared_ptr< Vector > ferr, std::shared_ptr< Vector > berr, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DGESVX, a wrapper to return C_DGESVX using objects. More...
 
int PSI_DGETRF (int irrep, int m, int n, SharedMatrix a, int lda, std::shared_ptr< IntVector > ipiv)
 PSI_DGETRF, a wrapper to return C_DGETRF using objects. More...
 
int PSI_DGETRI (int irrep, int n, SharedMatrix a, int lda, std::shared_ptr< IntVector > ipiv, std::shared_ptr< Vector > work, int lwork)
 PSI_DGETRI, a wrapper to return C_DGETRI using objects. More...
 
int PSI_DGETRS (int irrep, char trans, int n, int nrhs, SharedMatrix a, int lda, std::shared_ptr< IntVector > ipiv, SharedMatrix b, int ldb)
 PSI_DGETRS, a wrapper to return C_DGETRS using objects. More...
 
int PSI_DGGBAK (int irrep, char job, char side, int n, int ilo, int ihi, std::shared_ptr< Vector > lscale, std::shared_ptr< Vector > rscale, int m, SharedMatrix v, int ldv)
 PSI_DGGBAK, a wrapper to return C_DGGBAK using objects. More...
 
int PSI_DGGBAL (int irrep, char job, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< IntVector > ilo, std::shared_ptr< IntVector > ihi, std::shared_ptr< Vector > lscale, std::shared_ptr< Vector > rscale, std::shared_ptr< Vector > work)
 PSI_DGGBAL, a wrapper to return C_DGGBAL using objects. More...
 
int PSI_DGGES (int irrep, char jobvsl, char jobvsr, char sort, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< IntVector > sdim, std::shared_ptr< Vector > alphar, std::shared_ptr< Vector > alphai, std::shared_ptr< Vector > beta, SharedMatrix vsl, int ldvsl, SharedMatrix vsr, int ldvsr, std::shared_ptr< Vector > work, int lwork)
 PSI_DGGES, a wrapper to return C_DGGES using objects. More...
 
int PSI_DGGESX (int irrep, char jobvsl, char jobvsr, char sort, char sense, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< IntVector > sdim, std::shared_ptr< Vector > alphar, std::shared_ptr< Vector > alphai, std::shared_ptr< Vector > beta, SharedMatrix vsl, int ldvsl, SharedMatrix vsr, int ldvsr, std::shared_ptr< Vector > rconde, std::shared_ptr< Vector > rcondv, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, int liwork)
 PSI_DGGESX, a wrapper to return C_DGGESX using objects. More...
 
int PSI_DGGEV (int irrep, char jobvl, char jobvr, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< Vector > alphar, std::shared_ptr< Vector > alphai, std::shared_ptr< Vector > beta, SharedMatrix vl, int ldvl, SharedMatrix vr, int ldvr, std::shared_ptr< Vector > work, int lwork)
 PSI_DGGEV, a wrapper to return C_DGGEV using objects. More...
 
int PSI_DGGEVX (int irrep, char balanc, char jobvl, char jobvr, char sense, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< Vector > alphar, std::shared_ptr< Vector > alphai, std::shared_ptr< Vector > beta, SharedMatrix vl, int ldvl, SharedMatrix vr, int ldvr, std::shared_ptr< IntVector > ilo, std::shared_ptr< IntVector > ihi, std::shared_ptr< Vector > lscale, std::shared_ptr< Vector > rscale, std::shared_ptr< Vector > abnrm, std::shared_ptr< Vector > bbnrm, std::shared_ptr< Vector > rconde, std::shared_ptr< Vector > rcondv, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork)
 PSI_DGGEVX, a wrapper to return C_DGGEVX using objects. More...
 
int PSI_DGGGLM (int irrep, int n, int m, int p, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< Vector > d, std::shared_ptr< Vector > x, std::shared_ptr< Vector > y, std::shared_ptr< Vector > work, int lwork)
 PSI_DGGGLM, a wrapper to return C_DGGGLM using objects. More...
 
int PSI_DGGHRD (int irrep, char compq, char compz, int n, int ilo, int ihi, SharedMatrix a, int lda, SharedMatrix b, int ldb, SharedMatrix q, int ldq, SharedMatrix z, int ldz)
 PSI_DGGHRD, a wrapper to return C_DGGHRD using objects. More...
 
int PSI_DGGLSE (int irrep, int m, int n, int p, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< Vector > c, std::shared_ptr< Vector > d, std::shared_ptr< Vector > x, std::shared_ptr< Vector > work, int lwork)
 PSI_DGGLSE, a wrapper to return C_DGGLSE using objects. More...
 
int PSI_DGGQRF (int irrep, int n, int m, int p, SharedMatrix a, int lda, std::shared_ptr< Vector > taua, SharedMatrix b, int ldb, std::shared_ptr< Vector > taub, std::shared_ptr< Vector > work, int lwork)
 PSI_DGGQRF, a wrapper to return C_DGGQRF using objects. More...
 
int PSI_DGGRQF (int irrep, int m, int p, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > taua, SharedMatrix b, int ldb, std::shared_ptr< Vector > taub, std::shared_ptr< Vector > work, int lwork)
 PSI_DGGRQF, a wrapper to return C_DGGRQF using objects. More...
 
int PSI_DGGSVD (int irrep, char jobu, char jobv, char jobq, int m, int n, int p, std::shared_ptr< IntVector > k, std::shared_ptr< IntVector > l, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< Vector > alpha, std::shared_ptr< Vector > beta, SharedMatrix u, int ldu, SharedMatrix v, int ldv, SharedMatrix q, int ldq, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DGGSVD, a wrapper to return C_DGGSVD using objects. More...
 
int PSI_DGGSVP (int irrep, char jobu, char jobv, char jobq, int m, int p, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, double tola, double tolb, std::shared_ptr< IntVector > k, std::shared_ptr< IntVector > l, SharedMatrix u, int ldu, SharedMatrix v, int ldv, SharedMatrix q, int ldq, std::shared_ptr< IntVector > iwork, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work)
 PSI_DGGSVP, a wrapper to return C_DGGSVP using objects. More...
 
int PSI_DGTCON (int irrep, char norm, int n, std::shared_ptr< Vector > dl, std::shared_ptr< Vector > d, std::shared_ptr< Vector > du, std::shared_ptr< Vector > du2, std::shared_ptr< IntVector > ipiv, double anorm, std::shared_ptr< Vector > rcond, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DGTCON, a wrapper to return C_DGTCON using objects. More...
 
int PSI_DGTRFS (int irrep, char trans, int n, int nrhs, std::shared_ptr< Vector > dl, std::shared_ptr< Vector > d, std::shared_ptr< Vector > du, std::shared_ptr< Vector > dlf, std::shared_ptr< Vector > df, std::shared_ptr< Vector > duf, std::shared_ptr< Vector > du2, std::shared_ptr< IntVector > ipiv, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > ferr, std::shared_ptr< Vector > berr, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DGTRFS, a wrapper to return C_DGTRFS using objects. More...
 
int PSI_DGTSV (int irrep, int n, int nrhs, std::shared_ptr< Vector > dl, std::shared_ptr< Vector > d, std::shared_ptr< Vector > du, SharedMatrix b, int ldb)
 PSI_DGTSV, a wrapper to return C_DGTSV using objects. More...
 
int PSI_DGTSVX (int irrep, char fact, char trans, int n, int nrhs, std::shared_ptr< Vector > dl, std::shared_ptr< Vector > d, std::shared_ptr< Vector > du, std::shared_ptr< Vector > dlf, std::shared_ptr< Vector > df, std::shared_ptr< Vector > duf, std::shared_ptr< Vector > du2, std::shared_ptr< IntVector > ipiv, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > rcond)
 PSI_DGTSVX, a wrapper to return C_DGTSVX using objects. More...
 
int PSI_DGTTRF (int irrep, int n, std::shared_ptr< Vector > dl, std::shared_ptr< Vector > d, std::shared_ptr< Vector > du, std::shared_ptr< Vector > du2, std::shared_ptr< IntVector > ipiv)
 PSI_DGTTRF, a wrapper to return C_DGTTRF using objects. More...
 
int PSI_DGTTRS (int irrep, char trans, int n, int nrhs, std::shared_ptr< Vector > dl, std::shared_ptr< Vector > d, std::shared_ptr< Vector > du, std::shared_ptr< Vector > du2, std::shared_ptr< IntVector > ipiv, SharedMatrix b, int ldb)
 PSI_DGTTRS, a wrapper to return C_DGTTRS using objects. More...
 
int PSI_DHGEQZ (int irrep, char job, char compq, char compz, int n, int ilo, int ihi, SharedMatrix h, int ldh, SharedMatrix t, int ldt, std::shared_ptr< Vector > alphar, std::shared_ptr< Vector > alphai, std::shared_ptr< Vector > beta, SharedMatrix q, int ldq, SharedMatrix z, int ldz, std::shared_ptr< Vector > work, int lwork)
 PSI_DHGEQZ, a wrapper to return C_DHGEQZ using objects. More...
 
int PSI_DHSEIN (int irrep, char side, char eigsrc, char initv, int n, SharedMatrix h, int ldh, std::shared_ptr< Vector > wr, std::shared_ptr< Vector > wi, SharedMatrix vl, int ldvl, SharedMatrix vr, int ldvr, int mm, std::shared_ptr< IntVector > m, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > ifaill, std::shared_ptr< IntVector > ifailr)
 PSI_DHSEIN, a wrapper to return C_DHSEIN using objects. More...
 
int PSI_DHSEQR (int irrep, char job, char compz, int n, int ilo, int ihi, SharedMatrix h, int ldh, std::shared_ptr< Vector > wr, std::shared_ptr< Vector > wi, SharedMatrix z, int ldz, std::shared_ptr< Vector > work, int lwork)
 PSI_DHSEQR, a wrapper to return C_DHSEQR using objects. More...
 
int PSI_DORGBR (int irrep, char vect, int m, int n, int k, SharedMatrix a, int lda, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work, int lwork)
 PSI_DORGBR, a wrapper to return C_DORGBR using objects. More...
 
int PSI_DORGHR (int irrep, int n, int ilo, int ihi, SharedMatrix a, int lda, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work, int lwork)
 PSI_DORGHR, a wrapper to return C_DORGHR using objects. More...
 
int PSI_DORGLQ (int irrep, int m, int n, int k, SharedMatrix a, int lda, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work, int lwork)
 PSI_DORGLQ, a wrapper to return C_DORGLQ using objects. More...
 
int PSI_DORGQL (int irrep, int m, int n, int k, SharedMatrix a, int lda, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work, int lwork)
 PSI_DORGQL, a wrapper to return C_DORGQL using objects. More...
 
int PSI_DORGQR (int irrep, int m, int n, int k, SharedMatrix a, int lda, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work, int lwork)
 PSI_DORGQR, a wrapper to return C_DORGQR using objects. More...
 
int PSI_DORGRQ (int irrep, int m, int n, int k, SharedMatrix a, int lda, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work, int lwork)
 PSI_DORGRQ, a wrapper to return C_DORGRQ using objects. More...
 
int PSI_DORGTR (int irrep, char uplo, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work, int lwork)
 PSI_DORGTR, a wrapper to return C_DORGTR using objects. More...
 
int PSI_DORMBR (int irrep, char vect, char side, char trans, int m, int n, int k, std::shared_ptr< Vector > a, int lda, std::shared_ptr< Vector > tau, SharedMatrix c, int ldc, std::shared_ptr< Vector > work, int lwork)
 PSI_DORMBR, a wrapper to return C_DORMBR using objects. More...
 
int PSI_DORMHR (int irrep, char side, char trans, int m, int n, int ilo, int ihi, std::shared_ptr< Vector > a, int lda, std::shared_ptr< Vector > tau, SharedMatrix c, int ldc, std::shared_ptr< Vector > work, int lwork)
 PSI_DORMHR, a wrapper to return C_DORMHR using objects. More...
 
int PSI_DORMLQ (int irrep, char side, char trans, int m, int n, int k, std::shared_ptr< Vector > a, int lda, std::shared_ptr< Vector > tau, SharedMatrix c, int ldc, std::shared_ptr< Vector > work, int lwork)
 PSI_DORMLQ, a wrapper to return C_DORMLQ using objects. More...
 
int PSI_DORMQL (int irrep, char side, char trans, int m, int n, int k, SharedMatrix a, int lda, std::shared_ptr< Vector > tau, SharedMatrix c, int ldc, std::shared_ptr< Vector > work, int lwork)
 PSI_DORMQL, a wrapper to return C_DORMQL using objects. More...
 
int PSI_DORMQR (int irrep, char side, char trans, int m, int n, int k, SharedMatrix a, int lda, std::shared_ptr< Vector > tau, SharedMatrix c, int ldc, std::shared_ptr< Vector > work, int lwork)
 PSI_DORMQR, a wrapper to return C_DORMQR using objects. More...
 
int PSI_DORMR3 (int irrep, char side, char trans, int m, int n, int k, int l, std::shared_ptr< Vector > a, int lda, std::shared_ptr< Vector > tau, SharedMatrix c, int ldc, std::shared_ptr< Vector > work)
 PSI_DORMR3, a wrapper to return C_DORMR3 using objects. More...
 
int PSI_DORMRQ (int irrep, char side, char trans, int m, int n, int k, std::shared_ptr< Vector > a, int lda, std::shared_ptr< Vector > tau, SharedMatrix c, int ldc, std::shared_ptr< Vector > work, int lwork)
 PSI_DORMRQ, a wrapper to return C_DORMRQ using objects. More...
 
int PSI_DORMRZ (int irrep, char side, char trans, int m, int n, int k, int l, std::shared_ptr< Vector > a, int lda, std::shared_ptr< Vector > tau, SharedMatrix c, int ldc, std::shared_ptr< Vector > work, int lwork)
 PSI_DORMRZ, a wrapper to return C_DORMRZ using objects. More...
 
int PSI_DORMTR (int irrep, char side, char uplo, char trans, int m, int n, std::shared_ptr< Vector > a, int lda, std::shared_ptr< Vector > tau, SharedMatrix c, int ldc, std::shared_ptr< Vector > work, int lwork)
 PSI_DORMTR, a wrapper to return C_DORMTR using objects. More...
 
int PSI_DPBCON (int irrep, char uplo, int n, int kd, SharedMatrix ab, int ldab, double anorm, std::shared_ptr< Vector > rcond, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DPBCON, a wrapper to return C_DPBCON using objects. More...
 
int PSI_DPBEQU (int irrep, char uplo, int n, int kd, SharedMatrix ab, int ldab, std::shared_ptr< Vector > s, std::shared_ptr< Vector > scond, std::shared_ptr< Vector > amax)
 PSI_DPBEQU, a wrapper to return C_DPBEQU using objects. More...
 
int PSI_DPBRFS (int irrep, char uplo, int n, int kd, int nrhs, SharedMatrix ab, int ldab, SharedMatrix afb, int ldafb, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > ferr, std::shared_ptr< Vector > berr, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DPBRFS, a wrapper to return C_DPBRFS using objects. More...
 
int PSI_DPBSTF (int irrep, char uplo, int n, int kd, SharedMatrix ab, int ldab)
 PSI_DPBSTF, a wrapper to return C_DPBSTF using objects. More...
 
int PSI_DPBSV (int irrep, char uplo, int n, int kd, int nrhs, SharedMatrix ab, int ldab, SharedMatrix b, int ldb)
 PSI_DPBSV, a wrapper to return C_DPBSV using objects. More...
 
int PSI_DPBSVX (int irrep, char fact, char uplo, int n, int kd, int nrhs, SharedMatrix ab, int ldab, SharedMatrix afb, int ldafb, char equed, std::shared_ptr< Vector > s, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > rcond, std::shared_ptr< Vector > ferr, std::shared_ptr< Vector > berr, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DPBSVX, a wrapper to return C_DPBSVX using objects. More...
 
int PSI_DPBTRF (int irrep, char uplo, int n, int kd, SharedMatrix ab, int ldab)
 PSI_DPBTRF, a wrapper to return C_DPBTRF using objects. More...
 
int PSI_DPBTRS (int irrep, char uplo, int n, int kd, int nrhs, SharedMatrix ab, int ldab, SharedMatrix b, int ldb)
 PSI_DPBTRS, a wrapper to return C_DPBTRS using objects. More...
 
int PSI_DPOCON (int irrep, char uplo, int n, SharedMatrix a, int lda, double anorm, std::shared_ptr< Vector > rcond, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DPOCON, a wrapper to return C_DPOCON using objects. More...
 
int PSI_DPOEQU (int irrep, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > s, std::shared_ptr< Vector > scond, std::shared_ptr< Vector > amax)
 PSI_DPOEQU, a wrapper to return C_DPOEQU using objects. More...
 
int PSI_DPORFS (int irrep, char uplo, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix af, int ldaf, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > ferr, std::shared_ptr< Vector > berr, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DPORFS, a wrapper to return C_DPORFS using objects. More...
 
int PSI_DPOSV (int irrep, char uplo, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix b, int ldb)
 PSI_DPOSV, a wrapper to return C_DPOSV using objects. More...
 
int PSI_DPOSVX (int irrep, char fact, char uplo, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix af, int ldaf, char equed, std::shared_ptr< Vector > s, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > rcond, std::shared_ptr< Vector > ferr, std::shared_ptr< Vector > berr, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DPOSVX, a wrapper to return C_DPOSVX using objects. More...
 
int PSI_DPOTRF (int irrep, char uplo, int n, SharedMatrix a, int lda)
 PSI_DPOTRF, a wrapper to return C_DPOTRF using objects. More...
 
int PSI_DPOTRI (int irrep, char uplo, int n, SharedMatrix a, int lda)
 PSI_DPOTRI, a wrapper to return C_DPOTRI using objects. More...
 
int PSI_DPOTRS (int irrep, char uplo, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix b, int ldb)
 PSI_DPOTRS, a wrapper to return C_DPOTRS using objects. More...
 
int PSI_DPTCON (int irrep, int n, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, double anorm, std::shared_ptr< Vector > rcond, std::shared_ptr< Vector > work)
 PSI_DPTCON, a wrapper to return C_DPTCON using objects. More...
 
int PSI_DPTEQR (int irrep, char compz, int n, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, SharedMatrix z, int ldz, std::shared_ptr< Vector > work)
 PSI_DPTEQR, a wrapper to return C_DPTEQR using objects. More...
 
int PSI_DPTRFS (int irrep, int n, int nrhs, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, std::shared_ptr< Vector > df, std::shared_ptr< Vector > ef, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > ferr, std::shared_ptr< Vector > berr, std::shared_ptr< Vector > work)
 PSI_DPTRFS, a wrapper to return C_DPTRFS using objects. More...
 
int PSI_DPTSV (int irrep, int n, int nrhs, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, SharedMatrix b, int ldb)
 PSI_DPTSV, a wrapper to return C_DPTSV using objects. More...
 
int PSI_DPTSVX (int irrep, char fact, int n, int nrhs, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, std::shared_ptr< Vector > df, std::shared_ptr< Vector > ef, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > rcond, std::shared_ptr< Vector > ferr, std::shared_ptr< Vector > berr, std::shared_ptr< Vector > work)
 PSI_DPTSVX, a wrapper to return C_DPTSVX using objects. More...
 
int PSI_DPTTRF (int irrep, int n, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e)
 PSI_DPTTRF, a wrapper to return C_DPTTRF using objects. More...
 
int PSI_DPTTRS (int irrep, int n, int nrhs, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, SharedMatrix b, int ldb)
 PSI_DPTTRS, a wrapper to return C_DPTTRS using objects. More...
 
int PSI_DSBEV (int irrep, char jobz, char uplo, int n, int kd, SharedMatrix ab, int ldab, std::shared_ptr< Vector > w, SharedMatrix z, int ldz, std::shared_ptr< Vector > work)
 PSI_DSBEV, a wrapper to return C_DSBEV using objects. More...
 
int PSI_DSBEVD (int irrep, char jobz, char uplo, int n, int kd, SharedMatrix ab, int ldab, std::shared_ptr< Vector > w, SharedMatrix z, int ldz, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, int liwork)
 PSI_DSBEVD, a wrapper to return C_DSBEVD using objects. More...
 
int PSI_DSBEVX (int irrep, char jobz, char range, char uplo, int n, int kd, SharedMatrix ab, int ldab, SharedMatrix q, int ldq, double vl, double vu, int il, int iu, double abstol, std::shared_ptr< IntVector > m, std::shared_ptr< Vector > w, SharedMatrix z, int ldz, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork, std::shared_ptr< IntVector > ifail)
 PSI_DSBEVX, a wrapper to return C_DSBEVX using objects. More...
 
int PSI_DSBGST (int irrep, char vect, char uplo, int n, int ka, int kb, SharedMatrix ab, int ldab, SharedMatrix bb, int ldbb, SharedMatrix x, int ldx, std::shared_ptr< Vector > work)
 PSI_DSBGST, a wrapper to return C_DSBGST using objects. More...
 
int PSI_DSBGV (int irrep, char jobz, char uplo, int n, int ka, int kb, SharedMatrix ab, int ldab, SharedMatrix bb, int ldbb, std::shared_ptr< Vector > w, SharedMatrix z, int ldz, std::shared_ptr< Vector > work)
 PSI_DSBGV, a wrapper to return C_DSBGV using objects. More...
 
int PSI_DSBGVD (int irrep, char jobz, char uplo, int n, int ka, int kb, SharedMatrix ab, int ldab, SharedMatrix bb, int ldbb, std::shared_ptr< Vector > w, SharedMatrix z, int ldz, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, int liwork)
 PSI_DSBGVD, a wrapper to return C_DSBGVD using objects. More...
 
int PSI_DSBGVX (int irrep, char jobz, char range, char uplo, int n, int ka, int kb, SharedMatrix ab, int ldab, SharedMatrix bb, int ldbb, SharedMatrix q, int ldq, double vl, double vu, int il, int iu, double abstol, std::shared_ptr< IntVector > m, std::shared_ptr< Vector > w, SharedMatrix z, int ldz, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork, std::shared_ptr< IntVector > ifail)
 PSI_DSBGVX, a wrapper to return C_DSBGVX using objects. More...
 
int PSI_DSBTRD (int irrep, char vect, char uplo, int n, int kd, SharedMatrix ab, int ldab, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, SharedMatrix q, int ldq, std::shared_ptr< Vector > work)
 PSI_DSBTRD, a wrapper to return C_DSBTRD using objects. More...
 
int PSI_DSGESV (int irrep, int n, int nrhs, std::shared_ptr< Vector > a, int lda, std::shared_ptr< IntVector > ipiv, SharedMatrix b, int ldb, SharedMatrix x, int ldx, SharedMatrix work, std::shared_ptr< IntVector > iter)
 PSI_DSGESV, a wrapper to return C_DSGESV using objects. More...
 
int PSI_DSTEBZ (int irrep, char range, char order, int n, double vl, double vu, int il, int iu, double abstol, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, std::shared_ptr< IntVector > m, std::shared_ptr< IntVector > nsplit, std::shared_ptr< Vector > w, std::shared_ptr< IntVector > iblock, std::shared_ptr< IntVector > isplit, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DSTEBZ, a wrapper to return C_DSTEBZ using objects. More...
 
int PSI_DSTEDC (int irrep, char compz, int n, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, SharedMatrix z, int ldz, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, int liwork)
 PSI_DSTEDC, a wrapper to return C_DSTEDC using objects. More...
 
int PSI_DSTEGR (int irrep, char jobz, char range, int n, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, double vl, double vu, int il, int iu, double abstol, std::shared_ptr< IntVector > m, std::shared_ptr< Vector > w, SharedMatrix z, int ldz, std::shared_ptr< IntVector > isuppz, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, int liwork)
 PSI_DSTEGR, a wrapper to return C_DSTEGR using objects. More...
 
int PSI_DSTEIN (int irrep, int n, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, int m, std::shared_ptr< Vector > w, std::shared_ptr< IntVector > iblock, std::shared_ptr< IntVector > isplit, SharedMatrix z, int ldz, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork, std::shared_ptr< IntVector > ifail)
 PSI_DSTEIN, a wrapper to return C_DSTEIN using objects. More...
 
int PSI_DSTEQR (int irrep, char compz, int n, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, SharedMatrix z, int ldz, std::shared_ptr< Vector > work)
 PSI_DSTEQR, a wrapper to return C_DSTEQR using objects. More...
 
int PSI_DSTERF (int irrep, int n, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e)
 PSI_DSTERF, a wrapper to return C_DSTERF using objects. More...
 
int PSI_DSTEV (int irrep, char jobz, int n, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, SharedMatrix z, int ldz, std::shared_ptr< Vector > work)
 PSI_DSTEV, a wrapper to return C_DSTEV using objects. More...
 
int PSI_DSTEVD (int irrep, char jobz, int n, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, SharedMatrix z, int ldz, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, int liwork)
 PSI_DSTEVD, a wrapper to return C_DSTEVD using objects. More...
 
int PSI_DSTEVR (int irrep, char jobz, char range, int n, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, double vl, double vu, int il, int iu, double abstol, std::shared_ptr< IntVector > m, std::shared_ptr< Vector > w, SharedMatrix z, int ldz, std::shared_ptr< IntVector > isuppz, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, int liwork)
 PSI_DSTEVR, a wrapper to return C_DSTEVR using objects. More...
 
int PSI_DSTEVX (int irrep, char jobz, char range, int n, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, double vl, double vu, int il, int iu, double abstol, std::shared_ptr< IntVector > m, std::shared_ptr< Vector > w, SharedMatrix z, int ldz, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork, std::shared_ptr< IntVector > ifail)
 PSI_DSTEVX, a wrapper to return C_DSTEVX using objects. More...
 
int PSI_DSYCON (int irrep, char uplo, int n, SharedMatrix a, int lda, std::shared_ptr< IntVector > ipiv, double anorm, std::shared_ptr< Vector > rcond, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DSYCON, a wrapper to return C_DSYCON using objects. More...
 
int PSI_DSYEV (int irrep, char jobz, char uplo, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > w, std::shared_ptr< Vector > work, int lwork)
 PSI_DSYEV, a wrapper to return C_DSYEV using objects. More...
 
int PSI_DSYEVD (int irrep, char jobz, char uplo, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > w, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, int liwork)
 PSI_DSYEVD, a wrapper to return C_DSYEVD using objects. More...
 
int PSI_DSYEVR (int irrep, char jobz, char range, char uplo, int n, SharedMatrix a, int lda, double vl, double vu, int il, int iu, double abstol, std::shared_ptr< IntVector > m, std::shared_ptr< Vector > w, SharedMatrix z, int ldz, std::shared_ptr< IntVector > isuppz, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, int liwork)
 PSI_DSYEVR, a wrapper to return C_DSYEVR using objects. More...
 
int PSI_DSYEVX (int irrep, char jobz, char range, char uplo, int n, SharedMatrix a, int lda, double vl, double vu, int il, int iu, double abstol, std::shared_ptr< IntVector > m, std::shared_ptr< Vector > w, SharedMatrix z, int ldz, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, std::shared_ptr< IntVector > ifail)
 PSI_DSYEVX, a wrapper to return C_DSYEVX using objects. More...
 
int PSI_DSYGST (int irrep, int itype, char uplo, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb)
 PSI_DSYGST, a wrapper to return C_DSYGST using objects. More...
 
int PSI_DSYGV (int irrep, int itype, char jobz, char uplo, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< Vector > w, std::shared_ptr< Vector > work, int lwork)
 PSI_DSYGV, a wrapper to return C_DSYGV using objects. More...
 
int PSI_DSYGVD (int irrep, int itype, char jobz, char uplo, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< Vector > w, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, int liwork)
 PSI_DSYGVD, a wrapper to return C_DSYGVD using objects. More...
 
int PSI_DSYGVX (int irrep, int itype, char jobz, char range, char uplo, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, double vl, double vu, int il, int iu, double abstol, std::shared_ptr< IntVector > m, std::shared_ptr< Vector > w, SharedMatrix z, int ldz, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, std::shared_ptr< IntVector > ifail)
 PSI_DSYGVX, a wrapper to return C_DSYGVX using objects. More...
 
int PSI_DSYRFS (int irrep, char uplo, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix af, int ldaf, std::shared_ptr< IntVector > ipiv, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > ferr, std::shared_ptr< Vector > berr, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DSYRFS, a wrapper to return C_DSYRFS using objects. More...
 
int PSI_DSYSV (int irrep, char uplo, int n, int nrhs, SharedMatrix a, int lda, std::shared_ptr< IntVector > ipiv, SharedMatrix b, int ldb, std::shared_ptr< Vector > work, int lwork)
 PSI_DSYSV, a wrapper to return C_DSYSV using objects. More...
 
int PSI_DSYSVX (int irrep, char fact, char uplo, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix af, int ldaf, std::shared_ptr< IntVector > ipiv, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > rcond)
 PSI_DSYSVX, a wrapper to return C_DSYSVX using objects. More...
 
int PSI_DSYTRD (int irrep, char uplo, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > d, std::shared_ptr< Vector > e, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work, int lwork)
 PSI_DSYTRD, a wrapper to return C_DSYTRD using objects. More...
 
int PSI_DSYTRF (int irrep, char uplo, int n, SharedMatrix a, int lda, std::shared_ptr< IntVector > ipiv, std::shared_ptr< Vector > work, int lwork)
 PSI_DSYTRF, a wrapper to return C_DSYTRF using objects. More...
 
int PSI_DSYTRI (int irrep, char uplo, int n, SharedMatrix a, int lda, std::shared_ptr< IntVector > ipiv, std::shared_ptr< Vector > work)
 PSI_DSYTRI, a wrapper to return C_DSYTRI using objects. More...
 
int PSI_DSYTRS (int irrep, char uplo, int n, int nrhs, SharedMatrix a, int lda, std::shared_ptr< IntVector > ipiv, SharedMatrix b, int ldb)
 PSI_DSYTRS, a wrapper to return C_DSYTRS using objects. More...
 
int PSI_DTBCON (int irrep, char norm, char uplo, char diag, int n, int kd, SharedMatrix ab, int ldab, std::shared_ptr< Vector > rcond, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DTBCON, a wrapper to return C_DTBCON using objects. More...
 
int PSI_DTBRFS (int irrep, char uplo, char trans, char diag, int n, int kd, int nrhs, SharedMatrix ab, int ldab, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > ferr, std::shared_ptr< Vector > berr, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DTBRFS, a wrapper to return C_DTBRFS using objects. More...
 
int PSI_DTBTRS (int irrep, char uplo, char trans, char diag, int n, int kd, int nrhs, SharedMatrix ab, int ldab, SharedMatrix b, int ldb)
 PSI_DTBTRS, a wrapper to return C_DTBTRS using objects. More...
 
int PSI_DTGEVC (int irrep, char side, char howmny, int n, SharedMatrix s, int lds, SharedMatrix p, int ldp, SharedMatrix vl, int ldvl, SharedMatrix vr, int ldvr, int mm, std::shared_ptr< IntVector > m, std::shared_ptr< Vector > work)
 PSI_DTGEVC, a wrapper to return C_DTGEVC using objects. More...
 
int PSI_DTGEXC (int irrep, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, SharedMatrix q, int ldq, SharedMatrix z, int ldz, std::shared_ptr< IntVector > ifst, std::shared_ptr< IntVector > ilst, std::shared_ptr< Vector > work, int lwork)
 PSI_DTGEXC, a wrapper to return C_DTGEXC using objects. More...
 
int PSI_DTGSEN (int irrep, int ijob, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, std::shared_ptr< Vector > alphar, std::shared_ptr< Vector > alphai, std::shared_ptr< Vector > beta, SharedMatrix q, int ldq, SharedMatrix z, int ldz, std::shared_ptr< IntVector > m, std::shared_ptr< Vector > pl, std::shared_ptr< Vector > pr, std::shared_ptr< Vector > dif, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, int liwork)
 PSI_DTGSEN, a wrapper to return C_DTGSEN using objects. More...
 
int PSI_DTGSJA (int irrep, char jobu, char jobv, char jobq, int m, int p, int n, int k, int l, SharedMatrix a, int lda, SharedMatrix b, int ldb, double tola, double tolb, std::shared_ptr< Vector > alpha, std::shared_ptr< Vector > beta, SharedMatrix u, int ldu, SharedMatrix v, int ldv, SharedMatrix q, int ldq, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > ncycle)
 PSI_DTGSJA, a wrapper to return C_DTGSJA using objects. More...
 
int PSI_DTGSNA (int irrep, char job, char howmny, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, SharedMatrix vl, int ldvl, SharedMatrix vr, int ldvr, std::shared_ptr< Vector > s, std::shared_ptr< Vector > dif, int mm, std::shared_ptr< IntVector > m, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork)
 PSI_DTGSNA, a wrapper to return C_DTGSNA using objects. More...
 
int PSI_DTGSYL (int irrep, char trans, int ijob, int m, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, SharedMatrix c, int ldc, SharedMatrix d, int ldd, SharedMatrix e, int lde, SharedMatrix f, int ldf, std::shared_ptr< Vector > dif, std::shared_ptr< Vector > scale, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork)
 PSI_DTGSYL, a wrapper to return C_DTGSYL using objects. More...
 
int PSI_DTRCON (int irrep, char norm, char uplo, char diag, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > rcond, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DTRCON, a wrapper to return C_DTRCON using objects. More...
 
int PSI_DTREVC (int irrep, char side, char howmny, int n, SharedMatrix t, int ldt, SharedMatrix vl, int ldvl, SharedMatrix vr, int ldvr, int mm, std::shared_ptr< IntVector > m, std::shared_ptr< Vector > work)
 PSI_DTREVC, a wrapper to return C_DTREVC using objects. More...
 
int PSI_DTREXC (int irrep, char compq, int n, SharedMatrix t, int ldt, SharedMatrix q, int ldq, std::shared_ptr< IntVector > ifst, std::shared_ptr< IntVector > ilst, std::shared_ptr< Vector > work)
 PSI_DTREXC, a wrapper to return C_DTREXC using objects. More...
 
int PSI_DTRRFS (int irrep, char uplo, char trans, char diag, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix b, int ldb, SharedMatrix x, int ldx, std::shared_ptr< Vector > ferr, std::shared_ptr< Vector > berr, std::shared_ptr< Vector > work, std::shared_ptr< IntVector > iwork)
 PSI_DTRRFS, a wrapper to return C_DTRRFS using objects. More...
 
int PSI_DTRSEN (int irrep, char job, char compq, int n, SharedMatrix t, int ldt, SharedMatrix q, int ldq, std::shared_ptr< Vector > wr, std::shared_ptr< Vector > wi, std::shared_ptr< IntVector > m, std::shared_ptr< Vector > s, std::shared_ptr< Vector > sep, std::shared_ptr< Vector > work, int lwork, std::shared_ptr< IntVector > iwork, int liwork)
 PSI_DTRSEN, a wrapper to return C_DTRSEN using objects. More...
 
int PSI_DTRSNA (int irrep, char job, char howmny, int n, SharedMatrix t, int ldt, SharedMatrix vl, int ldvl, SharedMatrix vr, int ldvr, std::shared_ptr< Vector > s, std::shared_ptr< Vector > sep, int mm, std::shared_ptr< IntVector > m, SharedMatrix work, int ldwork, std::shared_ptr< IntVector > iwork)
 PSI_DTRSNA, a wrapper to return C_DTRSNA using objects. More...
 
int PSI_DTRSYL (int irrep, char trana, char tranb, int isgn, int m, int n, SharedMatrix a, int lda, SharedMatrix b, int ldb, SharedMatrix c, int ldc, std::shared_ptr< Vector > scale)
 PSI_DTRSYL, a wrapper to return C_DTRSYL using objects. More...
 
int PSI_DTRTRI (int irrep, char uplo, char diag, int n, SharedMatrix a, int lda)
 PSI_DTRTRI, a wrapper to return C_DTRTRI using objects. More...
 
int PSI_DTRTRS (int irrep, char uplo, char trans, char diag, int n, int nrhs, SharedMatrix a, int lda, SharedMatrix b, int ldb)
 PSI_DTRTRS, a wrapper to return C_DTRTRS using objects. More...
 
int PSI_DTZRQF (int irrep, int m, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > tau)
 PSI_DTZRQF, a wrapper to return C_DTZRQF using objects. More...
 
int PSI_DTZRZF (int irrep, int m, int n, SharedMatrix a, int lda, std::shared_ptr< Vector > tau, std::shared_ptr< Vector > work, int lwork)
 PSI_DTZRZF, a wrapper to return C_DTZRZF using objects. More...
 
static void shell_vector_deleter_ (ShellVec *mpv)
 
static void multishell_vector_deleter_ (ShellPairVec *mpv)
 
static simint_shell psi_shell_to_simint_ (const GaussianShell &s)
 
static std::shared_ptr< ShellVeccreate_shell_vec_ (const BasisSet &bs)
 
static std::shared_ptr
< ShellPairVec
create_shell_pair_ (const ShellVec &bs1, const ShellVec &bs2)
 
static ShellPairVec create_multi_shellpair_ (const std::vector< ShellPairBlock > &vsh, const ShellVec &shell1, const ShellVec &shell2)
 
static std::shared_ptr
< ShellPairVec
create_shared_multi_shellpair_ (const std::vector< ShellPairBlock > &vsh, const ShellVec &shell1, const ShellVec &shell2)
 
template<typename T >
void swap_index (T &a, T &b)
 
Vector3 operator* (double, const Vector3 &)
 
void plugin_close (const plugin_info &info)
 
plugin_info plugin_load (std::string &plugin_path)
 
void generate_combinations (int n, int k, std::vector< std::vector< int >> &combinations)
 
std::string file_to_string (std::string const &name)
 
bool space (char c)
 
bool not_space (char c)
 
std::vector< std::string > split (const std::string &str)
 
std::vector< std::string > split_indices (const std::string &str)
 
void to_lower (std::string &str)
 
std::string to_lower_copy (const std::string &str)
 
void to_upper (std::string &str)
 
std::string to_upper_copy (const std::string &str)
 
std::string to_string (const int val)
 
std::string to_string (const double val)
 
double to_double (const std::string str)
 
int to_integer (const std::string inString)
 
void append_reference (std::string &str, int reference)
 
std::string add_reference (std::string &str, int reference)
 
std::string find_and_replace (std::string &source, const std::string &target, const std::string &replace)
 
void trim_spaces (std::string &str)
 
template<typename Range1T , typename Range2T >
bool iequals (const Range1T &Input, const Range2T &Test)
 
std::vector< std::string > split (const std::string &input, const std::string &regex)
 
size_t edit_distance (const std::string &s1, const std::string &s2)
 Compute the Levenshtein distance between two strings. More...
 
double bytes_to_MiB (size_t n)
 
template<typename T >
double type_to_MiB (size_t n)
 
void die_if_not_converged ()
 
bool opening_square_bracket (char c)
 
bool closing_square_bracket (char c)
 
int psio_close (size_t unit, int keep)
 
int psio_done ()
 
void psio_error (size_t unit, size_t errval)
 
std::string fullkwd (const char *kwdgrp, const char *kwd, int unit)
 
int psio_set_filescfg_kwd (const char *kwdgrp, const char *kwd, int unit, const char *kwdval)
 
const char * psio_get_filescfg_kwd (const char *kwdgrp, const char *kwd, int unit)
 
psio_address psio_get_address (psio_address start, size_t shift)
 
int psio_get_filename_default (char **name)
 
psio_address psio_get_global_address (psio_address entry_start, psio_address rel_address)
 
size_t psio_get_length (psio_address sadd, psio_address eadd)
 
size_t psio_get_numvols_default ()
 
int psio_get_volpath_default (size_t volume, char **path)
 
std::string psio_getpid ()
 
int psio_init ()
 
int psio_state ()
 
int psio_open (size_t unit, int status)
 
int psio_open_check (size_t unit)
 
int psio_ipv1_config ()
 
int psio_volseek (psio_vol *vol, size_t page, size_t offset, size_t numvols)
 
psio_address psio_get_entry_end (size_t unit, const char *key)
 
int psio_tocwrite (size_t unit)
 
int psio_tocread (size_t unit)
 
void psio_tocprint (size_t unit, FILE *output)
 
psio_tocentrypsio_tocscan (size_t unit, const char *key)
 
bool psio_tocentry_exists (size_t unit, const char *key)
 
psio_tocentrypsio_toclast (size_t unit)
 
int psio_tocclean (size_t unit, const char *key)
 
int psio_write (size_t unit, const char *key, char *buffer, size_t size, psio_address sadd, psio_address *eadd)
 
int psio_read (size_t unit, const char *key, char *buffer, size_t size, psio_address sadd, psio_address *eadd)
 
int psio_write_entry (size_t unit, const char *key, char *buffer, size_t size)
 
int psio_read_entry (size_t unit, const char *key, char *buffer, size_t size)
 
int psio_write_block (size_t unit, const char *key, char *buffer, size_t blksiz, size_t start_blk, size_t end_blk)
 
int psio_read_block (size_t unit, const char *key, char *buffer, size_t blksiz, size_t start_blk, size_t end_blk)
 
int psio_rw (size_t unit, char *buffer, psio_address address, size_t size, int wrt)
 
int psio_zero_disk (size_t unit, const char *key, size_t rows, size_t cols)
 
size_t psio_rd_toclen (size_t unit)
 
void psio_wt_toclen (size_t unit, size_t toclen)
 
bool psio_tocdel (size_t unit, const char *key)
 
void psio_tocprint (size_t unit)
 
double *** init_3d_array (int p, int q, int r)
 
void free_3d_array (double ***A, int p, int q)
 
void PSI_API C_DSWAP (size_t length, double *x, int inc_x, double *y, int inc_y)
 
void PSI_API C_DAXPY (size_t length, double a, double *x, int inc_x, double *y, int inc_y)
 
void PSI_API C_DCOPY (size_t length, double *x, int inc_x, double *y, int inc_y)
 
void PSI_API C_DSCAL (size_t length, double alpha, double *vec, int inc)
 
void PSI_API C_DROT (size_t length, double *x, int inc_x, double *y, int inc_y, double costheta, double sintheta)
 
double PSI_API C_DDOT (size_t length, double *x, int inc_x, double *y, int inc_y)
 
double PSI_API C_DNRM2 (size_t length, double *x, int inc_x)
 
double PSI_API C_DASUM (size_t length, double *x, int inc_x)
 
size_t C_IDAMAX (size_t length, double *x, int inc_x)
 
void C_DGBMV (char trans, int m, int n, int kl, int ku, double alpha, double *a, int lda, double *x, int incx, double beta, double *y, int incy)
 
PSI_API void C_DGEMM (char transa, char transb, int m, int n, int k, double alpha, double *a, int lda, double *b, int ldb, double beta, double *c, int ldc)
 
PSI_API void C_DGEMV (char trans, int m, int n, double alpha, double *a, int lda, double *x, int incx, double beta, double *y, int incy)
 
PSI_API void C_DGER (int m, int n, double alpha, double *x, int incx, double *y, int incy, double *a, int lda)
 
void C_DSBMV (char uplo, int n, int k, double alpha, double *a, int lda, double *x, int incx, double beta, double *y, int incy)
 
void C_DSPMV (char uplo, int n, double alpha, double *ap, double *x, int incx, double beta, double *y, int incy)
 
void C_DSPR (char uplo, int n, double alpha, double *x, int incx, double *ap)
 
void C_DSPR2 (char uplo, int n, double alpha, double *x, int incx, double *y, int incy, double *ap)
 
void C_DSYMM (char side, char uplo, int m, int n, double alpha, double *a, int lda, double *b, int ldb, double beta, double *c, int ldc)
 
void C_DSYMV (char uplo, int n, double alpha, double *a, int lda, double *x, int incx, double beta, double *y, int incy)
 
void C_DSYR (char uplo, int n, double alpha, double *x, int incx, double *a, int lda)
 
void C_DSYR2 (char uplo, int n, double alpha, double *x, int incx, double *y, int incy, double *a, int lda)
 
void C_DSYR2K (char uplo, char trans, int n, int k, double alpha, double *a, int lda, double *b, int ldb, double beta, double *c, int ldc)
 
void C_DSYRK (char uplo, char trans, int n, int k, double alpha, double *a, int lda, double beta, double *c, int ldc)
 
void C_DTBMV (char uplo, char trans, char diag, int n, int k, double *a, int lda, double *x, int incx)
 
void C_DTBSV (char uplo, char trans, char diag, int n, int k, double *a, int lda, double *x, int incx)
 
void C_DTPMV (char uplo, char trans, char diag, int n, double *ap, double *x, int incx)
 
void C_DTPSV (char uplo, char trans, char diag, int n, double *ap, double *x, int incx)
 
void C_DTRMM (char side, char uplo, char transa, char diag, int m, int n, double alpha, double *a, int lda, double *b, int ldb)
 
void C_DTRMV (char uplo, char trans, char diag, int n, double *a, int lda, double *x, int incx)
 
void C_DTRSM (char side, char uplo, char transa, char diag, int m, int n, double alpha, double *a, int lda, double *b, int ldb)
 
void C_DTRSV (char uplo, char trans, char diag, int n, double *a, int lda, double *x, int incx)
 
int cc_excited (const char *wfn)
 
int cc_excited (std::string wfn)
 
int david (double **A, int N, int M, double *eps, double **v, double cutoff, int print)
 
void dirprd_block (double **A, double **B, int rows, int cols)
 
double dot_block (double **A, double **B, int rows, int cols, double alpha)
 
void dx_read (double **V_eff, double *phi_ao, double *phi_so, int nao, int nso, double **u)
 
void compute_delta (double **delta, double x, double y, double z)
 
void dx_write (std::shared_ptr< Wavefunction > wfn, Options &options, double **D)
 
void fill_sym_matrix (double **A, int size)
 
double invert_matrix (double **a, double **y, int N, std::string out)
 
int C_DGEEV (int n, double **a, int lda, double *wr, double *wi, double **vl, int ldvl, double **vr, int ldvr, double *work, int lwork, int info)
 
int C_DGESV (int n, int nrhs, double *a, int lda, int *ipiv, double *b, int ldb)
 
int C_DGETRF (int nrow, int ncol, double *a, int lda, int *ipiv)
 
int C_DPOTRF (char uplo, int n, double *A, int lda)
 
int C_DGETRI (int n, double *a, int lda, int *ipiv, double *work, int lwork)
 
int C_DPOTRI (char uplo, int n, double *A, int lda)
 
int C_DPOTRS (char uplo, int n, int nrhs, double *A, int lda, double *B, int ldb)
 
int C_DGESVD (char jobu, char jobvt, int m, int n, double *A, int lda, double *s, double *u, int ldu, double *vt, int ldvt, double *work, int lwork)
 
int C_DSYEV (char jobz, char uplo, int n, double *A, int lda, double *w, double *work, int lwork)
 
void mat_print (double **matrix, int rows, int cols, std::string out)
 
void newmm_rking (double **A, int transa, double **B, int transb, double **C, int num_rows, int num_links, int num_cols, double alpha, double beta)
 
void normalize (double **A, int rows, int cols)
 
int pople (double **A, double *x, int dimen, int, double tolerance, std::string out, int print_lvl)
 
double factorial (int n)
 
double combinations (int n, int k)
 
void schmidt (double **A, int rows, int cols, std::string out_fname)
 
PSI_API int schmidt_add (double **A, int rows, int cols, double *v)
 
void solve_2x2_pep (double **H, double S, double *evals, double **evecs)
 
PSI_API void reorder_qt (int *docc_in, int *socc_in, int *frozen_docc_in, int *frozen_uocc_in, int *order, int *orbs_per_irrep, int nirreps)
 
PSI_API void reorder_qt_uhf (int *docc, int *socc, int *frozen_docc, int *frozen_uocc, int *order_alpha, int *order_beta, int *orbspi, int nirreps)
 
int ras_set3 (int nirreps, int nmo, int *orbspi, int *docc, int *socc, int *frdocc, int *fruocc, int *restrdocc, int *restruocc, int **ras_opi, int *core_guess, int *order, int ras_type, bool is_mcscf, Options &options)
 
void timer_init ()
 
void timer_done ()
 
void timer_on (const std::string &key)
 
void timer_off (const std::string &key)
 
void parallel_timer_on (const std::string &key, int thread_rank)
 
void parallel_timer_off (const std::string &key, int thread_rank)
 
void start_skip_timers ()
 
void stop_skip_timers ()
 
void print_block (double *, int, int, FILE *)
 
int * get_frzcpi ()
 
int * get_frzvpi ()
 
int C_DBDSDC (char uplo, char compq, int n, double *d, double *e, double *u, int ldu, double *vt, int ldvt, double *q, int *iq, double *work, int *iwork)
 
int C_DBDSQR (char uplo, int n, int ncvt, int nru, int ncc, double *d, double *e, double *vt, int ldvt, double *u, int ldu, double *c, int ldc, double *work)
 
int C_DDISNA (char job, int m, int n, double *d, double *sep)
 
int C_DGBBRD (char vect, int m, int n, int ncc, int kl, int ku, double *ab, int ldab, double *d, double *e, double *q, int ldq, double *pt, int ldpt, double *c, int ldc, double *work)
 
int C_DGBCON (char norm, int n, int kl, int ku, double *ab, int ldab, int *ipiv, double anorm, double *rcond, double *work, int *iwork)
 
int C_DGBEQU (int m, int n, int kl, int ku, double *ab, int ldab, double *r, double *c, double *rowcnd, double *colcnd, double *amax)
 
int C_DGBRFS (char trans, int n, int kl, int ku, int nrhs, double *ab, int ldab, double *afb, int ldafb, int *ipiv, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, double *work, int *iwork)
 
int C_DGBSV (int n, int kl, int ku, int nrhs, double *ab, int ldab, int *ipiv, double *b, int ldb)
 
int C_DGBSVX (char fact, char trans, int n, int kl, int ku, int nrhs, double *ab, int ldab, double *afb, int ldafb, int *ipiv, char equed, double *r, double *c, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, double *work, int *iwork)
 
int C_DGBTRF (int m, int n, int kl, int ku, double *ab, int ldab, int *ipiv)
 
int C_DGBTRS (char trans, int n, int kl, int ku, int nrhs, double *ab, int ldab, int *ipiv, double *b, int ldb)
 
int C_DGEBAK (char job, char side, int n, int ilo, int ihi, double *scale, int m, double *v, int ldv)
 
int C_DGEBAL (char job, int n, double *a, int lda, int *ilo, int *ihi, double *scale)
 
int C_DGEBRD (int m, int n, double *a, int lda, double *d, double *e, double *tauq, double *taup, double *work, int lwork)
 
int C_DGECON (char norm, int n, double *a, int lda, double anorm, double *rcond, double *work, int *iwork)
 
int C_DGEEQU (int m, int n, double *a, int lda, double *r, double *c, double *rowcnd, double *colcnd, double *amax)
 
int C_DGEES (char jobvs, char sort, int n, double *a, int lda, int *sdim, double *wr, double *wi, double *vs, int ldvs, double *work, int lwork)
 
int C_DGEESX (char jobvs, char sort, char sense, int n, double *a, int lda, int *sdim, double *wr, double *wi, double *vs, int ldvs, double *rconde, double *rcondv, double *work, int lwork, int *iwork, int liwork)
 
int C_DGEEV (char jobvl, char jobvr, int n, double *a, int lda, double *wr, double *wi, double *vl, int ldvl, double *vr, int ldvr, double *work, int lwork)
 
int C_DGEEVX (char balanc, char jobvl, char jobvr, char sense, int n, double *a, int lda, double *wr, double *wi, double *vl, int ldvl, double *vr, int ldvr, int *ilo, int *ihi, double *scale, double *abnrm, double *rconde, double *rcondv, double *work, int lwork, int *iwork)
 
int C_DGEGS (char jobvsl, char jobvsr, int n, double *a, int lda, double *b, int ldb, double *alphar, double *alphai, double *beta, double *vsl, int ldvsl, double *vsr, int ldvsr, double *work, int lwork)
 
int C_DGEGV (char jobvl, char jobvr, int n, double *a, int lda, double *b, int ldb, double *alphar, double *alphai, double *beta, double *vl, int ldvl, double *vr, int ldvr, double *work, int lwork)
 
int C_DGEHRD (int n, int ilo, int ihi, double *a, int lda, double *tau, double *work, int lwork)
 
int C_DGELQF (int m, int n, double *a, int lda, double *tau, double *work, int lwork)
 
int C_DGELS (char trans, int m, int n, int nrhs, double *a, int lda, double *b, int ldb, double *work, int lwork)
 
int C_DGELSD (int m, int n, int nrhs, double *a, int lda, double *b, int ldb, double *s, double rcond, int *rank, double *work, int lwork, int *iwork)
 
int C_DGELSS (int m, int n, int nrhs, double *a, int lda, double *b, int ldb, double *s, double rcond, int *rank, double *work, int lwork)
 
int C_DGELSX (int m, int n, int nrhs, double *a, int lda, double *b, int ldb, int *jpvt, double rcond, int *rank, double *work)
 
int C_DGELSY (int m, int n, int nrhs, double *a, int lda, double *b, int ldb, int *jpvt, double rcond, int *rank, double *work, int lwork)
 
int C_DGEQLF (int m, int n, double *a, int lda, double *tau, double *work, int lwork)
 
int C_DGEQP3 (int m, int n, double *a, int lda, int *jpvt, double *tau, double *work, int lwork)
 
int C_DGEQPF (int m, int n, double *a, int lda, int *jpvt, double *tau, double *work)
 
int C_DGEQRF (int m, int n, double *a, int lda, double *tau, double *work, int lwork)
 
int C_DGERFS (char trans, int n, int nrhs, double *a, int lda, double *af, int ldaf, int *ipiv, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, double *work, int *iwork)
 
int C_DGERQF (int m, int n, double *a, int lda, double *tau, double *work, int lwork)
 
int C_DGESDD (char jobz, int m, int n, double *a, int lda, double *s, double *u, int ldu, double *vt, int ldvt, double *work, int lwork, int *iwork)
 
int C_DGESVX (char fact, char trans, int n, int nrhs, double *a, int lda, double *af, int ldaf, int *ipiv, char equed, double *r, double *c, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, double *work, int *iwork)
 
int C_DGETRS (char trans, int n, int nrhs, double *a, int lda, int *ipiv, double *b, int ldb)
 
int C_DGGBAK (char job, char side, int n, int ilo, int ihi, double *lscale, double *rscale, int m, double *v, int ldv)
 
int C_DGGBAL (char job, int n, double *a, int lda, double *b, int ldb, int *ilo, int *ihi, double *lscale, double *rscale, double *work)
 
int C_DGGES (char jobvsl, char jobvsr, char sort, int n, double *a, int lda, double *b, int ldb, int *sdim, double *alphar, double *alphai, double *beta, double *vsl, int ldvsl, double *vsr, int ldvsr, double *work, int lwork)
 
int C_DGGESX (char jobvsl, char jobvsr, char sort, char sense, int n, double *a, int lda, double *b, int ldb, int *sdim, double *alphar, double *alphai, double *beta, double *vsl, int ldvsl, double *vsr, int ldvsr, double *rconde, double *rcondv, double *work, int lwork, int *iwork, int liwork)
 
PSI_API int C_DGGEV (char jobvl, char jobvr, int n, double *a, int lda, double *b, int ldb, double *alphar, double *alphai, double *beta, double *vl, int ldvl, double *vr, int ldvr, double *work, int lwork)
 
int C_DGGEVX (char balanc, char jobvl, char jobvr, char sense, int n, double *a, int lda, double *b, int ldb, double *alphar, double *alphai, double *beta, double *vl, int ldvl, double *vr, int ldvr, int *ilo, int *ihi, double *lscale, double *rscale, double *abnrm, double *bbnrm, double *rconde, double *rcondv, double *work, int lwork, int *iwork)
 
int C_DGGGLM (int n, int m, int p, double *a, int lda, double *b, int ldb, double *d, double *x, double *y, double *work, int lwork)
 
int C_DGGHRD (char compq, char compz, int n, int ilo, int ihi, double *a, int lda, double *b, int ldb, double *q, int ldq, double *z, int ldz)
 
int C_DGGLSE (int m, int n, int p, double *a, int lda, double *b, int ldb, double *c, double *d, double *x, double *work, int lwork)
 
int C_DGGQRF (int n, int m, int p, double *a, int lda, double *taua, double *b, int ldb, double *taub, double *work, int lwork)
 
int C_DGGRQF (int m, int p, int n, double *a, int lda, double *taua, double *b, int ldb, double *taub, double *work, int lwork)
 
int C_DGGSVD (char jobu, char jobv, char jobq, int m, int n, int p, int *k, int *l, double *a, int lda, double *b, int ldb, double *alpha, double *beta, double *u, int ldu, double *v, int ldv, double *q, int ldq, double *work, int *iwork)
 
int C_DGGSVP (char jobu, char jobv, char jobq, int m, int p, int n, double *a, int lda, double *b, int ldb, double tola, double tolb, int *k, int *l, double *u, int ldu, double *v, int ldv, double *q, int ldq, int *iwork, double *tau, double *work)
 
int C_DGTCON (char norm, int n, double *dl, double *d, double *du, double *du2, int *ipiv, double anorm, double *rcond, double *work, int *iwork)
 
int C_DGTRFS (char trans, int n, int nrhs, double *dl, double *d, double *du, double *dlf, double *df, double *duf, double *du2, int *ipiv, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, double *work, int *iwork)
 
int C_DGTSV (int n, int nrhs, double *dl, double *d, double *du, double *b, int ldb)
 
int C_DGTSVX (char fact, char trans, int n, int nrhs, double *dl, double *d, double *du, double *dlf, double *df, double *duf, double *du2, int *ipiv, double *b, int ldb, double *x, int ldx, double *rcond)
 
int C_DGTTRF (int n, double *dl, double *d, double *du, double *du2, int *ipiv)
 
int C_DGTTRS (char trans, int n, int nrhs, double *dl, double *d, double *du, double *du2, int *ipiv, double *b, int ldb)
 
int C_DHGEQZ (char job, char compq, char compz, int n, int ilo, int ihi, double *h, int ldh, double *t, int ldt, double *alphar, double *alphai, double *beta, double *q, int ldq, double *z, int ldz, double *work, int lwork)
 
int C_DHSEIN (char side, char eigsrc, char initv, int n, double *h, int ldh, double *wr, double *wi, double *vl, int ldvl, double *vr, int ldvr, int mm, int *m, double *work, int *ifaill, int *ifailr)
 
int C_DHSEQR (char job, char compz, int n, int ilo, int ihi, double *h, int ldh, double *wr, double *wi, double *z, int ldz, double *work, int lwork)
 
int C_DOPGTR (char uplo, int n, double *ap, double *tau, double *q, int ldq, double *work)
 
int C_DOPMTR (char side, char uplo, char trans, int m, int n, double *ap, double *tau, double *c, int ldc, double *work)
 
int C_DORGBR (char vect, int m, int n, int k, double *a, int lda, double *tau, double *work, int lwork)
 
int C_DORGHR (int n, int ilo, int ihi, double *a, int lda, double *tau, double *work, int lwork)
 
int C_DORGLQ (int m, int n, int k, double *a, int lda, double *tau, double *work, int lwork)
 
int C_DORGQL (int m, int n, int k, double *a, int lda, double *tau, double *work, int lwork)
 
int C_DORGQR (int m, int n, int k, double *a, int lda, double *tau, double *work, int lwork)
 
int C_DORGRQ (int m, int n, int k, double *a, int lda, double *tau, double *work, int lwork)
 
int C_DORGTR (char uplo, int n, double *a, int lda, double *tau, double *work, int lwork)
 
int C_DORMBR (char vect, char side, char trans, int m, int n, int k, double *a, int lda, double *tau, double *c, int ldc, double *work, int lwork)
 
int C_DORMHR (char side, char trans, int m, int n, int ilo, int ihi, double *a, int lda, double *tau, double *c, int ldc, double *work, int lwork)
 
int C_DORMLQ (char side, char trans, int m, int n, int k, double *a, int lda, double *tau, double *c, int ldc, double *work, int lwork)
 
int C_DORMQL (char side, char trans, int m, int n, int k, double *a, int lda, double *tau, double *c, int ldc, double *work, int lwork)
 
int C_DORMQR (char side, char trans, int m, int n, int k, double *a, int lda, double *tau, double *c, int ldc, double *work, int lwork)
 
int C_DORMR3 (char side, char trans, int m, int n, int k, int l, double *a, int lda, double *tau, double *c, int ldc, double *work)
 
int C_DORMRQ (char side, char trans, int m, int n, int k, double *a, int lda, double *tau, double *c, int ldc, double *work, int lwork)
 
int C_DORMRZ (char side, char trans, int m, int n, int k, int l, double *a, int lda, double *tau, double *c, int ldc, double *work, int lwork)
 
int C_DORMTR (char side, char uplo, char trans, int m, int n, double *a, int lda, double *tau, double *c, int ldc, double *work, int lwork)
 
int C_DPBCON (char uplo, int n, int kd, double *ab, int ldab, double anorm, double *rcond, double *work, int *iwork)
 
int C_DPBEQU (char uplo, int n, int kd, double *ab, int ldab, double *s, double *scond, double *amax)
 
int C_DPBRFS (char uplo, int n, int kd, int nrhs, double *ab, int ldab, double *afb, int ldafb, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, double *work, int *iwork)
 
int C_DPBSTF (char uplo, int n, int kd, double *ab, int ldab)
 
int C_DPBSV (char uplo, int n, int kd, int nrhs, double *ab, int ldab, double *b, int ldb)
 
int C_DPBSVX (char fact, char uplo, int n, int kd, int nrhs, double *ab, int ldab, double *afb, int ldafb, char equed, double *s, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, double *work, int *iwork)
 
int C_DPBTRF (char uplo, int n, int kd, double *ab, int ldab)
 
int C_DPBTRS (char uplo, int n, int kd, int nrhs, double *ab, int ldab, double *b, int ldb)
 
int C_DPOCON (char uplo, int n, double *a, int lda, double anorm, double *rcond, double *work, int *iwork)
 
int C_DPOEQU (int n, double *a, int lda, double *s, double *scond, double *amax)
 
int C_DPORFS (char uplo, int n, int nrhs, double *a, int lda, double *af, int ldaf, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, double *work, int *iwork)
 
int C_DPOSV (char uplo, int n, int nrhs, double *a, int lda, double *b, int ldb)
 
int C_DPOSVX (char fact, char uplo, int n, int nrhs, double *a, int lda, double *af, int ldaf, char equed, double *s, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, double *work, int *iwork)
 
int C_DPPCON (char uplo, int n, double *ap, double anorm, double *rcond, double *work, int *iwork)
 
int C_DPPEQU (char uplo, int n, double *ap, double *s, double *scond, double *amax)
 
int C_DPPRFS (char uplo, int n, int nrhs, double *ap, double *afp, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, double *work, int *iwork)
 
int C_DPPSV (char uplo, int n, int nrhs, double *ap, double *b, int ldb)
 
int C_DPPSVX (char fact, char uplo, int n, int nrhs, double *ap, double *afp, char equed, double *s, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, double *work, int *iwork)
 
int C_DPPTRF (char uplo, int n, double *ap)
 
int C_DPPTRI (char uplo, int n, double *ap)
 
int C_DPPTRS (char uplo, int n, int nrhs, double *ap, double *b, int ldb)
 
int C_DPTCON (int n, double *d, double *e, double anorm, double *rcond, double *work)
 
int C_DPTEQR (char compz, int n, double *d, double *e, double *z, int ldz, double *work)
 
int C_DPTRFS (int n, int nrhs, double *d, double *e, double *df, double *ef, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, double *work)
 
int C_DPTSV (int n, int nrhs, double *d, double *e, double *b, int ldb)
 
int C_DPTSVX (char fact, int n, int nrhs, double *d, double *e, double *df, double *ef, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, double *work)
 
int C_DPTTRF (int n, double *d, double *e)
 
int C_DPTTRS (int n, int nrhs, double *d, double *e, double *b, int ldb)
 
int C_DSBEV (char jobz, char uplo, int n, int kd, double *ab, int ldab, double *w, double *z, int ldz, double *work)
 
int C_DSBEVD (char jobz, char uplo, int n, int kd, double *ab, int ldab, double *w, double *z, int ldz, double *work, int lwork, int *iwork, int liwork)
 
int C_DSBEVX (char jobz, char range, char uplo, int n, int kd, double *ab, int ldab, double *q, int ldq, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, double *work, int *iwork, int *ifail)
 
int C_DSBGST (char vect, char uplo, int n, int ka, int kb, double *ab, int ldab, double *bb, int ldbb, double *x, int ldx, double *work)
 
int C_DSBGV (char jobz, char uplo, int n, int ka, int kb, double *ab, int ldab, double *bb, int ldbb, double *w, double *z, int ldz, double *work)
 
int C_DSBGVD (char jobz, char uplo, int n, int ka, int kb, double *ab, int ldab, double *bb, int ldbb, double *w, double *z, int ldz, double *work, int lwork, int *iwork, int liwork)
 
int C_DSBGVX (char jobz, char range, char uplo, int n, int ka, int kb, double *ab, int ldab, double *bb, int ldbb, double *q, int ldq, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, double *work, int *iwork, int *ifail)
 
int C_DSBTRD (char vect, char uplo, int n, int kd, double *ab, int ldab, double *d, double *e, double *q, int ldq, double *work)
 
int C_DSGESV (int n, int nrhs, double *a, int lda, int *ipiv, double *b, int ldb, double *x, int ldx, double *work, int *iter)
 
int C_DSPCON (char uplo, int n, double *ap, int *ipiv, double anorm, double *rcond, double *work, int *iwork)
 
int C_DSPEV (char jobz, char uplo, int n, double *ap, double *w, double *z, int ldz, double *work)
 
int C_DSPEVD (char jobz, char uplo, int n, double *ap, double *w, double *z, int ldz, double *work, int lwork, int *iwork, int liwork)
 
int C_DSPEVX (char jobz, char range, char uplo, int n, double *ap, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, double *work, int *iwork, int *ifail)
 
int C_DSPGST (int itype, char uplo, int n, double *ap, double *bp)
 
int C_DSPGV (int itype, char jobz, char uplo, int n, double *ap, double *bp, double *w, double *z, int ldz, double *work)
 
int C_DSPGVD (int itype, char jobz, char uplo, int n, double *ap, double *bp, double *w, double *z, int ldz, double *work, int lwork, int *iwork, int liwork)
 
int C_DSPGVX (int itype, char jobz, char range, char uplo, int n, double *ap, double *bp, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, double *work, int *iwork, int *ifail)
 
int C_DSPRFS (char uplo, int n, int nrhs, double *ap, double *afp, int *ipiv, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, double *work, int *iwork)
 
int C_DSPSV (char uplo, int n, int nrhs, double *ap, int *ipiv, double *b, int ldb)
 
int C_DSPSVX (char fact, char uplo, int n, int nrhs, double *ap, double *afp, int *ipiv, double *b, int ldb, double *x, int ldx, double *rcond)
 
int C_DSPTRD (char uplo, int n, double *ap, double *d, double *e, double *tau)
 
int C_DSPTRF (char uplo, int n, double *ap, int *ipiv)
 
int C_DSPTRI (char uplo, int n, double *ap, int *ipiv, double *work)
 
int C_DSPTRS (char uplo, int n, int nrhs, double *ap, int *ipiv, double *b, int ldb)
 
int C_DSTEBZ (char range, char order, int n, double vl, double vu, int il, int iu, double abstol, double *d, double *e, int *m, int *nsplit, double *w, int *iblock, int *isplit, double *work, int *iwork)
 
int C_DSTEDC (char compz, int n, double *d, double *e, double *z, int ldz, double *work, int lwork, int *iwork, int liwork)
 
int C_DSTEGR (char jobz, char range, int n, double *d, double *e, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, int *isuppz, double *work, int lwork, int *iwork, int liwork)
 
int C_DSTEIN (int n, double *d, double *e, int m, double *w, int *iblock, int *isplit, double *z, int ldz, double *work, int *iwork, int *ifail)
 
int C_DSTEQR (char compz, int n, double *d, double *e, double *z, int ldz, double *work)
 
int C_DSTERF (int n, double *d, double *e)
 
int C_DSTEV (char jobz, int n, double *d, double *e, double *z, int ldz, double *work)
 
int C_DSTEVD (char jobz, int n, double *d, double *e, double *z, int ldz, double *work, int lwork, int *iwork, int liwork)
 
int C_DSTEVR (char jobz, char range, int n, double *d, double *e, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, int *isuppz, double *work, int lwork, int *iwork, int liwork)
 
int C_DSTEVX (char jobz, char range, int n, double *d, double *e, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, double *work, int *iwork, int *ifail)
 
int C_DSYCON (char uplo, int n, double *a, int lda, int *ipiv, double anorm, double *rcond, double *work, int *iwork)
 
PSI_API int C_DSYEVD (char jobz, char uplo, int n, double *a, int lda, double *w, double *work, int lwork, int *iwork, int liwork)
 
int C_DSYEVR (char jobz, char range, char uplo, int n, double *a, int lda, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, int *isuppz, double *work, int lwork, int *iwork, int liwork)
 
int C_DSYEVX (char jobz, char range, char uplo, int n, double *a, int lda, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, double *work, int lwork, int *iwork, int *ifail)
 
int C_DSYGST (int itype, char uplo, int n, double *a, int lda, double *b, int ldb)
 
PSI_API int C_DSYGV (int itype, char jobz, char uplo, int n, double *a, int lda, double *b, int ldb, double *w, double *work, int lwork)
 
int C_DSYGVD (int itype, char jobz, char uplo, int n, double *a, int lda, double *b, int ldb, double *w, double *work, int lwork, int *iwork, int liwork)
 
int C_DSYGVX (int itype, char jobz, char range, char uplo, int n, double *a, int lda, double *b, int ldb, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, double *work, int lwork, int *iwork, int *ifail)
 
int C_DSYRFS (char uplo, int n, int nrhs, double *a, int lda, double *af, int ldaf, int *ipiv, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, double *work, int *iwork)
 
int C_DSYSV (char uplo, int n, int nrhs, double *a, int lda, int *ipiv, double *b, int ldb, double *work, int lwork)
 
int C_DSYSVX (char fact, char uplo, int n, int nrhs, double *a, int lda, double *af, int ldaf, int *ipiv, double *b, int ldb, double *x, int ldx, double *rcond)
 
int C_DSYTRD (char uplo, int n, double *a, int lda, double *d, double *e, double *tau, double *work, int lwork)
 
int C_DSYTRF (char uplo, int n, double *a, int lda, int *ipiv, double *work, int lwork)
 
int C_DSYTRI (char uplo, int n, double *a, int lda, int *ipiv, double *work)
 
int C_DSYTRS (char uplo, int n, int nrhs, double *a, int lda, int *ipiv, double *b, int ldb)
 
int C_DTBCON (char norm, char uplo, char diag, int n, int kd, double *ab, int ldab, double *rcond, double *work, int *iwork)
 
int C_DTBRFS (char uplo, char trans, char diag, int n, int kd, int nrhs, double *ab, int ldab, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, double *work, int *iwork)
 
int C_DTBTRS (char uplo, char trans, char diag, int n, int kd, int nrhs, double *ab, int ldab, double *b, int ldb)
 
int C_DTGEVC (char side, char howmny, int n, double *s, int lds, double *p, int ldp, double *vl, int ldvl, double *vr, int ldvr, int mm, int *m, double *work)
 
int C_DTGEXC (int n, double *a, int lda, double *b, int ldb, double *q, int ldq, double *z, int ldz, int *ifst, int *ilst, double *work, int lwork)
 
int C_DTGSEN (int ijob, int n, double *a, int lda, double *b, int ldb, double *alphar, double *alphai, double *beta, double *q, int ldq, double *z, int ldz, int *m, double *pl, double *pr, double *dif, double *work, int lwork, int *iwork, int liwork)
 
int C_DTGSJA (char jobu, char jobv, char jobq, int m, int p, int n, int k, int l, double *a, int lda, double *b, int ldb, double tola, double tolb, double *alpha, double *beta, double *u, int ldu, double *v, int ldv, double *q, int ldq, double *work, int *ncycle)
 
int C_DTGSNA (char job, char howmny, int n, double *a, int lda, double *b, int ldb, double *vl, int ldvl, double *vr, int ldvr, double *s, double *dif, int mm, int *m, double *work, int lwork, int *iwork)
 
int C_DTGSYL (char trans, int ijob, int m, int n, double *a, int lda, double *b, int ldb, double *c, int ldc, double *d, int ldd, double *e, int lde, double *f, int ldf, double *dif, double *scale, double *work, int lwork, int *iwork)
 
int C_DTPCON (char norm, char uplo, char diag, int n, double *ap, double *rcond, double *work, int *iwork)
 
int C_DTPRFS (char uplo, char trans, char diag, int n, int nrhs, double *ap, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, double *work, int *iwork)
 
int C_DTPTRI (char uplo, char diag, int n, double *ap)
 
int C_DTPTRS (char uplo, char trans, char diag, int n, int nrhs, double *ap, double *b, int ldb)
 
int C_DTRCON (char norm, char uplo, char diag, int n, double *a, int lda, double *rcond, double *work, int *iwork)
 
int C_DTREVC (char side, char howmny, int n, double *t, int ldt, double *vl, int ldvl, double *vr, int ldvr, int mm, int *m, double *work)
 
int C_DTREXC (char compq, int n, double *t, int ldt, double *q, int ldq, int *ifst, int *ilst, double *work)
 
int C_DTRRFS (char uplo, char trans, char diag, int n, int nrhs, double *a, int lda, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, double *work, int *iwork)
 
int C_DTRSEN (char job, char compq, int n, double *t, int ldt, double *q, int ldq, double *wr, double *wi, int *m, double *s, double *sep, double *work, int lwork, int *iwork, int liwork)
 
int C_DTRSNA (char job, char howmny, int n, double *t, int ldt, double *vl, int ldvl, double *vr, int ldvr, double *s, double *sep, int mm, int *m, double *work, int ldwork, int *iwork)
 
int C_DTRSYL (char trana, char tranb, int isgn, int m, int n, double *a, int lda, double *b, int ldb, double *c, int ldc, double *scale)
 
int C_DTRTRI (char uplo, char diag, int n, double *a, int lda)
 
int C_DTRTRS (char uplo, char trans, char diag, int n, int nrhs, double *a, int lda, double *b, int ldb)
 
int C_DTZRQF (int m, int n, double *a, int lda, double *tau)
 
int C_DTZRZF (int m, int n, double *a, int lda, double *tau, double *work, int lwork)
 
void stringset_init (StringSet *stringset, int size, int nelec, int ndrc, short int *frozen_occ)
 
void stringset_delete (StringSet *stringset)
 
void stringset_add (StringSet *stringset, int index, unsigned char *Occ)
 
void stringset_write (size_t unit, const char *prefix, StringSet *sset)
 
void stringset_read (size_t unit, const char *prefix, StringSet **sset)
 
void stringset_reindex (StringSet *stringset, short int *mo_map)
 
void slaterdetset_init (SlaterDetSet *sdset, int size, StringSet *alphastrings, StringSet *betastrings)
 
void slaterdetset_delete (SlaterDetSet *sdset)
 
void slaterdetset_delete_full (SlaterDetSet *sdset)
 
void slaterdetset_add (SlaterDetSet *sdset, int index, int alphastring, int betastring)
 
void slaterdetset_write (size_t unit, const char *prefix, SlaterDetSet *sdset)
 
void slaterdetset_read (size_t unit, const char *prefix, SlaterDetSet **sdset)
 
void slaterdetvector_init (SlaterDetVector *sdvector, SlaterDetSet *sdset)
 
void slaterdetvector_delete (SlaterDetVector *sdvector)
 
void slaterdetvector_delete_full (SlaterDetVector *sdvector)
 
void slaterdetvector_set (SlaterDetVector *sdvector, double *coeffs)
 
void slaterdetvector_write (size_t unit, const char *prefix, SlaterDetVector *vector)
 
void slaterdetset_write_vect (size_t unit, const char *prefix, double *coeffs, int size, int vectnum)
 
void slaterdetvector_read (size_t unit, const char *prefix, SlaterDetVector **vector)
 
void slaterdetset_read_vect (size_t unit, const char *prefix, double *coeffs, int size, int vectnum)
 
void print_timer (const Timer_Structure &timer, std::shared_ptr< PsiOutStream > printer, int align_key_width)
 
void print_nested_timer (const Timer_Structure &timer, std::shared_ptr< PsiOutStream > printer, const std::string &indent)
 
bool empty_parallel ()
 
template<class DPDFunctor , class FockFunctor >
void iwl_integrals (IWL *iwl, DPDFunctor &dpd, FockFunctor &fock)
 
void psiclean ()
 
int ** compute_atom_map (const Molecule *molecule, double tol, bool suppress_mol_print_in_exc)
 
int ** compute_atom_map (const std::shared_ptr< Molecule > &molecule, double tol, bool suppress_mol_print_in_exc)
 
void delete_atom_map (int **atom_map, const Molecule *molecule)
 
void delete_atom_map (int **atom_map, const std::shared_ptr< Molecule > &molecule)
 

Variables

char * psi_file_prefix
 
std::string outfile_name
 
std::string restart_id
 
std::shared_ptr< PsiOutStreamoutfile
 
std::time_t time_start
 
std::time_t time_end
 
std::time_t time_start_overall
 
int running = 0
 
double user_start
 
double sys_start
 
double user_start_overall
 
double sys_start_overall
 
double user_stop
 
double sys_stop
 
const double RvdW_D1_ []
 
const double C6_D1_ []
 
const double RvdW_D2_ []
 
const double C6_D2_ []
 
const double R_cov_ []
 
const double C6_Das2009_ []
 
const double C8_Das2009_ []
 
const double Beta_Das2009_ []
 
const double A_Das2009_ []
 
const double C6_Das2010_ []
 
const double C8_Das2010_ []
 
const double Beta_Das2010_ []
 
double R_0_AB_ []
 
dpd_gbl dpd_main
 
PSI_API DPDglobal_dpd_ = nullptr
 
PSI_API int dpd_default = 0
 
DPDdpd_list [2] = {nullptr, nullptr}
 
const double SMALL = 1.0E-7
 
const int TAYLOR_CUT = 5
 
size_t counter
 
std::smatch reMatches_
 
const std::string RotorTypeList [] = {"ASYMMETRIC_TOP", "SYMMETRIC_TOP", "SPHERICAL_TOP", "LINEAR", "ATOM"}
 
const std::string FullPointGroupList []
 
const char * labels [] = {" E ", "C2z", "C2y", "C2x", " i ", "Sxy", "Sxz", "Syz", " E "}
 
class PSI_API CharacterTable
 
ModelSpacemodel_space
 
MOInfoSCFmoinfo_scf = nullptr
 
class PSI_API Data
 
const std::string empty_
 
PSI_API psio_address PSIO_ZERO = {0, 0}
 
std::shared_ptr< PSIO_default_psio_lib_
 
std::shared_ptr< PSIOManager_default_psio_manager_
 
int nmo
 
int nso
 
int nao
 
double ** scf
 
double ** u
 
std::shared_ptr< Moleculemolecule
 
std::shared_ptr< BasisSetbasis
 
std::shared_ptr< Wavefunctionwfn
 
Timer_Structure root_timer (nullptr,"")
 
Timer_Structure parallel_timer (nullptr,"")
 
std::list< Timer_Structure * > ser_on_timers
 
std::vector< std::list
< Timer_Structure * > > 
par_on_timers
 
std::time_t timer_start
 
std::time_t timer_end
 
bool skip_timers
 
static omp_lock_t lock_timer
 

Detailed Description

This is all defined in python.cc initialize.

AEL() computes the approximate excitation level according to Stanton and Bartlett, JCP, 98, 1993, 7034. Trace [rho(excited) - rho(ground)] = AEL where both densities are expressed in the basis that diagonalizes the ground-state CCSD density. I was never able to get these results to agree with those of JFS or the current ACES2 so I'm not going to use this right now. –RAK

Standard library includes

Standard library includes Required PSI3 includes Required libmints includes

! This is a generalized second-order SCF module capable of computing the optimal orbital rotations at each macroiteration for RHF, RASSCF, and CASSCF.

Derived from the purple book Chapters 10.8.8,

Indices: mu, nu, sigma, ro - General AO indices mnopqrs - General MO indices ijkl - Occupied indices tuvw - Active indices abcd - Virtual indices

LibXC functional wrapper

psimath.h A set of wrappers to BLAS and LAPACK for use with Matrix, Vector, and IntVector Rob Parrish 1/25/2010

Typedef Documentation

using psi::clock = typedef std::chrono::high_resolution_clock
typedef short int psi::Label
typedef SharedWavefunction(* psi::plugin_t)(SharedWavefunction, Options &)
typedef int(* psi::read_options_t)(std::string, Options &)
typedef std::shared_ptr<GridBlock> psi::SharedGridBlock
using psi::SharedIntVector = typedef std::shared_ptr<IntVector>
typedef std::shared_ptr< Matrix > psi::SharedMatrix
using psi::SharedMolecule = typedef std::shared_ptr<Molecule>
typedef std::shared_ptr<OneBodyAOInt> psi::SharedOneBodyAOInt
typedef std::shared_ptr<OneBodySOInt> psi::SharedOneBodySOInt
typedef std::shared_ptr<TwoBodyAOInt> psi::SharedTwoBodyAOInt
typedef std::shared_ptr<TwoBodySOInt> psi::SharedTwoBodySOInt
typedef std::shared_ptr< Vector > psi::SharedVector
using psi::SharedWavefunction = typedef std::shared_ptr<Wavefunction>
typedef std::vector<std::pair<int, int> > psi::ShellPairBlock

SlaterDetSet is a set of Slater determinants

typedef std::vector<std::shared_ptr<MOSpace> > psi::SpaceVec
typedef std::vector<std::string> psi::strvec
typedef double psi::Value

Enumeration Type Documentation

Enumerator
XAxis 
YAxis 
ZAxis 
Enumerator
evals_only_ascending 
ascending 
evals_only_descending 
descending 
Enumerator
PG_ATOM 
PG_Cinfv 
PG_Dinfh 
PG_C1 
PG_Cs 
PG_Ci 
PG_Cn 
PG_Cnv 
PG_Cnh 
PG_Sn 
PG_Dn 
PG_Dnd 
PG_Dnh 
PG_Td 
PG_Oh 
PG_Ih 
Enumerator
Cartesian 
Pure 
Enumerator
ONEPOINT 
TWOPOINT 
Enumerator
pqrs 
pqsr 
prqs 
prsq 
psqr 
psrq 
qprs 
qpsr 
qrps 
qrsp 
qspr 
qsrp 
rqps 
rqsp 
rpqs 
rpsq 
rsqp 
rspq 
sqrp 
sqpr 
srqp 
srpq 
spqr 
sprq 
Enumerator
abc 
acb 
cab 
cba 
bca 
bac 
Enumerator
ABCD 
BACD 
ABDC 
BADC 
CDAB 
CDBA 
DCAB 
DCBA 
Enumerator
Normalized 
Unnormalized 
Enumerator
Success 
Failure 
Balk 
EndLoop 
Enumerator
AllRefs 
UniqueRefs 
ClosedShellRefs 
UniqueOpenShellRefs 
Enumerator
RT_ASYMMETRIC_TOP 
RT_SYMMETRIC_TOP 
RT_SPHERICAL_TOP 
RT_LINEAR 
RT_ATOM 
Enumerator
Gaussian 
ECPType1 
ECPType2 
Enumerator
OFF 
ON 
PARALLEL 

Function Documentation

template<class T >
void psi::_set_dfjk_options ( T *  jk,
Options options 
)
std::string psi::add_reference ( std::string &  str,
int  reference 
)
void psi::append_reference ( std::string &  str,
int  reference 
)
PSI_API void psi::arr_to_mat ( double **  a,
double *  b,
int  m,
int  n 
)
bool psi::atom_present_in_geom ( Matrix &  geom,
Vector3 &  b,
double  tol 
)
PSI_API void psi::balance ( double **  a,
int  n 
)
void psi::benchmark_blas1 ( int  N,
double  min_time 
)

Perform a benchmark traverse of BLAS 1 routines on the current hardware

Parameters
Nmaximum dimension exponent (requires ~ 3 (2^N x 2^N) double matrices
min_timeminimum amount of time to run each routine [s]
nthreadmaximum number of threads to use
void psi::benchmark_blas2 ( int  N,
double  min_time 
)

Perform a benchmark traverse of BLAS 2 routines on the current hardware

Parameters
Nmaximum dimension exponent (requires ~ 3 (2^N x 2^N) double matrices
min_timeminimum amount of time to run each routine [s]
nthreadmaximum number of threads to use
void psi::benchmark_blas3 ( int  N,
double  min_time,
int  nthread = 1 
)

Perform a benchmark traverse of BLAS 3 and LAPACK routines on the current hardware

Parameters
Nmaximum dimension exponent (requires ~ 4 (2^N x 2^N) double matrices
min_timeminimum amount of time to run each routine [s]
nthreadmaximum number of threads to use
void psi::benchmark_disk ( int  N,
double  min_time 
)

Perform a benchmark of PSIO disk performance on the current hardware

Parameters
Nmaximum dimension exponent (requires 1 (2^N x 2^N) double matrices
min_timeminimum amount of time to run each routine [s]
void psi::benchmark_integrals ( int  max_am,
double  min_time 
)

Perform a benchmark of psi integrals (of libmints type) on the current hardware All integrals will be called from different centers

Parameters
max_ammaximum am to consider
min_timeminimum time to run each shell combination of each integral type

Poisson Ints this_type = "2C Poisson"; this_ncenter = 2; std::shared_ptr<OneBodyAOInt> p2c(bbbb->poisson_overlap()); for (int P = 0, index = 0; P < max_shell; P++) { for (int Q = 0; Q < max_shell; Q++, index++) { T = 0.0; rounds = 0L; qq = new Timer(); while (T < min_time) { p2c->compute_shell(P, Q + max_shell); T = qq->get(); rounds++; } delete qq; t = T / (double) (rounds * n_per_combination[this_ncenter][index]); timings[this_type][index] = t; } }

void psi::benchmark_math ( double  min_time)

Perform a benchmark of common double floating point operations, including most of cmath

Parameters
min_timeminimum amount of time to run each routine [s]
PSI_API double ** psi::block_matrix ( size_t  n,
size_t  m,
bool  memlock 
)

block_matrix(): Allocate a 2D array of doubles using contiguous memory

Allocates a contiguous block of memory for an array of doubles, allocates an array of pointers to the beginning of each row and returns the pointer to the first row pointer. This allows transparent 2d-array style access, but keeps memory together such that the matrix could be used in conjunction with FORTRAN matrix routines.

Allocates memory for an n x m matrix and returns a pointer to the first row.

Parameters
n= number of rows (size_t to allow large matrices)
m= number of columns (size_t to allow large matrices)
memlock= optional bool indicating whether to lock memory into physical RAM or not, and available only where _POSIX_MEMLOCK is defined. Defaults to false if not specified.

Returns: double star pointer to newly allocated matrix

T. Daniel Crawford Sometime in 1994

Based on init_matrix() from libciomr

PSI_API void psi::block_to_tri ( double *  a,
double **  b,
int  num_ir,
int *  num_so,
int *  ioff 
)
double psi::bytes_to_MiB ( size_t  n)
int psi::C_DBDSDC ( char  uplo,
char  compq,
int  n,
double *  d,
double *  e,
double *  u,
int  ldu,
double *  vt,
int  ldvt,
double *  q,
int *  iq,
double *  work,
int *  iwork 
)
int psi::C_DBDSQR ( char  uplo,
int  n,
int  ncvt,
int  nru,
int  ncc,
double *  d,
double *  e,
double *  vt,
int  ldvt,
double *  u,
int  ldu,
double *  c,
int  ldc,
double *  work 
)
int psi::C_DDISNA ( char  job,
int  m,
int  n,
double *  d,
double *  sep 
)
int psi::C_DGBBRD ( char  vect,
int  m,
int  n,
int  ncc,
int  kl,
int  ku,
double *  ab,
int  ldab,
double *  d,
double *  e,
double *  q,
int  ldq,
double *  pt,
int  ldpt,
double *  c,
int  ldc,
double *  work 
)
int psi::C_DGBCON ( char  norm,
int  n,
int  kl,
int  ku,
double *  ab,
int  ldab,
int *  ipiv,
double  anorm,
double *  rcond,
double *  work,
int *  iwork 
)
int psi::C_DGBEQU ( int  m,
int  n,
int  kl,
int  ku,
double *  ab,
int  ldab,
double *  r,
double *  c,
double *  rowcnd,
double *  colcnd,
double *  amax 
)
void psi::C_DGBMV ( char  trans,
int  m,
int  n,
int  kl,
int  ku,
double  alpha,
double *  a,
int  lda,
double *  x,
int  incx,
double  beta,
double *  y,
int  incy 
)

Purpose

DGBMV performs one of the matrix-vector operations

y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y,

where alpha and beta are scalars, x and y are vectors and A is an m by n band matrix, with kl sub-diagonals and ku super-diagonals.

Arguments

TRANS - CHARACTER*1. On entry, TRANS specifies the operation to be performed as follows:

TRANS = 'N' or 'n' y := alpha*A*x + beta*y.

TRANS = 'T' or 't' y := alpha*A'*x + beta*y.

TRANS = 'C' or 'c' y := alpha*A'*x + beta*y.

Unchanged on exit.

M - INTEGER. On entry, M specifies the number of rows of the matrix A. M must be at least zero. Unchanged on exit.

N - INTEGER. On entry, N specifies the number of columns of the matrix A. N must be at least zero. Unchanged on exit.

KL - INTEGER. On entry, KL specifies the number of sub-diagonals of the matrix A. KL must satisfy 0 .le. KL. Unchanged on exit.

KU - INTEGER. On entry, KU specifies the number of super-diagonals of the matrix A. KU must satisfy 0 .le. KU. Unchanged on exit.

ALPHA - DOUBLE PRECISION. On entry, ALPHA specifies the scalar alpha. Unchanged on exit.

A - DOUBLE PRECISION array of DIMENSION ( LDA, n ). Before entry, the leading ( kl + ku + 1 ) by n part of the array A must contain the matrix of coefficients, supplied column by column, with the leading diagonal of the matrix in row ( ku + 1 ) of the array, the first super-diagonal starting at position 2 in row ku, the first sub-diagonal starting at position 1 in row ( ku + 2 ), and so on. Elements in the array A that do not correspond to elements in the band matrix (such as the top left ku by ku triangle) are not referenced. The following program segment will transfer a band matrix from conventional full matrix storage to band storage:

  DO 20, J = 1, N
     K = KU + 1 - J
     DO 10, I = MAX( 1, J - KU ), MIN( M, J + KL )
        A( K + I, J ) = matrix( I, J )

10 CONTINUE 20 CONTINUE

Unchanged on exit.

LDA - INTEGER. On entry, LDA specifies the first dimension of A as declared in the calling (sub) program. LDA must be at least ( kl + ku + 1 ). Unchanged on exit.

X - DOUBLE PRECISION array of DIMENSION at least ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n' and at least ( 1 + ( m - 1 )*abs( INCX ) ) otherwise. Before entry, the incremented array X must contain the vector x. Unchanged on exit.

INCX - INTEGER. On entry, INCX specifies the increment for the elements of X. INCX must not be zero. Unchanged on exit.

BETA - DOUBLE PRECISION. On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input. Unchanged on exit.

Y - DOUBLE PRECISION array of DIMENSION at least ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n' and at least ( 1 + ( n - 1 )*abs( INCY ) ) otherwise. Before entry, the incremented array Y must contain the vector y. On exit, Y is overwritten by the updated vector y.

INCY - INTEGER. On entry, INCY specifies the increment for the elements of Y. INCY must not be zero. Unchanged on exit.

Level 2 Blas routine.

– Written on 22-October-1986. Jack Dongarra, Argonne National Lab. Jeremy Du Croz, Nag Central Office. Sven Hammarling, Nag Central Office. Richard Hanson, Sandia National Labs.

.. Parameters ..

int psi::C_DGBRFS ( char  trans,
int  n,
int  kl,
int  ku,
int  nrhs,
double *  ab,
int  ldab,
double *  afb,
int  ldafb,
int *  ipiv,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  ferr,
double *  berr,
double *  work,
int *  iwork 
)
int psi::C_DGBSV ( int  n,
int  kl,
int  ku,
int  nrhs,
double *  ab,
int  ldab,
int *  ipiv,
double *  b,
int  ldb 
)
int psi::C_DGBSVX ( char  fact,
char  trans,
int  n,
int  kl,
int  ku,
int  nrhs,
double *  ab,
int  ldab,
double *  afb,
int  ldafb,
int *  ipiv,
char  equed,
double *  r,
double *  c,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  rcond,
double *  ferr,
double *  berr,
double *  work,
int *  iwork 
)
int psi::C_DGBTRF ( int  m,
int  n,
int  kl,
int  ku,
double *  ab,
int  ldab,
int *  ipiv 
)
int psi::C_DGBTRS ( char  trans,
int  n,
int  kl,
int  ku,
int  nrhs,
double *  ab,
int  ldab,
int *  ipiv,
double *  b,
int  ldb 
)
int psi::C_DGEBAK ( char  job,
char  side,
int  n,
int  ilo,
int  ihi,
double *  scale,
int  m,
double *  v,
int  ldv 
)
int psi::C_DGEBAL ( char  job,
int  n,
double *  a,
int  lda,
int *  ilo,
int *  ihi,
double *  scale 
)
int psi::C_DGEBRD ( int  m,
int  n,
double *  a,
int  lda,
double *  d,
double *  e,
double *  tauq,
double *  taup,
double *  work,
int  lwork 
)
int psi::C_DGECON ( char  norm,
int  n,
double *  a,
int  lda,
double  anorm,
double *  rcond,
double *  work,
int *  iwork 
)
int psi::C_DGEEQU ( int  m,
int  n,
double *  a,
int  lda,
double *  r,
double *  c,
double *  rowcnd,
double *  colcnd,
double *  amax 
)
int psi::C_DGEES ( char  jobvs,
char  sort,
int  n,
double *  a,
int  lda,
int *  sdim,
double *  wr,
double *  wi,
double *  vs,
int  ldvs,
double *  work,
int  lwork 
)
int psi::C_DGEESX ( char  jobvs,
char  sort,
char  sense,
int  n,
double *  a,
int  lda,
int *  sdim,
double *  wr,
double *  wi,
double *  vs,
int  ldvs,
double *  rconde,
double *  rcondv,
double *  work,
int  lwork,
int *  iwork,
int  liwork 
)
int psi::C_DGEEV ( char  jobvl,
char  jobvr,
int  n,
double *  a,
int  lda,
double *  wr,
double *  wi,
double *  vl,
int  ldvl,
double *  vr,
int  ldvr,
double *  work,
int  lwork 
)
int psi::C_DGEEVX ( char  balanc,
char  jobvl,
char  jobvr,
char  sense,
int  n,
double *  a,
int  lda,
double *  wr,
double *  wi,
double *  vl,
int  ldvl,
double *  vr,
int  ldvr,
int *  ilo,
int *  ihi,
double *  scale,
double *  abnrm,
double *  rconde,
double *  rcondv,
double *  work,
int  lwork,
int *  iwork 
)
int psi::C_DGEGS ( char  jobvsl,
char  jobvsr,
int  n,
double *  a,
int  lda,
double *  b,
int  ldb,
double *  alphar,
double *  alphai,
double *  beta,
double *  vsl,
int  ldvsl,
double *  vsr,
int  ldvsr,
double *  work,
int  lwork 
)
int psi::C_DGEGV ( char  jobvl,
char  jobvr,
int  n,
double *  a,
int  lda,
double *  b,
int  ldb,
double *  alphar,
double *  alphai,
double *  beta,
double *  vl,
int  ldvl,
double *  vr,
int  ldvr,
double *  work,
int  lwork 
)
int psi::C_DGEHRD ( int  n,
int  ilo,
int  ihi,
double *  a,
int  lda,
double *  tau,
double *  work,
int  lwork 
)
int psi::C_DGELQF ( int  m,
int  n,
double *  a,
int  lda,
double *  tau,
double *  work,
int  lwork 
)
int psi::C_DGELS ( char  trans,
int  m,
int  n,
int  nrhs,
double *  a,
int  lda,
double *  b,
int  ldb,
double *  work,
int  lwork 
)
int psi::C_DGELSD ( int  m,
int  n,
int  nrhs,
double *  a,
int  lda,
double *  b,
int  ldb,
double *  s,
double  rcond,
int *  rank,
double *  work,
int  lwork,
int *  iwork 
)
int psi::C_DGELSS ( int  m,
int  n,
int  nrhs,
double *  a,
int  lda,
double *  b,
int  ldb,
double *  s,
double  rcond,
int *  rank,
double *  work,
int  lwork 
)
int psi::C_DGELSX ( int  m,
int  n,
int  nrhs,
double *  a,
int  lda,
double *  b,
int  ldb,
int *  jpvt,
double  rcond,
int *  rank,
double *  work 
)
int psi::C_DGELSY ( int  m,
int  n,
int  nrhs,
double *  a,
int  lda,
double *  b,
int  ldb,
int *  jpvt,
double  rcond,
int *  rank,
double *  work,
int  lwork 
)
PSI_API void psi::C_DGEMM ( char  transa,
char  transb,
int  m,
int  n,
int  k,
double  alpha,
double *  a,
int  lda,
double *  b,
int  ldb,
double  beta,
double *  c,
int  ldc 
)

Purpose

DGEMM performs one of the matrix-matrix operations

C := alpha*op( A )*op( B ) + beta*C,

where op( X ) is one of

op( X ) = X or op( X ) = X',

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

Arguments

TRANSA - CHARACTER*1. On entry, TRANSA specifies the form of op( A ) to be used in the matrix multiplication as follows:

TRANSA = 'N' or 'n', op( A ) = A.

TRANSA = 'T' or 't', op( A ) = A'.

TRANSA = 'C' or 'c', op( A ) = A'.

Unchanged on exit.

TRANSB - CHARACTER*1. On entry, TRANSB specifies the form of op( B ) to be used in the matrix multiplication as follows:

TRANSB = 'N' or 'n', op( B ) = B.

TRANSB = 'T' or 't', op( B ) = B'.

TRANSB = 'C' or 'c', op( B ) = B'.

Unchanged on exit.

M - INTEGER. On entry, M specifies the number of rows of the matrix op( A ) and of the matrix C. M must be at least zero. Unchanged on exit.

N - INTEGER. On entry, N specifies the number of columns of the matrix op( B ) and the number of columns of the matrix C. N must be at least zero. Unchanged on exit.

K - INTEGER. On entry, K specifies the number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). K must be at least zero. Unchanged on exit.

ALPHA - DOUBLE PRECISION. On entry, ALPHA specifies the scalar alpha. Unchanged on exit.

A - DOUBLE PRECISION array of DIMENSION ( LDA, ka ), where ka is k when TRANSA = 'N' or 'n', and is m otherwise. Before entry with TRANSA = 'N' or 'n', the leading m by k part of the array A must contain the matrix A, otherwise the leading k by m part of the array A must contain the matrix A. Unchanged on exit.

LDA - INTEGER. On entry, LDA specifies the first dimension of A as declared in the calling (sub) program. When TRANSA = 'N' or 'n' then LDA must be at least max( 1, m ), otherwise LDA must be at least max( 1, k ). Unchanged on exit.

B - DOUBLE PRECISION array of DIMENSION ( LDB, kb ), where kb is n when TRANSB = 'N' or 'n', and is k otherwise. Before entry with TRANSB = 'N' or 'n', the leading k by n part of the array B must contain the matrix B, otherwise the leading n by k part of the array B must contain the matrix B. Unchanged on exit.

LDB - INTEGER. On entry, LDB specifies the first dimension of B as declared in the calling (sub) program. When TRANSB = 'N' or 'n' then LDB must be at least max( 1, k ), otherwise LDB must be at least max( 1, n ). Unchanged on exit.

BETA - DOUBLE PRECISION. On entry, BETA specifies the scalar beta. When BETA is supplied as zero then C need not be set on input. Unchanged on exit.

C - DOUBLE PRECISION array of DIMENSION ( LDC, n ). Before entry, the leading m by n part of the array C must contain the matrix C, except when beta is zero, in which case C need not be set on entry. On exit, the array C is overwritten by the m by n matrix ( alpha*op( A )*op( B ) + beta*C ).

LDC - INTEGER. On entry, LDC specifies the first dimension of C as declared in the calling (sub) program. LDC must be at least max( 1, m ). Unchanged on exit.

Level 3 Blas routine.

– Written on 8-February-1989. Jack Dongarra, Argonne National Laboratory. Iain Duff, AERE Harwell. Jeremy Du Croz, Numerical Algorithms Group Ltd. Sven Hammarling, Numerical Algorithms Group Ltd.

.. External Functions ..

PSI_API void psi::C_DGEMV ( char  trans,
int  m,
int  n,
double  alpha,
double *  a,
int  lda,
double *  x,
int  incx,
double  beta,
double *  y,
int  incy 
)

Purpose

DGEMV performs one of the matrix-vector operations

y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y,

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Arguments

TRANS - CHARACTER*1. On entry, TRANS specifies the operation to be performed as follows:

TRANS = 'N' or 'n' y := alpha*A*x + beta*y.

TRANS = 'T' or 't' y := alpha*A'*x + beta*y.

TRANS = 'C' or 'c' y := alpha*A'*x + beta*y.

Unchanged on exit.

M - INTEGER. On entry, M specifies the number of rows of the matrix A. M must be at least zero. Unchanged on exit.

N - INTEGER. On entry, N specifies the number of columns of the matrix A. N must be at least zero. Unchanged on exit.

ALPHA - DOUBLE PRECISION. On entry, ALPHA specifies the scalar alpha. Unchanged on exit.

A - DOUBLE PRECISION array of DIMENSION ( LDA, n ). Before entry, the leading m by n part of the array A must contain the matrix of coefficients. Unchanged on exit.

LDA - INTEGER. On entry, LDA specifies the first dimension of A as declared in the calling (sub) program. LDA must be at least max( 1, m ). Unchanged on exit.

X - DOUBLE PRECISION array of DIMENSION at least ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n' and at least ( 1 + ( m - 1 )*abs( INCX ) ) otherwise. Before entry, the incremented array X must contain the vector x. Unchanged on exit.

INCX - INTEGER. On entry, INCX specifies the increment for the elements of X. INCX must not be zero. Unchanged on exit.

BETA - DOUBLE PRECISION. On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input. Unchanged on exit.

Y - DOUBLE PRECISION array of DIMENSION at least ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n' and at least ( 1 + ( n - 1 )*abs( INCY ) ) otherwise. Before entry with BETA non-zero, the incremented array Y must contain the vector y. On exit, Y is overwritten by the updated vector y.

INCY - INTEGER. On entry, INCY specifies the increment for the elements of Y. INCY must not be zero. Unchanged on exit.

Level 2 Blas routine.

– Written on 22-October-1986. Jack Dongarra, Argonne National Lab. Jeremy Du Croz, Nag Central Office. Sven Hammarling, Nag Central Office. Richard Hanson, Sandia National Labs.

.. Parameters ..

int psi::C_DGEQLF ( int  m,
int  n,
double *  a,
int  lda,
double *  tau,
double *  work,
int  lwork 
)
int psi::C_DGEQP3 ( int  m,
int  n,
double *  a,
int  lda,
int *  jpvt,
double *  tau,
double *  work,
int  lwork 
)
int psi::C_DGEQPF ( int  m,
int  n,
double *  a,
int  lda,
int *  jpvt,
double *  tau,
double *  work 
)
int psi::C_DGEQRF ( int  m,
int  n,
double *  a,
int  lda,
double *  tau,
double *  work,
int  lwork 
)
PSI_API void psi::C_DGER ( int  m,
int  n,
double  alpha,
double *  x,
int  incx,
double *  y,
int  incy,
double *  a,
int  lda 
)

Purpose

DGER performs the rank 1 operation

A := alpha*x*y' + A,

where alpha is a scalar, x is an m element vector, y is an n element vector and A is an m by n matrix.

Arguments

M - INTEGER. On entry, M specifies the number of rows of the matrix A. M must be at least zero. Unchanged on exit.

N - INTEGER. On entry, N specifies the number of columns of the matrix A. N must be at least zero. Unchanged on exit.

ALPHA - DOUBLE PRECISION. On entry, ALPHA specifies the scalar alpha. Unchanged on exit.

X - DOUBLE PRECISION array of dimension at least ( 1 + ( m - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the m element vector x. Unchanged on exit.

INCX - INTEGER. On entry, INCX specifies the increment for the elements of X. INCX must not be zero. Unchanged on exit.

Y - DOUBLE PRECISION array of dimension at least ( 1 + ( n - 1 )*abs( INCY ) ). Before entry, the incremented array Y must contain the n element vector y. Unchanged on exit.

INCY - INTEGER. On entry, INCY specifies the increment for the elements of Y. INCY must not be zero. Unchanged on exit.

A - DOUBLE PRECISION array of DIMENSION ( LDA, n ). Before entry, the leading m by n part of the array A must contain the matrix of coefficients. On exit, A is overwritten by the updated matrix.

LDA - INTEGER. On entry, LDA specifies the first dimension of A as declared in the calling (sub) program. LDA must be at least max( 1, m ). Unchanged on exit.

Level 2 Blas routine.

– Written on 22-October-1986. Jack Dongarra, Argonne National Lab. Jeremy Du Croz, Nag Central Office. Sven Hammarling, Nag Central Office. Richard Hanson, Sandia National Labs.

.. Parameters ..

int psi::C_DGERFS ( char  trans,
int  n,
int  nrhs,
double *  a,
int  lda,
double *  af,
int  ldaf,
int *  ipiv,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  ferr,
double *  berr,
double *  work,
int *  iwork 
)
int psi::C_DGERQF ( int  m,
int  n,
double *  a,
int  lda,
double *  tau,
double *  work,
int  lwork 
)
int psi::C_DGESDD ( char  jobz,
int  m,
int  n,
double *  a,
int  lda,
double *  s,
double *  u,
int  ldu,
double *  vt,
int  ldvt,
double *  work,
int  lwork,
int *  iwork 
)
int psi::C_DGESVX ( char  fact,
char  trans,
int  n,
int  nrhs,
double *  a,
int  lda,
double *  af,
int  ldaf,
int *  ipiv,
char  equed,
double *  r,
double *  c,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  rcond,
double *  ferr,
double *  berr,
double *  work,
int *  iwork 
)
int psi::C_DGETRS ( char  trans,
int  n,
int  nrhs,
double *  a,
int  lda,
int *  ipiv,
double *  b,
int  ldb 
)
int psi::C_DGGBAK ( char  job,
char  side,
int  n,
int  ilo,
int  ihi,
double *  lscale,
double *  rscale,
int  m,
double *  v,
int  ldv 
)
int psi::C_DGGBAL ( char  job,
int  n,
double *  a,
int  lda,
double *  b,
int  ldb,
int *  ilo,
int *  ihi,
double *  lscale,
double *  rscale,
double *  work 
)
int psi::C_DGGES ( char  jobvsl,
char  jobvsr,
char  sort,
int  n,
double *  a,
int  lda,
double *  b,
int  ldb,
int *  sdim,
double *  alphar,
double *  alphai,
double *  beta,
double *  vsl,
int  ldvsl,
double *  vsr,
int  ldvsr,
double *  work,
int  lwork 
)
int psi::C_DGGESX ( char  jobvsl,
char  jobvsr,
char  sort,
char  sense,
int  n,
double *  a,
int  lda,
double *  b,
int  ldb,
int *  sdim,
double *  alphar,
double *  alphai,
double *  beta,
double *  vsl,
int  ldvsl,
double *  vsr,
int  ldvsr,
double *  rconde,
double *  rcondv,
double *  work,
int  lwork,
int *  iwork,
int  liwork 
)
PSI_API int psi::C_DGGEV ( char  jobvl,
char  jobvr,
int  n,
double *  a,
int  lda,
double *  b,
int  ldb,
double *  alphar,
double *  alphai,
double *  beta,
double *  vl,
int  ldvl,
double *  vr,
int  ldvr,
double *  work,
int  lwork 
)
int psi::C_DGGEVX ( char  balanc,
char  jobvl,
char  jobvr,
char  sense,
int  n,
double *  a,
int  lda,
double *  b,
int  ldb,
double *  alphar,
double *  alphai,
double *  beta,
double *  vl,
int  ldvl,
double *  vr,
int  ldvr,
int *  ilo,
int *  ihi,
double *  lscale,
double *  rscale,
double *  abnrm,
double *  bbnrm,
double *  rconde,
double *  rcondv,
double *  work,
int  lwork,
int *  iwork 
)
int psi::C_DGGGLM ( int  n,
int  m,
int  p,
double *  a,
int  lda,
double *  b,
int  ldb,
double *  d,
double *  x,
double *  y,
double *  work,
int  lwork 
)
int psi::C_DGGHRD ( char  compq,
char  compz,
int  n,
int  ilo,
int  ihi,
double *  a,
int  lda,
double *  b,
int  ldb,
double *  q,
int  ldq,
double *  z,
int  ldz 
)
int psi::C_DGGLSE ( int  m,
int  n,
int  p,
double *  a,
int  lda,
double *  b,
int  ldb,
double *  c,
double *  d,
double *  x,
double *  work,
int  lwork 
)
int psi::C_DGGQRF ( int  n,
int  m,
int  p,
double *  a,
int  lda,
double *  taua,
double *  b,
int  ldb,
double *  taub,
double *  work,
int  lwork 
)
int psi::C_DGGRQF ( int  m,
int  p,
int  n,
double *  a,
int  lda,
double *  taua,
double *  b,
int  ldb,
double *  taub,
double *  work,
int  lwork 
)
int psi::C_DGGSVD ( char  jobu,
char  jobv,
char  jobq,
int  m,
int  n,
int  p,
int *  k,
int *  l,
double *  a,
int  lda,
double *  b,
int  ldb,
double *  alpha,
double *  beta,
double *  u,
int  ldu,
double *  v,
int  ldv,
double *  q,
int  ldq,
double *  work,
int *  iwork 
)
int psi::C_DGGSVP ( char  jobu,
char  jobv,
char  jobq,
int  m,
int  p,
int  n,
double *  a,
int  lda,
double *  b,
int  ldb,
double  tola,
double  tolb,
int *  k,
int *  l,
double *  u,
int  ldu,
double *  v,
int  ldv,
double *  q,
int  ldq,
int *  iwork,
double *  tau,
double *  work 
)
int psi::C_DGTCON ( char  norm,
int  n,
double *  dl,
double *  d,
double *  du,
double *  du2,
int *  ipiv,
double  anorm,
double *  rcond,
double *  work,
int *  iwork 
)
int psi::C_DGTRFS ( char  trans,
int  n,
int  nrhs,
double *  dl,
double *  d,
double *  du,
double *  dlf,
double *  df,
double *  duf,
double *  du2,
int *  ipiv,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  ferr,
double *  berr,
double *  work,
int *  iwork 
)
int psi::C_DGTSV ( int  n,
int  nrhs,
double *  dl,
double *  d,
double *  du,
double *  b,
int  ldb 
)
int psi::C_DGTSVX ( char  fact,
char  trans,
int  n,
int  nrhs,
double *  dl,
double *  d,
double *  du,
double *  dlf,
double *  df,
double *  duf,
double *  du2,
int *  ipiv,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  rcond 
)
int psi::C_DGTTRF ( int  n,
double *  dl,
double *  d,
double *  du,
double *  du2,
int *  ipiv 
)
int psi::C_DGTTRS ( char  trans,
int  n,
int  nrhs,
double *  dl,
double *  d,
double *  du,
double *  du2,
int *  ipiv,
double *  b,
int  ldb 
)
int psi::C_DHGEQZ ( char  job,
char  compq,
char  compz,
int  n,
int  ilo,
int  ihi,
double *  h,
int  ldh,
double *  t,
int  ldt,
double *  alphar,
double *  alphai,
double *  beta,
double *  q,
int  ldq,
double *  z,
int  ldz,
double *  work,
int  lwork 
)
int psi::C_DHSEIN ( char  side,
char  eigsrc,
char  initv,
int  n,
double *  h,
int  ldh,
double *  wr,
double *  wi,
double *  vl,
int  ldvl,
double *  vr,
int  ldvr,
int  mm,
int *  m,
double *  work,
int *  ifaill,
int *  ifailr 
)
int psi::C_DHSEQR ( char  job,
char  compz,
int  n,
int  ilo,
int  ihi,
double *  h,
int  ldh,
double *  wr,
double *  wi,
double *  z,
int  ldz,
double *  work,
int  lwork 
)
int psi::C_DOPGTR ( char  uplo,
int  n,
double *  ap,
double *  tau,
double *  q,
int  ldq,
double *  work 
)
int psi::C_DOPMTR ( char  side,
char  uplo,
char  trans,
int  m,
int  n,
double *  ap,
double *  tau,
double *  c,
int  ldc,
double *  work 
)
int psi::C_DORGBR ( char  vect,
int  m,
int  n,
int  k,
double *  a,
int  lda,
double *  tau,
double *  work,
int  lwork 
)
int psi::C_DORGHR ( int  n,
int  ilo,
int  ihi,
double *  a,
int  lda,
double *  tau,
double *  work,
int  lwork 
)
int psi::C_DORGLQ ( int  m,
int  n,
int  k,
double *  a,
int  lda,
double *  tau,
double *  work,
int  lwork 
)
int psi::C_DORGQL ( int  m,
int  n,
int  k,
double *  a,
int  lda,
double *  tau,
double *  work,
int  lwork 
)
int psi::C_DORGQR ( int  m,
int  n,
int  k,
double *  a,
int  lda,
double *  tau,
double *  work,
int  lwork 
)
int psi::C_DORGRQ ( int  m,
int  n,
int  k,
double *  a,
int  lda,
double *  tau,
double *  work,
int  lwork 
)
int psi::C_DORGTR ( char  uplo,
int  n,
double *  a,
int  lda,
double *  tau,
double *  work,
int  lwork 
)
int psi::C_DORMBR ( char  vect,
char  side,
char  trans,
int  m,
int  n,
int  k,
double *  a,
int  lda,
double *  tau,
double *  c,
int  ldc,
double *  work,
int  lwork 
)
int psi::C_DORMHR ( char  side,
char  trans,
int  m,
int  n,
int  ilo,
int  ihi,
double *  a,
int  lda,
double *  tau,
double *  c,
int  ldc,
double *  work,
int  lwork 
)
int psi::C_DORMLQ ( char  side,
char  trans,
int  m,
int  n,
int  k,
double *  a,
int  lda,
double *  tau,
double *  c,
int  ldc,
double *  work,
int  lwork 
)
int psi::C_DORMQL ( char  side,
char  trans,
int  m,
int  n,
int  k,
double *  a,
int  lda,
double *  tau,
double *  c,
int  ldc,
double *  work,
int  lwork 
)
int psi::C_DORMQR ( char  side,
char  trans,
int  m,
int  n,
int  k,
double *  a,
int  lda,
double *  tau,
double *  c,
int  ldc,
double *  work,
int  lwork 
)
int psi::C_DORMR3 ( char  side,
char  trans,
int  m,
int  n,
int  k,
int  l,
double *  a,
int  lda,
double *  tau,
double *  c,
int  ldc,
double *  work 
)
int psi::C_DORMRQ ( char  side,
char  trans,
int  m,
int  n,
int  k,
double *  a,
int  lda,
double *  tau,
double *  c,
int  ldc,
double *  work,
int  lwork 
)
int psi::C_DORMRZ ( char  side,
char  trans,
int  m,
int  n,
int  k,
int  l,
double *  a,
int  lda,
double *  tau,
double *  c,
int  ldc,
double *  work,
int  lwork 
)
int psi::C_DORMTR ( char  side,
char  uplo,
char  trans,
int  m,
int  n,
double *  a,
int  lda,
double *  tau,
double *  c,
int  ldc,
double *  work,
int  lwork 
)
int psi::C_DPBCON ( char  uplo,
int  n,
int  kd,
double *  ab,
int  ldab,
double  anorm,
double *  rcond,
double *  work,
int *  iwork 
)
int psi::C_DPBEQU ( char  uplo,
int  n,
int  kd,
double *  ab,
int  ldab,
double *  s,
double *  scond,
double *  amax 
)
int psi::C_DPBRFS ( char  uplo,
int  n,
int  kd,
int  nrhs,
double *  ab,
int  ldab,
double *  afb,
int  ldafb,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  ferr,
double *  berr,
double *  work,
int *  iwork 
)
int psi::C_DPBSTF ( char  uplo,
int  n,
int  kd,
double *  ab,
int  ldab 
)
int psi::C_DPBSV ( char  uplo,
int  n,
int  kd,
int  nrhs,
double *  ab,
int  ldab,
double *  b,
int  ldb 
)
int psi::C_DPBSVX ( char  fact,
char  uplo,
int  n,
int  kd,
int  nrhs,
double *  ab,
int  ldab,
double *  afb,
int  ldafb,
char  equed,
double *  s,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  rcond,
double *  ferr,
double *  berr,
double *  work,
int *  iwork 
)
int psi::C_DPBTRF ( char  uplo,
int  n,
int  kd,
double *  ab,
int  ldab 
)
int psi::C_DPBTRS ( char  uplo,
int  n,
int  kd,
int  nrhs,
double *  ab,
int  ldab,
double *  b,
int  ldb 
)
int psi::C_DPOCON ( char  uplo,
int  n,
double *  a,
int  lda,
double  anorm,
double *  rcond,
double *  work,
int *  iwork 
)
int psi::C_DPOEQU ( int  n,
double *  a,
int  lda,
double *  s,
double *  scond,
double *  amax 
)
int psi::C_DPORFS ( char  uplo,
int  n,
int  nrhs,
double *  a,
int  lda,
double *  af,
int  ldaf,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  ferr,
double *  berr,
double *  work,
int *  iwork 
)
int psi::C_DPOSV ( char  uplo,
int  n,
int  nrhs,
double *  a,
int  lda,
double *  b,
int  ldb 
)
int psi::C_DPOSVX ( char  fact,
char  uplo,
int  n,
int  nrhs,
double *  a,
int  lda,
double *  af,
int  ldaf,
char  equed,
double *  s,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  rcond,
double *  ferr,
double *  berr,
double *  work,
int *  iwork 
)
int psi::C_DPPCON ( char  uplo,
int  n,
double *  ap,
double  anorm,
double *  rcond,
double *  work,
int *  iwork 
)
int psi::C_DPPEQU ( char  uplo,
int  n,
double *  ap,
double *  s,
double *  scond,
double *  amax 
)
int psi::C_DPPRFS ( char  uplo,
int  n,
int  nrhs,
double *  ap,
double *  afp,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  ferr,
double *  berr,
double *  work,
int *  iwork 
)
int psi::C_DPPSV ( char  uplo,
int  n,
int  nrhs,
double *  ap,
double *  b,
int  ldb 
)
int psi::C_DPPSVX ( char  fact,
char  uplo,
int  n,
int  nrhs,
double *  ap,
double *  afp,
char  equed,
double *  s,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  rcond,
double *  ferr,
double *  berr,
double *  work,
int *  iwork 
)
int psi::C_DPPTRF ( char  uplo,
int  n,
double *  ap 
)
int psi::C_DPPTRI ( char  uplo,
int  n,
double *  ap 
)
int psi::C_DPPTRS ( char  uplo,
int  n,
int  nrhs,
double *  ap,
double *  b,
int  ldb 
)
int psi::C_DPTCON ( int  n,
double *  d,
double *  e,
double  anorm,
double *  rcond,
double *  work 
)
int psi::C_DPTEQR ( char  compz,
int  n,
double *  d,
double *  e,
double *  z,
int  ldz,
double *  work 
)
int psi::C_DPTRFS ( int  n,
int  nrhs,
double *  d,
double *  e,
double *  df,
double *  ef,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  ferr,
double *  berr,
double *  work 
)
int psi::C_DPTSV ( int  n,
int  nrhs,
double *  d,
double *  e,
double *  b,
int  ldb 
)
int psi::C_DPTSVX ( char  fact,
int  n,
int  nrhs,
double *  d,
double *  e,
double *  df,
double *  ef,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  rcond,
double *  ferr,
double *  berr,
double *  work 
)
int psi::C_DPTTRF ( int  n,
double *  d,
double *  e 
)
int psi::C_DPTTRS ( int  n,
int  nrhs,
double *  d,
double *  e,
double *  b,
int  ldb 
)
int psi::C_DSBEV ( char  jobz,
char  uplo,
int  n,
int  kd,
double *  ab,
int  ldab,
double *  w,
double *  z,
int  ldz,
double *  work 
)
int psi::C_DSBEVD ( char  jobz,
char  uplo,
int  n,
int  kd,
double *  ab,
int  ldab,
double *  w,
double *  z,
int  ldz,
double *  work,
int  lwork,
int *  iwork,
int  liwork 
)
int psi::C_DSBEVX ( char  jobz,
char  range,
char  uplo,
int  n,
int  kd,
double *  ab,
int  ldab,
double *  q,
int  ldq,
double  vl,
double  vu,
int  il,
int  iu,
double  abstol,
int *  m,
double *  w,
double *  z,
int  ldz,
double *  work,
int *  iwork,
int *  ifail 
)
int psi::C_DSBGST ( char  vect,
char  uplo,
int  n,
int  ka,
int  kb,
double *  ab,
int  ldab,
double *  bb,
int  ldbb,
double *  x,
int  ldx,
double *  work 
)
int psi::C_DSBGV ( char  jobz,
char  uplo,
int  n,
int  ka,
int  kb,
double *  ab,
int  ldab,
double *  bb,
int  ldbb,
double *  w,
double *  z,
int  ldz,
double *  work 
)
int psi::C_DSBGVD ( char  jobz,
char  uplo,
int  n,
int  ka,
int  kb,
double *  ab,
int  ldab,
double *  bb,
int  ldbb,
double *  w,
double *  z,
int  ldz,
double *  work,
int  lwork,
int *  iwork,
int  liwork 
)
int psi::C_DSBGVX ( char  jobz,
char  range,
char  uplo,
int  n,
int  ka,
int  kb,
double *  ab,
int  ldab,
double *  bb,
int  ldbb,
double *  q,
int  ldq,
double  vl,
double  vu,
int  il,
int  iu,
double  abstol,
int *  m,
double *  w,
double *  z,
int  ldz,
double *  work,
int *  iwork,
int *  ifail 
)
void psi::C_DSBMV ( char  uplo,
int  n,
int  k,
double  alpha,
double *  a,
int  lda,
double *  x,
int  incx,
double  beta,
double *  y,
int  incy 
)

Purpose

DSBMV performs the matrix-vector operation

y := alpha*A*x + beta*y,

where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric band matrix, with k super-diagonals.

Arguments

UPLO - CHARACTER*1. On entry, UPLO specifies whether the upper or lower triangular part of the band matrix A is being supplied as follows:

UPLO = 'U' or 'u' The upper triangular part of A is being supplied.

UPLO = 'L' or 'l' The lower triangular part of A is being supplied.

Unchanged on exit.

N - INTEGER. On entry, N specifies the order of the matrix A. N must be at least zero. Unchanged on exit.

K - INTEGER. On entry, K specifies the number of super-diagonals of the matrix A. K must satisfy 0 .le. K. Unchanged on exit.

ALPHA - DOUBLE PRECISION. On entry, ALPHA specifies the scalar alpha. Unchanged on exit.

A - DOUBLE PRECISION array of DIMENSION ( LDA, n ). Before entry with UPLO = 'U' or 'u', the leading ( k + 1 ) by n part of the array A must contain the upper triangular band part of the symmetric matrix, supplied column by column, with the leading diagonal of the matrix in row ( k + 1 ) of the array, the first super-diagonal starting at position 2 in row k, and so on. The top left k by k triangle of the array A is not referenced. The following program segment will transfer the upper triangular part of a symmetric band matrix from conventional full matrix storage to band storage:

  DO 20, J = 1, N
     M = K + 1 - J
     DO 10, I = MAX( 1, J - K ), J
        A( M + I, J ) = matrix( I, J )

10 CONTINUE 20 CONTINUE

Before entry with UPLO = 'L' or 'l', the leading ( k + 1 ) by n part of the array A must contain the lower triangular band part of the symmetric matrix, supplied column by column, with the leading diagonal of the matrix in row 1 of the array, the first sub-diagonal starting at position 1 in row 2, and so on. The bottom right k by k triangle of the array A is not referenced. The following program segment will transfer the lower triangular part of a symmetric band matrix from conventional full matrix storage to band storage:

  DO 20, J = 1, N
     M = 1 - J
     DO 10, I = J, MIN( N, J + K )
        A( M + I, J ) = matrix( I, J )

10 CONTINUE 20 CONTINUE

Unchanged on exit.

LDA - INTEGER. On entry, LDA specifies the first dimension of A as declared in the calling (sub) program. LDA must be at least ( k + 1 ). Unchanged on exit.

X - DOUBLE PRECISION array of DIMENSION at least ( 1 + ( n - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the vector x. Unchanged on exit.

INCX - INTEGER. On entry, INCX specifies the increment for the elements of X. INCX must not be zero. Unchanged on exit.

BETA - DOUBLE PRECISION. On entry, BETA specifies the scalar beta. Unchanged on exit.

Y - DOUBLE PRECISION array of DIMENSION at least ( 1 + ( n - 1 )*abs( INCY ) ). Before entry, the incremented array Y must contain the vector y. On exit, Y is overwritten by the updated vector y.

INCY - INTEGER. On entry, INCY specifies the increment for the elements of Y. INCY must not be zero. Unchanged on exit.

Level 2 Blas routine.

– Written on 22-October-1986. Jack Dongarra, Argonne National Lab. Jeremy Du Croz, Nag Central Office. Sven Hammarling, Nag Central Office. Richard Hanson, Sandia National Labs.

.. Parameters ..

int psi::C_DSBTRD ( char  vect,
char  uplo,
int  n,
int  kd,
double *  ab,
int  ldab,
double *  d,
double *  e,
double *  q,
int  ldq,
double *  work 
)
int psi::C_DSGESV ( int  n,
int  nrhs,
double *  a,
int  lda,
int *  ipiv,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  work,
int *  iter 
)
int psi::C_DSPCON ( char  uplo,
int  n,
double *  ap,
int *  ipiv,
double  anorm,
double *  rcond,
double *  work,
int *  iwork 
)
int psi::C_DSPEV ( char  jobz,
char  uplo,
int  n,
double *  ap,
double *  w,
double *  z,
int  ldz,
double *  work 
)
int psi::C_DSPEVD ( char  jobz,
char  uplo,
int  n,
double *  ap,
double *  w,
double *  z,
int  ldz,
double *  work,
int  lwork,
int *  iwork,
int  liwork 
)
int psi::C_DSPEVX ( char  jobz,
char  range,
char  uplo,
int  n,
double *  ap,
double  vl,
double  vu,
int  il,
int  iu,
double  abstol,
int *  m,
double *  w,
double *  z,
int  ldz,
double *  work,
int *  iwork,
int *  ifail 
)
int psi::C_DSPGST ( int  itype,
char  uplo,
int  n,
double *  ap,
double *  bp 
)
int psi::C_DSPGV ( int  itype,
char  jobz,
char  uplo,
int  n,
double *  ap,
double *  bp,
double *  w,
double *  z,
int  ldz,
double *  work 
)
int psi::C_DSPGVD ( int  itype,
char  jobz,
char  uplo,
int  n,
double *  ap,
double *  bp,
double *  w,
double *  z,
int  ldz,
double *  work,
int  lwork,
int *  iwork,
int  liwork 
)
int psi::C_DSPGVX ( int  itype,
char  jobz,
char  range,
char  uplo,
int  n,
double *  ap,
double *  bp,
double  vl,
double  vu,
int  il,
int  iu,
double  abstol,
int *  m,
double *  w,
double *  z,
int  ldz,
double *  work,
int *  iwork,
int *  ifail 
)
void psi::C_DSPMV ( char  uplo,
int  n,
double  alpha,
double *  ap,
double *  x,
int  incx,
double  beta,
double *  y,
int  incy 
)

Purpose

DSPMV performs the matrix-vector operation

y := alpha*A*x + beta*y,

where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.

Arguments

UPLO - CHARACTER*1. On entry, UPLO specifies whether the upper or lower triangular part of the matrix A is supplied in the packed array AP as follows:

UPLO = 'U' or 'u' The upper triangular part of A is supplied in AP.

UPLO = 'L' or 'l' The lower triangular part of A is supplied in AP.

Unchanged on exit.

N - INTEGER. On entry, N specifies the order of the matrix A. N must be at least zero. Unchanged on exit.

ALPHA - DOUBLE PRECISION. On entry, ALPHA specifies the scalar alpha. Unchanged on exit.

AP - DOUBLE PRECISION array of DIMENSION at least ( ( n*( n + 1 ) )/2 ). Before entry with UPLO = 'U' or 'u', the array AP must contain the upper triangular part of the symmetric matrix packed sequentially, column by column, so that AP( 1 ) contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 ) and a( 2, 2 ) respectively, and so on. Before entry with UPLO = 'L' or 'l', the array AP must contain the lower triangular part of the symmetric matrix packed sequentially, column by column, so that AP( 1 ) contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 ) and a( 3, 1 ) respectively, and so on. Unchanged on exit.

X - DOUBLE PRECISION array of dimension at least ( 1 + ( n - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the n element vector x. Unchanged on exit.

INCX - INTEGER. On entry, INCX specifies the increment for the elements of X. INCX must not be zero. Unchanged on exit.

BETA - DOUBLE PRECISION. On entry, BETA specifies the scalar beta. When BETA is supplied as zero then Y need not be set on input. Unchanged on exit.

Y - DOUBLE PRECISION array of dimension at least ( 1 + ( n - 1 )*abs( INCY ) ). Before entry, the incremented array Y must contain the n element vector y. On exit, Y is overwritten by the updated vector y.

INCY - INTEGER. On entry, INCY specifies the increment for the elements of Y. INCY must not be zero. Unchanged on exit.

Level 2 Blas routine.

– Written on 22-October-1986. Jack Dongarra, Argonne National Lab. Jeremy Du Croz, Nag Central Office. Sven Hammarling, Nag Central Office. Richard Hanson, Sandia National Labs.

.. Parameters ..

void psi::C_DSPR ( char  uplo,
int  n,
double  alpha,
double *  x,
int  incx,
double *  ap 
)

Purpose

DSPR performs the symmetric rank 1 operation

A := alpha*x*x' + A,

where alpha is a real scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form.

Arguments

UPLO - CHARACTER*1. On entry, UPLO specifies whether the upper or lower triangular part of the matrix A is supplied in the packed array AP as follows:

UPLO = 'U' or 'u' The upper triangular part of A is supplied in AP.

UPLO = 'L' or 'l' The lower triangular part of A is supplied in AP.

Unchanged on exit.

N - INTEGER. On entry, N specifies the order of the matrix A. N must be at least zero. Unchanged on exit.

ALPHA - DOUBLE PRECISION. On entry, ALPHA specifies the scalar alpha. Unchanged on exit.

X - DOUBLE PRECISION array of dimension at least ( 1 + ( n - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the n element vector x. Unchanged on exit.

INCX - INTEGER. On entry, INCX specifies the increment for the elements of X. INCX must not be zero. Unchanged on exit.

AP - DOUBLE PRECISION array of DIMENSION at least ( ( n*( n + 1 ) )/2 ). Before entry with UPLO = 'U' or 'u', the array AP must contain the upper triangular part of the symmetric matrix packed sequentially, column by column, so that AP( 1 ) contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 ) and a( 2, 2 ) respectively, and so on. On exit, the array AP is overwritten by the upper triangular part of the updated matrix. Before entry with UPLO = 'L' or 'l', the array AP must contain the lower triangular part of the symmetric matrix packed sequentially, column by column, so that AP( 1 ) contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 ) and a( 3, 1 ) respectively, and so on. On exit, the array AP is overwritten by the lower triangular part of the updated matrix.

Level 2 Blas routine.

– Written on 22-October-1986. Jack Dongarra, Argonne National Lab. Jeremy Du Croz, Nag Central Office. Sven Hammarling, Nag Central Office. Richard Hanson, Sandia National Labs.

.. Parameters ..

void psi::C_DSPR2 ( char  uplo,
int  n,
double  alpha,
double *  x,
int  incx,
double *  y,
int  incy,
double *  ap 
)

Purpose

DSPR2 performs the symmetric rank 2 operation

A := alpha*x*y' + alpha*y*x' + A,

where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.

Arguments

UPLO - CHARACTER*1. On entry, UPLO specifies whether the upper or lower triangular part of the matrix A is supplied in the packed array AP as follows:

UPLO = 'U' or 'u' The upper triangular part of A is supplied in AP.

UPLO = 'L' or 'l' The lower triangular part of A is supplied in AP.

Unchanged on exit.

N - INTEGER. On entry, N specifies the order of the matrix A. N must be at least zero. Unchanged on exit.

ALPHA - DOUBLE PRECISION. On entry, ALPHA specifies the scalar alpha. Unchanged on exit.

X - DOUBLE PRECISION array of dimension at least ( 1 + ( n - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the n element vector x. Unchanged on exit.

INCX - INTEGER. On entry, INCX specifies the increment for the elements of X. INCX must not be zero. Unchanged on exit.

Y - DOUBLE PRECISION array of dimension at least ( 1 + ( n - 1 )*abs( INCY ) ). Before entry, the incremented array Y must contain the n element vector y. Unchanged on exit.

INCY - INTEGER. On entry, INCY specifies the increment for the elements of Y. INCY must not be zero. Unchanged on exit.

AP - DOUBLE PRECISION array of DIMENSION at least ( ( n*( n + 1 ) )/2 ). Before entry with UPLO = 'U' or 'u', the array AP must contain the upper triangular part of the symmetric matrix packed sequentially, column by column, so that AP( 1 ) contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 ) and a( 2, 2 ) respectively, and so on. On exit, the array AP is overwritten by the upper triangular part of the updated matrix. Before entry with UPLO = 'L' or 'l', the array AP must contain the lower triangular part of the symmetric matrix packed sequentially, column by column, so that AP( 1 ) contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 ) and a( 3, 1 ) respectively, and so on. On exit, the array AP is overwritten by the lower triangular part of the updated matrix.

Level 2 Blas routine.

– Written on 22-October-1986. Jack Dongarra, Argonne National Lab. Jeremy Du Croz, Nag Central Office. Sven Hammarling, Nag Central Office. Richard Hanson, Sandia National Labs.

.. Parameters ..

int psi::C_DSPRFS ( char  uplo,
int  n,
int  nrhs,
double *  ap,
double *  afp,
int *  ipiv,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  ferr,
double *  berr,
double *  work,
int *  iwork 
)
int psi::C_DSPSV ( char  uplo,
int  n,
int  nrhs,
double *  ap,
int *  ipiv,
double *  b,
int  ldb 
)
int psi::C_DSPSVX ( char  fact,
char  uplo,
int  n,
int  nrhs,
double *  ap,
double *  afp,
int *  ipiv,
double *  b,
int  ldb,
double *  x,
int  ldx,
double *  rcond 
)
int psi::C_DSPTRD ( char  uplo,
int  n,
double *  ap,
double *  d,
double *  e,
double *  tau 
)
int psi::C_DSPTRF ( char  uplo,
int  n,
double *  ap,
int *  ipiv 
)
int psi::C_DSPTRI ( char  uplo,
int  n,
double *  ap,
int *  ipiv,
double *  work 
)
int psi::C_DSPTRS ( char  uplo,
int  n,
int  nrhs,
double *  ap,
int *  ipiv,
double *  b,
int  ldb 
)
int psi::C_DSTEBZ ( char  range,
char  order,
int  n,
double  vl,
double  vu,
int  il,
int  iu,
double  abstol,
double *  d,
double *  e,
int *  m,
int *  nsplit,
double *  w,
int *  iblock,
int *  isplit,
double *  work,
int *  iwork 
)
int psi::C_DSTEDC ( char  compz,
int  n,
double *  d,
double *  e,
double *  z,
int  ldz,
double *  work,
int  lwork,
int *  iwork,
int  liwork 
)
int psi::C_DSTEGR ( char  jobz,
char  range,
int  n,
double *  d,
double *  e,
double  vl,
double  vu,
int  il,
int  iu,
double  abstol,
int *  m,
double *  w,
double *  z,
int  ldz,
int *  isuppz,
double *  work,
int  lwork,
int *  iwork,
int  liwork 
)
int psi::C_DSTEIN ( int  n,
double *  d,
double *  e,
int  m,
double *  w,
int *  iblock,
int *  isplit,
double *  z,
int  ldz,
double *  work,
int *  iwork,
int *  ifail 
)
int psi::C_DSTEQR ( char  compz,
int  n,
double *  d,
double *  e,
double *  z,
int  ldz,
double *  work 
)
int psi::C_DSTERF ( int  n,
double *  d,
double *  e 
)
int psi::C_DSTEV ( char  jobz,
int  n,
double *  d,
double *  e,
double *  z,
int  ldz,
double *  work 
)
int psi::C_DSTEVD ( char  jobz,
int  n,
double *  d,
double *  e,
double *  z,
int  ldz,
double *  work,
int  lwork,
int *  iwork,
int  liwork 
)
int psi::C_DSTEVR ( char  jobz,
char  range,
int  n,
double *  d,
double *  e,
double  vl,
double  vu,
int  il,
int  iu,
double  abstol,
int *  m,
double *  w,
double *  z,
int  ldz,
int *  isuppz,
double *  work,
int  lwork,
int *  iwork,
int  liwork 
)
int psi::C_DSTEVX ( char  jobz,
char  range,
int  n,
double *  d,
double *  e,
double  vl,
double  vu,
int  il,
int  iu,
double  abstol,
int *  m,
double *  w,
double *  z,
int  ldz,
double *  work,
int *  iwork,
int *  ifail 
)
int psi::C_DSYCON ( char  uplo,
int  n,
double *  a,
int  lda,
int *  ipiv,
double  anorm,
double *  rcond,
double *  work,
int *  iwork 
)
PSI_API int psi::C_DSYEVD ( char  jobz,
char  uplo,
int  n,
double *  a,
int  lda,
double *  w,
double *  work,
int  lwork,
int *  iwork,
int  liwork 
)
int psi::C_DSYEVR ( char  jobz,
char  range,
char  uplo,
int  n,
double *  a,
int  lda,
double  vl,
double  vu,
int  il,
int  iu,
double  abstol,
int *  m,
double *  w,
double *  z,
int  ldz,
int *  isuppz,
double *  work,
int  lwork,
int *  iwork,
int  liwork 
)
int psi::C_DSYEVX ( char  jobz,
char  range,
char  uplo,
int  n,
double *  a,
int  lda,
double  vl,
double  vu,
int  il,
int  iu,
double  abstol,
int *  m,
double *  w,
double *  z,
int  ldz,
double *  work,
int  lwork,
int *  iwork,
int *  ifail 
)
int psi::C_DSYGST ( int  itype,
char  uplo,
int  n,
double *  a,
int  lda,
double *  b,
int  ldb 
)
PSI_API int psi::C_DSYGV ( int  itype,
char  jobz,
char  uplo,
int  n,
double *  a,
int  lda,
double *  b,
int  ldb,
double *  w,
double *  work,
int  lwork 
)
int psi::C_DSYGVD ( int  itype,
char  jobz,
char  uplo,
int  n,
double *  a,
int  lda,
double *  b,
int  ldb,
double *  w,
double *  work,
int  lwork,
int *  iwork,
int  liwork 
)
int psi::C_DSYGVX ( int  itype,
char  jobz,
char  range,
char  uplo,
int  n,
double *  a,
int  lda,
double *  b,
int  ldb,
double  vl,
double  vu,
int  il,
int  iu,
double  abstol,
int *  m,
double *  w,
double *  z,
int  ldz,
double *  work,
int  lwork,
int *  iwork,
int *  ifail 
)
void psi::C_DSYMM ( char  side,
char  uplo,
int  m,
int  n,
double  alpha,
double *  a,
int  lda,