GooFit  v2.1.3
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
GooFit Namespace Reference

Namespaces

 Lineshapes
 
 literals
 
 Resonances
 

Classes

class  AddPdf
 
class  AmpCalc
 
class  AmpCalc_TD
 
class  Amplitude
 
class  Application
 
class  ArgusPdf
 
class  BifurGaussPdf
 
class  BinnedChisqFit
 
class  BinnedDataSet
 
class  BinnedErrorFit
 
class  BinnedNllFit
 
class  BinTransformPdf
 
class  BWPdf
 
class  CompositePdf
 
class  ConvolutionPdf
 
class  CorrGaussianPdf
 
class  CrystalBallPdf
 
class  DalitzPlotPdf
 
class  DalitzPlotter
 This class makes it easy to make plots over 3 body Dalitz PDFs. You can use ROOT style value access or bin numbers. More...
 
class  DalitzVetoPdf
 
class  DataSet
 
struct  DecayInfo3
 
struct  DecayInfo3t
 
struct  DecayInfo4
 
struct  DecayInfo4t
 
struct  Dim5
 
class  DPPdf
 
class  EventNumber
 
class  EventWeightedAddPdf
 
class  ExpGausPdf
 
class  ExpPdf
 
class  FCN
 
class  FitControl
 
class  FitManagerMinuit1
 
class  FitManagerMinuit2
 
class  FourDblTupleAdd
 
class  GaussianPdf
 
struct  GeneralError
 Thrown when a general error is encountered. More...
 
class  GooPdf
 
class  IncoherentSumPdf
 
class  Indexable
 
class  InterHistPdf
 
class  JohnsonSUPdf
 
class  KinLimitBWPdf
 
class  LandauPdf
 
class  Lineshape
 
class  LorentzMatrix
 
class  LSCalculator
 
class  LSCalculator_TD
 
class  MappedPdf
 
class  MetricTaker
 
class  Minuit1
 
class  MixingTimeResolution
 
class  NormIntegrator
 
class  NormIntegrator_TD
 
class  NormLSCalculator
 
class  NormLSCalculator_TD
 
class  NormSpinCalculator
 
class  NormSpinCalculator_TD
 
class  NovosibirskPdf
 
class  Observable
 Special class for observables. Used in DataSets. More...
 
struct  OutOfRange
 
class  Params
 
class  PdfBase
 
class  PolynomialPdf
 
class  ProdPdf
 
class  ResonancePdf
 
class  ScaledGaussianPdf
 
class  SFCalculator
 
class  SFCalculator_TD
 
class  SmoothHistogramPdf
 
class  SpecialComplexSum
 
class  SpecialDalitzIntegrator
 
class  SpecialIncoherentIntegrator
 
class  SpecialIncoherentResonanceCalculator
 
class  SpecialResonanceCalculator
 
class  SpecialResonanceIntegrator
 
class  SpecialWaveCalculator
 
class  SpinFactor
 
class  SpinSumT
 
class  SpinSumV
 
class  StepPdf
 
class  strided_range
 
class  SymmLorentzMatrix
 
class  TDDP4
 
class  TddpPdf
 
class  ThreeGaussResolution
 
class  TrigThresholdPdf
 
class  TruthResolution
 
class  UnbinnedDataSet
 
class  UnbinnedNllFit
 
class  Uncertain
 
class  Variable
 
class  VariableBinTransform1DPdf
 
struct  VetoInfo
 
class  VoigtianPdf
 
struct  WaveHolder_s
 
class  ZTspin1
 
class  ZTspin2
 

Typedefs

using fpcomplex = thrust::complex< fptype >
 
using FitManager = GooFit::FitManagerMinuit2
 
using fptype = double
 
typedef fptype(* device_function_ptr) (fptype *, fptype *, unsigned int *)
 Pass event, parameters, index into parameters. More...
 
typedef fptype(* device_metric_ptr) (fptype, fptype *, unsigned int)
 
typedef fptype(* device_resfunction_ptr) (fptype, fptype, fptype, fptype, fptype, fptype, fptype, fptype, fptype, fptype *, unsigned int *)
 
typedef fptype(* device_calc_tau_fcn_ptr) (fptype, fptype, fptype, fptype, fptype, fptype, fptype)
 
typedef fpcomplex(* resonance_function_ptr) (fptype, fptype, fptype, unsigned int *)
 
typedef fptype(* spin_function_ptr) (fptype *, unsigned int *)
 
typedef thrust::tuple< fptype, fptype, fptype, fptypeWaveHolder
 
typedef thrust::tuple< fptype, fptype, fptype, fptype, fptype, fptypeThreeComplex
 

Enumerations

enum  FitErrors : int { FitErrors::Valid = 0, FitErrors::NotRun = 50, FitErrors::InValid }
 
enum  EvalFunc : size_t {
  EvalFunc::Eval = 0, EvalFunc::NLL, EvalFunc::Prob, EvalFunc::BinAvg,
  EvalFunc::BinWithError, EvalFunc::Chisq
}
 
enum  DP4Pair {
  M_12 = 0, M_34, M_13, M_14,
  M_23, M_24, M_12_3, M_13_2,
  M_23_1, M_12_4, M_14_2, M_24_1,
  M_13_4, M_14_3, M_34_1, M_23_4,
  M_24_3, M_34_2
}
 
enum  DaughterPair { PAIR_12 = 0, PAIR_13, PAIR_23 }
 
enum  FF : unsigned int { FF::One = 0, FF::BL, FF::BL_Prime, FF::BL2 }
 
enum  SF_4Body {
  SF_4Body::DtoPP1_PtoSP2_StoP3P4, SF_4Body::DtoPP1_PtoVP2_VtoP3P4, SF_4Body::DtoV1V2_V1toP1P2_V2toP3P4_S, SF_4Body::DtoV1V2_V1toP1P2_V2toP3P4_P,
  SF_4Body::DtoV1V2_V1toP1P2_V2toP3P4_D, SF_4Body::DtoAP1_AtoVP2_VtoP3P4, SF_4Body::DtoAP1_AtoVP2Dwave_VtoP3P4, SF_4Body::DtoVS_VtoP1P2_StoP3P4,
  SF_4Body::DtoV1P1_V1toV2P2_V2toP3P4, SF_4Body::DtoAP1_AtoSP2_StoP3P4, SF_4Body::DtoTP1_TtoVP2_VtoP3P4, SF_4Body::FF_12_34_L1,
  SF_4Body::FF_12_34_L2, SF_4Body::FF_123_4_L1, SF_4Body::FF_123_4_L2, SF_4Body::ONE
}
 

Functions

void signal_handler (int s)
 will call the correct exit func, no unwinding of the stack though More...
 
void print_splash ()
 
void print_goofit_info (int gpuDev_=0)
 Print out information about GooFit. More...
 
void abort (std::string file, int line, std::string reason, const PdfBase *pdf=nullptr)
 Smart abort that includes the file name and location, and prints a stack trace if possible. More...
 
template<int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int >
__device__ Eigen::Array< fpcomplex, 5, 5 > compute_inverse5 (const Eigen::Array< fpcomplex, 5, 5 > &m)
 
template<>
__device__ Eigen::Array< fpcomplex, 5, 5 > compute_inverse5<-1, -1, 0, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 > (const Eigen::Array< fpcomplex, 5, 5 > &M)
 
template<typename M >
read_csv (std::string name, bool comma=true)
 
fptype cpuvoigtian (fptype x, fptype m, fptype w, fptype s)
 
void writeToFile (PdfBase *pdf, const char *fname)
 
void readFromFile (PdfBase *pdf, const char *fname)
 
void writeListOfNumbers (thrust::host_vector< fptype > &target, const char *fname)
 
void readListOfNumbers (thrust::host_vector< fptype > &target, const char *fname)
 
cudaError_t gooMalloc (void **target, size_t bytes)
 
cudaError_t gooFree (void *ptr)
 
template<typename T >
std::vector< T > flatten (const std::vector< thrust::complex< T >> &input)
 Flatten a complex array into a standard one (1r, 1i, 2r, 2i, ...) More...
 
std::vector< fpcomplexcomplex_derivative (const std::vector< fptype > &x, const std::vector< fpcomplex > &y)
 
constexpr const char * evalfunc_to_string (EvalFunc val)
 
__device__ int dev_powi (int base, int exp)
 
void * getMetricPointer (std::string name)
 
__device__ fptype callFunction (fptype *eventAddress, unsigned int functionIdx, unsigned int paramIdx)
 
template<typename E >
constexpr std::underlying_type< E >::type enum_to_underlying (E e)
 
__host__ __device__ bool inDalitz (const fptype &m12, const fptype &m13, const fptype &bigM, const fptype &dm1, const fptype &dm2, const fptype &dm3)
 
__device__ fpcomplex getResonanceAmplitude (fptype m12, fptype m13, fptype m23, unsigned int functionIdx, unsigned int pIndex)
 
__device__ void get4Vecs (fptype *Vecs, const unsigned int &constants, const fptype &m12, const fptype &m34, const fptype &cos12, const fptype &cos34, const fptype &phi)
 
__device__ fptype getmass (const unsigned int &pair, fptype &d1, fptype &d2, const fptype *vecs, const fptype &m1, const fptype &m2, const fptype &m3, const fptype &m4)
 
__device__ fptype twoBodyCMmom (double rMassSq, fptype d1m, fptype d2m)
 
__device__ fptype dampingFactorSquare (const fptype &cmmom, const int &spin, const fptype &mRadius)
 
__device__ fptype spinFactor (unsigned int spin, fptype motherMass, fptype daug1Mass, fptype daug2Mass, fptype daug3Mass, fptype m12, fptype m13, fptype m23, unsigned int cyclic_index)
 
class __align__ (16) gpuLVec
 
__device__ gpuLVec operator+ (gpuLVec lhs, const gpuLVec &rhs)
 
__device__ gpuLVec operator- (gpuLVec lhs, const gpuLVec &rhs)
 
__device__ gpuLVec operator* (gpuLVec lhs, fptype rhs)
 
__device__ gpuLVec operator* (fptype lhs, gpuLVec rhs)
 
__device__ SymmLorentzMatrix operator* (fptype lhs, const SymmLorentzMatrix &rhs)
 
__device__ SymmLorentzMatrix operator/ (fptype lhs, const SymmLorentzMatrix &rhs)
 
__device__ fptype LeviCivita (const gpuLVec &p1, const gpuLVec &p2, const gpuLVec &p3, const gpuLVec &p4)
 
__device__ gpuLVec LeviCivita (const gpuLVec &a, const gpuLVec &b, const gpuLVec &c)
 
Eigen::Matrix< fptype, 5, Eigen::Dynamic > to_5param (const Eigen::Matrix< fptype, 16, Eigen::Dynamic > &mat)
 This is a helper to convert values. It copies back and forth, so is only to be used in scripts. More...
 
void fillDataSetMC1D (GooPdf &pdf, Observable var, size_t nTotal, unsigned int seed=0)
 
Uncertain operator* (fptype other, const Uncertain &self)
 Allow int and float multiplies. More...
 
std::ostream & operator<< (std::ostream &stream, Uncertain value)
 Simple << output. More...
 
void format_arg (fmt::BasicFormatter< char > &f, const char *&format_str, const Uncertain &s)
 fmt support More...
 
int max_index (const std::vector< Variable > &vars)
 Get the max index of a variable from a list. More...
 
int max_index (const std::vector< Observable > &vars)
 
int max_fitter_index (const std::vector< Variable > &vars)
 Get the max fitter index of a variable from a list. More...
 
std::ostream & operator<< (std::ostream &o, const GooFit::Variable &var)
 Nice print of Variable. More...
 
std::ostream & operator<< (std::ostream &o, const GooFit::Observable &var)
 Nice print of Observable. More...
 
std::istream & operator>> (std::istream &i, GooFit::Observable &var)
 Allow Observable to be read in. More...
 
fpcomplex Faddeeva_2 (const fpcomplex &z)
 
void make_a_grid (std::vector< Observable > ret, UnbinnedDataSet *grid, Observable *eventNum)
 

Variables

constexpr rang::fg const black = rang::fg::black
 
constexpr rang::fg const red = rang::fg::red
 
constexpr rang::fg const green = rang::fg::green
 
constexpr rang::fg const yellow = rang::fg::yellow
 
constexpr rang::fg const blue = rang::fg::blue
 
constexpr rang::fg const magenta = rang::fg::magenta
 
constexpr rang::fg const cyan = rang::fg::cyan
 
constexpr rang::fg const gray = rang::fg::gray
 
constexpr rang::style const reset = rang::style::reset
 
constexpr rang::style const bold = rang::style::bold
 
constexpr rang::style const dim = rang::style::dim
 
constexpr rang::style const italic = rang::style::italic
 
int host_callnumber = 0
 
const int maxParams = GOOFIT_MAXPAR
 
fptypedev_event_array
 
fptype host_normalisation [maxParams]
 
fptype host_params [maxParams]
 
unsigned int host_indices [maxParams]
 
int totalParams = 0
 
int totalConstants = 1
 
constexpr const char * evalfunc_vals [] = {"ptr_to_Eval", "ptr_to_NLL", "ptr_to_Prob", "ptr_to_BinAvg", "ptr_to_BinWithError", "ptr_to_Chisq"}
 
void * host_fcn_ptr
 
const int resonanceSize = 4
 

Typedef Documentation

◆ device_calc_tau_fcn_ptr

typedef fptype(* GooFit::device_calc_tau_fcn_ptr) (fptype, fptype, fptype, fptype, fptype, fptype, fptype)

Definition at line 10 of file MixingTimeResolution_Aux.h.

◆ device_function_ptr

typedef fptype(* GooFit::device_function_ptr) (fptype *, fptype *, unsigned int *)

Pass event, parameters, index into parameters.

Definition at line 46 of file GooPdf.h.

◆ device_metric_ptr

typedef fptype(* GooFit::device_metric_ptr) (fptype, fptype *, unsigned int)

Definition at line 48 of file GooPdf.h.

◆ device_resfunction_ptr

typedef fptype(* GooFit::device_resfunction_ptr) (fptype, fptype, fptype, fptype, fptype, fptype, fptype, fptype, fptype, fptype *, unsigned int *)

Definition at line 8 of file MixingTimeResolution_Aux.h.

◆ FitManager

Definition at line 9 of file FitManager.h.

◆ fpcomplex

using GooFit::fpcomplex = typedef thrust::complex<fptype>

Definition at line 8 of file Complex.h.

◆ fptype

using GooFit::fptype = typedef double

Definition at line 96 of file GlobalCudaDefines.h.

◆ resonance_function_ptr

typedef fpcomplex(* GooFit::resonance_function_ptr) (fptype, fptype, fptype, unsigned int *)

Definition at line 10 of file ResonancePdf.h.

◆ spin_function_ptr

typedef fptype(* GooFit::spin_function_ptr) (fptype *, unsigned int *)

Definition at line 15 of file SpinFactors.h.

◆ ThreeComplex

Definition at line 19 of file TddpPdf.h.

◆ WaveHolder

typedef thrust::tuple<fptype, fptype, fptype, fptype> GooFit::WaveHolder

Definition at line 18 of file TddpPdf.h.

Enumeration Type Documentation

◆ DaughterPair

Enumerator
PAIR_12 
PAIR_13 
PAIR_23 

Definition at line 69 of file DalitzPlotHelpers.h.

◆ DP4Pair

Enumerator
M_12 
M_34 
M_13 
M_14 
M_23 
M_24 
M_12_3 
M_13_2 
M_23_1 
M_12_4 
M_14_2 
M_24_1 
M_13_4 
M_14_3 
M_34_1 
M_23_4 
M_24_3 
M_34_2 

Definition at line 49 of file DalitzPlotHelpers.h.

◆ EvalFunc

enum GooFit::EvalFunc : size_t
strong
Enumerator
Eval 
NLL 
Prob 
BinAvg 
BinWithError 
Chisq 

Definition at line 15 of file GooPdf.h.

◆ FF

enum GooFit::FF : unsigned int
strong
Enumerator
One 
BL 
BL_Prime 
BL2 

Definition at line 25 of file LineshapesPdf.h.

◆ FitErrors

enum GooFit::FitErrors : int
strong
Enumerator
Valid 
NotRun 
InValid 

Definition at line 14 of file FitManagerMinuit2.h.

◆ SF_4Body

enum GooFit::SF_4Body
strong

Function Documentation

◆ __align__()

class GooFit::__align__ ( 16  )

Definition at line 15 of file SpinHelper.h.

15  {
16  private:
17  fptype X;
18  fptype Y;
19  fptype Z;
20  fptype E;
21 
22  public:
23  __device__ gpuLVec() { X = Y = Z = E = 0; };
24  __device__ gpuLVec(fptype x, fptype y, fptype z, fptype e)
25  : X(x)
26  , Y(y)
27  , Z(z)
28  , E(e){};
29 
30  __device__ void SetXYZE(fptype x, fptype y, fptype z, fptype e) {
31  X = x;
32  Y = y;
33  Z = z;
34  E = e;
35  }
36 
37  __device__ fptype Dot(const gpuLVec &rhs) const { return E * rhs.E - X * rhs.X - Y * rhs.Y - Z * rhs.Z; }
38  __device__ inline fptype GetX() const { return X; }
39  __device__ inline fptype GetY() const { return Y; }
40  __device__ inline fptype GetZ() const { return Z; }
41  __device__ inline fptype GetE() const { return E; }
42 
43  __device__ inline fptype Mag2() const { return this->Dot(*this); }
44  __device__ inline fptype M() const { return sqrt(this->Mag2()); }
45  __device__ inline void SetX(fptype a) { X = a; }
46  __device__ inline void SetY(fptype a) { Y = a; }
47  __device__ inline void SetZ(fptype a) { Z = a; }
48  __device__ inline void SetE(fptype a) { E = a; }
49 
50  __device__ gpuLVec &operator+=(const gpuLVec &rhs) {
51  X += rhs.X;
52  Y += rhs.Y;
53  Z += rhs.Z;
54  E += rhs.E;
55  return *this;
56  }
57  __device__ gpuLVec &operator-=(const gpuLVec &rhs) {
58  X -= rhs.X;
59  Y -= rhs.Y;
60  Z -= rhs.Z;
61  E -= rhs.E;
62  return *this;
63  }
64  __device__ gpuLVec &operator*=(const fptype rhs) {
65  X *= rhs;
66  Y *= rhs;
67  Z *= rhs;
68  E *= rhs;
69  return *this;
70  }
71 };
double fptype

◆ abort()

void GooFit::abort ( std::string  file,
int  line,
std::string  reason,
const PdfBase pdf = nullptr 
)

Smart abort that includes the file name and location, and prints a stack trace if possible.

Definition at line 9 of file Abort.cpp.

References bold, GooFit::PdfBase::getName(), GooFit::PdfBase::getParameters(), host_params, red, reset, and totalParams.

9  {
10  void *stackarray[20];
11 
12  std::cout << GooFit::reset << GooFit::red << "Abort called from " << file << " line " << line << " due to "
13  << reason << std::endl;
14 
15  if(pdf) {
16  std::vector<Variable> pars = pdf->getParameters();
17  std::cout << "Parameters of " << pdf->getName() << " : \n";
18 
19  for(const Variable &v : pars) {
20  if(0 > v.getIndex())
21  continue;
22 
23  std::cout << " " << v.getName() << " (" << v.getIndex() << ") :\t" << host_params[v.getIndex()]
24  << std::endl;
25  }
26  }
27 
28  std::cout << "Parameters (" << totalParams << ") :\n";
29 
30  for(int i = 0; i < totalParams; ++i) {
31  std::cout << host_params[i] << " ";
32  }
33 
34 #if Backtrace_FOUND
35  std::cout << GooFit::bold << std::endl;
36  // get void* pointers for all entries on the stack
37  int size = backtrace(stackarray, 20);
38  // print out all the frames to stderr
39  backtrace_symbols_fd(stackarray, size, 2);
40 #endif
41 
42  std::cout << GooFit::reset << std::flush;
43 
44  throw GooFit::GeneralError(reason);
45 }
Thrown when a general error is encountered.
Definition: Error.h:10
constexpr rang::style const bold
Definition: Color.h:17
constexpr rang::fg const red
Definition: Color.h:9
constexpr rang::style const reset
Definition: Color.h:16
int totalParams
Definition: PdfBase.cpp:34
fptype host_params[maxParams]
Definition: PdfBase.cpp:30

◆ callFunction()

__device__ fptype GooFit::callFunction ( fptype eventAddress,
unsigned int  functionIdx,
unsigned int  paramIdx 
)

◆ complex_derivative()

std::vector<fpcomplex> GooFit::complex_derivative ( const std::vector< fptype > &  x,
const std::vector< fpcomplex > &  y 
)

Definition at line 20 of file ComplexUtils.h.

20  {
21  if(x.size() != y.size()) // Must be a valid pointer
22  throw GeneralError("x and y must have the same diminsions!");
23 
24  int i, k;
25  unsigned int n = x.size();
26  std::vector<fpcomplex> u(n);
27  std::vector<fpcomplex> y2(n);
28 
29  fptype sig, p, qn, un;
30  fpcomplex yp1 = 2. * (y[1] - y[0]) / (x[1] - x[0]);
31  fpcomplex ypn = 2. * (y[n - 1] - y[n - 2]) / (x[n - 1] - x[n - 2]);
32 
33  /* The lower boundary condition is set either to be "natural" or else to have specified first derivative*/
34  if(yp1.real() > 0.99e30) {
35  y2[0].real(0.);
36  u[0].real(0.);
37  } else {
38  y2[0].real(-0.5);
39  u[0].real(3.0 / (x[1] - x[0]) * ((y[1].real() - y[0].real()) / (x[1] - x[0]) - yp1.real()));
40  }
41  if(yp1.imag() > 0.99e30) {
42  y2[0].imag(0.);
43  u[0].imag(0.);
44  } else {
45  y2[0].imag(-0.5);
46  u[0].imag(3.0 / (x[1] - x[0]) * ((y[1].imag() - y[0].imag()) / (x[1] - x[0]) - yp1.imag()));
47  }
48 
49  /* This is the decomposition loop of the tridiagonal algorithm. y2 and u are used for temporary storage of the
50  * decomposed factors*/
51 
52  for(i = 1; i < n - 1; i++) {
53  sig = (x[i] - x[i - 1]) / (x[i + 1] - x[i - 1]);
54  p = sig * y2[i - 1].real() + 2.0;
55  y2[i].real((sig - 1.0) / p);
56  u[i].real((y[i + 1].real() - y[i].real()) / (x[i + 1] - x[i])
57  - (y[i].real() - y[i - 1].real()) / (x[i] - x[i - 1]));
58  u[i].real((6.0 * u[i].real() / (x[i + 1] - x[i - 1]) - sig * u[i - 1].real()) / p);
59  p = sig * y2[i - 1].imag() + 2.0;
60  y2[i].imag((sig - 1.0) / p);
61  u[i].imag((y[i + 1].imag() - y[i].imag()) / (x[i + 1] - x[i])
62  - (y[i].imag() - y[i - 1].imag()) / (x[i] - x[i - 1]));
63  u[i].imag((6.0 * u[i].imag() / (x[i + 1] - x[i - 1]) - sig * u[i - 1].imag()) / p);
64  }
65 
66  /* The upper boundary condition is set either to be "natural" or else to have specified first derivative*/
67 
68  if(ypn.real() > 0.99e30) {
69  qn = 0.;
70  un = 0.;
71  } else {
72  qn = 0.5;
73  un = (3.0 / (x[n - 1] - x[n - 2])) * (ypn.real() - (y[n - 1].real() - y[n - 2].real()) / (x[n - 1] - x[n - 2]));
74  }
75  y2[n - 1].real((un - qn * u[n - 2].real()) / (qn * y2[n - 2].real() + 1.0));
76  if(ypn.imag() > 0.99e30) {
77  qn = 0.;
78  un = 0.;
79  } else {
80  qn = 0.5;
81  un = (3.0 / (x[n - 1] - x[n - 2])) * (ypn.imag() - (y[n - 1].imag() - y[n - 2].imag()) / (x[n - 1] - x[n - 2]));
82  }
83  y2[n - 1].imag((un - qn * u[n - 2].imag()) / (qn * y2[n - 2].imag() + 1.0));
84 
85  /* This is the backsubstitution loop of the tridiagonal algorithm */
86 
87  for(k = n - 2; k >= 0; k--) {
88  y2[k].real(y2[k].real() * y2[k + 1].real() + u[k].real());
89  y2[k].imag(y2[k].imag() * y2[k + 1].imag() + u[k].imag());
90  }
91 
92  return y2;
93 }
double fptype
thrust::complex< fptype > fpcomplex
Definition: Complex.h:8

◆ compute_inverse5()

template<int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int , int >
__device__ Eigen::Array<fpcomplex, 5, 5> GooFit::compute_inverse5 ( const Eigen::Array< fpcomplex, 5, 5 > &  m)

◆ compute_inverse5<-1, -1, 0, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 >()

template<>
__device__ Eigen::Array<fpcomplex, 5, 5> GooFit::compute_inverse5<-1, -1, 0, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 > ( const Eigen::Array< fpcomplex, 5, 5 > &  M)
inline

Definition at line 36 of file compute_inverse5.h.

37  {
38  Eigen::Array<fpcomplex, 5, 5> O;
39 
40  O(0, 0) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
41  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
42  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
43  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
44  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
45  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
46  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
47  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
48  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
49  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
50  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
51  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
52  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
53  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
54  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
55  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
56  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
57  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
58  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
59  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
60  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
61  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
62  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
63  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
64  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
65  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
66  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
67  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
68  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
69  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
70  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
71  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
72  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
73  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
74  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
75  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
76  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
77  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
78  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
79  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
80  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
81  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
82  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
83  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
84  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
85 
86  O(0, 1) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
87  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
88  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
89  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
90  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
91  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
92  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
93  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
94  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
95  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
96  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
97  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
98  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
99  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
100  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
101  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
102  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
103  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
104  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
105  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
106  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
107  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
108  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
109  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
110  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
111  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
112  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
113  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
114  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
115  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
116  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
117  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
118  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
119  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
120  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
121  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
122  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
123  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
124  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
125  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
126  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
127  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
128  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
129  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
130  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
131 
132  O(0, 2) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
133  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
134  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
135  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
136  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
137  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
138  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
139  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
140  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
141  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
142  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
143  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
144  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
145  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
146  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
147  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
148  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
149  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
150  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
151  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
152  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
153  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
154  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
155  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
156  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
157  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
158  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
159  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
160  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
161  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
162  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
163  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
164  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
165  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
166  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
167  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
168  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
169  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
170  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
171  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
172  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
173  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
174  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
175  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
176  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
177 
178  O(0, 3) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
179  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
180  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
181  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
182  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
183  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
184  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
185  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
186  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
187  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
188  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
189  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
190  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
191  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
192  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
193  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
194  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
195  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
196  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
197  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
198  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
199  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
200  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
201  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
202  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
203  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
204  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
205  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
206  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
207  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
208  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
209  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
210  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
211  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
212  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
213  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
214  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
215  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
216  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
217  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
218  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
219  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
220  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
221  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
222  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
223 
224  O(0, 4) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
225  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
226  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
227  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
228  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
229  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
230  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
231  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
232  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
233  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
234  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
235  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
236  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
237  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
238  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
239  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
240  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
241  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
242  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
243  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
244  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
245  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
246  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
247  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
248  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
249  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
250  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
251  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
252  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
253  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
254  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
255  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
256  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
257  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
258  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
259  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
260  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
261  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
262  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
263  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
264  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
265  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
266  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
267  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
268  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
269 
270  O(1, 0) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
271  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
272  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
273  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
274  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
275  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
276  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
277  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
278  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
279  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
280  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
281  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
282  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
283  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
284  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
285  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
286  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
287  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
288  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
289  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
290  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
291  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
292  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
293  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
294  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
295  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
296  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
297  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
298  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
299  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
300  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
301  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
302  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
303  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
304  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
305  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
306  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
307  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
308  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
309  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
310  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
311  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
312  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
313  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
314  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
315 
316  O(1, 1) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
317  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
318  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
319  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
320  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
321  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
322  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
323  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
324  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
325  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
326  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
327  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
328  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
329  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
330  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
331  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
332  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
333  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
334  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
335  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
336  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
337  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
338  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
339  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
340  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
341  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
342  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
343  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
344  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
345  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
346  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
347  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
348  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
349  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
350  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
351  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
352  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
353  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
354  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
355  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
356  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
357  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
358  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
359  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
360  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
361 
362  O(1, 2) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
363  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
364  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
365  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
366  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
367  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
368  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
369  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
370  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
371  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
372  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
373  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
374  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
375  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
376  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
377  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
378  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
379  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
380  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
381  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
382  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
383  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
384  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
385  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
386  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
387  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
388  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
389  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
390  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
391  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
392  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
393  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
394  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
395  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
396  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
397  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
398  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
399  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
400  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
401  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
402  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
403  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
404  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
405  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
406  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
407 
408  O(1, 3) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
409  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
410  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
411  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
412  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
413  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
414  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
415  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
416  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
417  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
418  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
419  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
420  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
421  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
422  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
423  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
424  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
425  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
426  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
427  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
428  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
429  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
430  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
431  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
432  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
433  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
434  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
435  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
436  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
437  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
438  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
439  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
440  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
441  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
442  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
443  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
444  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
445  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
446  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
447  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
448  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
449  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
450  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
451  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
452  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
453 
454  O(1, 4) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
455  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
456  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
457  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
458  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
459  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
460  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
461  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
462  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
463  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
464  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
465  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
466  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
467  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
468  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
469  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
470  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
471  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
472  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
473  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
474  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
475  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
476  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
477  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
478  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
479  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
480  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
481  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
482  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
483  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
484  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
485  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
486  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
487  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
488  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
489  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
490  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
491  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
492  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
493  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
494  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
495  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
496  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
497  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
498  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
499 
500  O(2, 0) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
501  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
502  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
503  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
504  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
505  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
506  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
507  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
508  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
509  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
510  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
511  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
512  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
513  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
514  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
515  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
516  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
517  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
518  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
519  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
520  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
521  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
522  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
523  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
524  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
525  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
526  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
527  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
528  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
529  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
530  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
531  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
532  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
533  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
534  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
535  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
536  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
537  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
538  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
539  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
540  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
541  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
542  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
543  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
544  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
545 
546  O(2, 1) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
547  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
548  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
549  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
550  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
551  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
552  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
553  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
554  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
555  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
556  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
557  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
558  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
559  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
560  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
561  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
562  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
563  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
564  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
565  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
566  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
567  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
568  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
569  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
570  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
571  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
572  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
573  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
574  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
575  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
576  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
577  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
578  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
579  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
580  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
581  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
582  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
583  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
584  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
585  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
586  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
587  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
588  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
589  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
590  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
591 
592  O(2, 2) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
593  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
594  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
595  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
596  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
597  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
598  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
599  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
600  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
601  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
602  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
603  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
604  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
605  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
606  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
607  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
608  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
609  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
610  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
611  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
612  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
613  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
614  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
615  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
616  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
617  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
618  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
619  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
620  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
621  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
622  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
623  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
624  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
625  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
626  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
627  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
628  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
629  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
630  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
631  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
632  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
633  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
634  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
635  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
636  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
637 
638  O(2, 3) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
639  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
640  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
641  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
642  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
643  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
644  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
645  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
646  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
647  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
648  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
649  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
650  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
651  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
652  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
653  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
654  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
655  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
656  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
657  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
658  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
659  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
660  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
661  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
662  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
663  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
664  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
665  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
666  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
667  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
668  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
669  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
670  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
671  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
672  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
673  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
674  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
675  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
676  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
677  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
678  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
679  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
680  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
681  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
682  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
683 
684  O(2, 4) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
685  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
686  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
687  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
688  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
689  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
690  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
691  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
692  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
693  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
694  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
695  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
696  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
697  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
698  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
699  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
700  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
701  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
702  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
703  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
704  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
705  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
706  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
707  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
708  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
709  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
710  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
711  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
712  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
713  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
714  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
715  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
716  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
717  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
718  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
719  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
720  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
721  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
722  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
723  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
724  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
725  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
726  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
727  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
728  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
729 
730  O(3, 0) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
731  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
732  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
733  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
734  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
735  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
736  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
737  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
738  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
739  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
740  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
741  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
742  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
743  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
744  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
745  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
746  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
747  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
748  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
749  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
750  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
751  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
752  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
753  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
754  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
755  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
756  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
757  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
758  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
759  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
760  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
761  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
762  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
763  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
764  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
765  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
766  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
767  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
768  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
769  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
770  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
771  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
772  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
773  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
774  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
775 
776  O(3, 1) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
777  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
778  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
779  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
780  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
781  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
782  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
783  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
784  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
785  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
786  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
787  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
788  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
789  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
790  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
791  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
792  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
793  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
794  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
795  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
796  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
797  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
798  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
799  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
800  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
801  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
802  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
803  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
804  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
805  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
806  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
807  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
808  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
809  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
810  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
811  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
812  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
813  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
814  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
815  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
816  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
817  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
818  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
819  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
820  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
821 
822  O(3, 2) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
823  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
824  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
825  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
826  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
827  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
828  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
829  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
830  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
831  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
832  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
833  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
834  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
835  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
836  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
837  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
838  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
839  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
840  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
841  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
842  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
843  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
844  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
845  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
846  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
847  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
848  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
849  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
850  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
851  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
852  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
853  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
854  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
855  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
856  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
857  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
858  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
859  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
860  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
861  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
862  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
863  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
864  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
865  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
866  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
867 
868  O(3, 3) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
869  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
870  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
871  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
872  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
873  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
874  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
875  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
876  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
877  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
878  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
879  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
880  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
881  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
882  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
883  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
884  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
885  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
886  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
887  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
888  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
889  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
890  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
891  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
892  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
893  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
894  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
895  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
896  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
897  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
898  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
899  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
900  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
901  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
902  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
903  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
904  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
905  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
906  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
907  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
908  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
909  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
910  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
911  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
912  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
913 
914  O(3, 4) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
915  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
916  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
917  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
918  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
919  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
920  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
921  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
922  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
923  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
924  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
925  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
926  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
927  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
928  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
929  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
930  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
931  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
932  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
933  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
934  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
935  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
936  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
937  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
938  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
939  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
940  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
941  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
942  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
943  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
944  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
945  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
946  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
947  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
948  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
949  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
950  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
951  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
952  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
953  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
954  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
955  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
956  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
957  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
958  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
959 
960  O(4, 0) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
961  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
962  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
963  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
964  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
965  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
966  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
967  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
968  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
969  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
970  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
971  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
972  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
973  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
974  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
975  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
976  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
977  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
978  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
979  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
980  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
981  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
982  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
983  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
984  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
985  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
986  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
987  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
988  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
989  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
990  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
991  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
992  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
993  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
994  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
995  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
996  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
997  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
998  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
999  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
1000  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
1001  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
1002  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
1003  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
1004  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
1005 
1006  O(4, 1) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
1007  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
1008  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
1009  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
1010  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
1011  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
1012  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
1013  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
1014  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
1015  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
1016  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
1017  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
1018  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
1019  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
1020  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
1021  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
1022  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
1023  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
1024  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
1025  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
1026  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
1027  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
1028  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
1029  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
1030  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
1031  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
1032  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
1033  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
1034  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
1035  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
1036  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
1037  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
1038  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
1039  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
1040  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
1041  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
1042  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
1043  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
1044  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
1045  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
1046  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
1047  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
1048  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
1049  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
1050  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
1051 
1052  O(4, 2) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
1053  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
1054  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
1055  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
1056  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
1057  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
1058  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
1059  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
1060  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
1061  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
1062  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
1063  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
1064  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
1065  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
1066  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
1067  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
1068  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
1069  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
1070  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
1071  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
1072  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
1073  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
1074  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
1075  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
1076  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
1077  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
1078  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
1079  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
1080  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
1081  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
1082  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
1083  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
1084  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
1085  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
1086  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
1087  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
1088  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
1089  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
1090  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
1091  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
1092  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
1093  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
1094  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
1095  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
1096  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
1097 
1098  O(4, 3) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
1099  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
1100  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
1101  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
1102  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
1103  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
1104  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
1105  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
1106  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
1107  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
1108  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
1109  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
1110  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
1111  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
1112  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
1113  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
1114  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
1115  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
1116  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
1117  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
1118  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
1119  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
1120  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
1121  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
1122  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
1123  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
1124  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
1125  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
1126  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
1127  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
1128  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
1129  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
1130  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
1131  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
1132  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
1133  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
1134  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
1135  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
1136  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
1137  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
1138  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
1139  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
1140  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
1141  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
1142  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
1143 
1144  O(4, 4) = (M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
1145  - M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
1146  + M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
1147  + M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
1148  - M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
1149  + M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
1150  - M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
1151  + M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
1152  - M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1))
1153  / (M(0, 0) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 4) - M(0, 0) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 3)
1154  - M(0, 0) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 4) + M(0, 0) * M(1, 1) * M(2, 3) * M(3, 4) * M(4, 2)
1155  + M(0, 0) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 3) - M(0, 0) * M(1, 1) * M(2, 4) * M(3, 3) * M(4, 2)
1156  + M(0, 0) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 4) - M(0, 0) * M(1, 3) * M(2, 1) * M(3, 4) * M(4, 2)
1157  - M(0, 0) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 4) + M(0, 0) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 1)
1158  + M(0, 0) * M(1, 3) * M(2, 4) * M(3, 1) * M(4, 2) - M(0, 0) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 1)
1159  - M(0, 0) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 3) + M(0, 0) * M(1, 4) * M(2, 1) * M(3, 3) * M(4, 2)
1160  + M(0, 0) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 3) - M(0, 0) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 1)
1161  - M(0, 0) * M(1, 4) * M(2, 3) * M(3, 1) * M(4, 2) + M(0, 0) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 1)
1162  - M(0, 1) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 4) + M(0, 1) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 3)
1163  + M(0, 1) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 4) - M(0, 1) * M(1, 0) * M(2, 3) * M(3, 4) * M(4, 2)
1164  - M(0, 1) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 3) + M(0, 1) * M(1, 0) * M(2, 4) * M(3, 3) * M(4, 2)
1165  - M(0, 1) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 4) + M(0, 1) * M(1, 3) * M(2, 0) * M(3, 4) * M(4, 2)
1166  + M(0, 1) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 4) - M(0, 1) * M(1, 3) * M(2, 2) * M(3, 4) * M(4, 0)
1167  - M(0, 1) * M(1, 3) * M(2, 4) * M(3, 0) * M(4, 2) + M(0, 1) * M(1, 3) * M(2, 4) * M(3, 2) * M(4, 0)
1168  + M(0, 1) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 3) - M(0, 1) * M(1, 4) * M(2, 0) * M(3, 3) * M(4, 2)
1169  - M(0, 1) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 3) + M(0, 1) * M(1, 4) * M(2, 2) * M(3, 3) * M(4, 0)
1170  + M(0, 1) * M(1, 4) * M(2, 3) * M(3, 0) * M(4, 2) - M(0, 1) * M(1, 4) * M(2, 3) * M(3, 2) * M(4, 0)
1171  - M(0, 3) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 4) + M(0, 3) * M(1, 0) * M(2, 1) * M(3, 4) * M(4, 2)
1172  + M(0, 3) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 4) - M(0, 3) * M(1, 0) * M(2, 2) * M(3, 4) * M(4, 1)
1173  - M(0, 3) * M(1, 0) * M(2, 4) * M(3, 1) * M(4, 2) + M(0, 3) * M(1, 0) * M(2, 4) * M(3, 2) * M(4, 1)
1174  + M(0, 3) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 4) - M(0, 3) * M(1, 1) * M(2, 0) * M(3, 4) * M(4, 2)
1175  - M(0, 3) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 4) + M(0, 3) * M(1, 1) * M(2, 2) * M(3, 4) * M(4, 0)
1176  + M(0, 3) * M(1, 1) * M(2, 4) * M(3, 0) * M(4, 2) - M(0, 3) * M(1, 1) * M(2, 4) * M(3, 2) * M(4, 0)
1177  + M(0, 3) * M(1, 4) * M(2, 0) * M(3, 1) * M(4, 2) - M(0, 3) * M(1, 4) * M(2, 0) * M(3, 2) * M(4, 1)
1178  - M(0, 3) * M(1, 4) * M(2, 1) * M(3, 0) * M(4, 2) + M(0, 3) * M(1, 4) * M(2, 1) * M(3, 2) * M(4, 0)
1179  + M(0, 3) * M(1, 4) * M(2, 2) * M(3, 0) * M(4, 1) - M(0, 3) * M(1, 4) * M(2, 2) * M(3, 1) * M(4, 0)
1180  + M(0, 4) * M(1, 0) * M(2, 1) * M(3, 2) * M(4, 3) - M(0, 4) * M(1, 0) * M(2, 1) * M(3, 3) * M(4, 2)
1181  - M(0, 4) * M(1, 0) * M(2, 2) * M(3, 1) * M(4, 3) + M(0, 4) * M(1, 0) * M(2, 2) * M(3, 3) * M(4, 1)
1182  + M(0, 4) * M(1, 0) * M(2, 3) * M(3, 1) * M(4, 2) - M(0, 4) * M(1, 0) * M(2, 3) * M(3, 2) * M(4, 1)
1183  - M(0, 4) * M(1, 1) * M(2, 0) * M(3, 2) * M(4, 3) + M(0, 4) * M(1, 1) * M(2, 0) * M(3, 3) * M(4, 2)
1184  + M(0, 4) * M(1, 1) * M(2, 2) * M(3, 0) * M(4, 3) - M(0, 4) * M(1, 1) * M(2, 2) * M(3, 3) * M(4, 0)
1185  - M(0, 4) * M(1, 1) * M(2, 3) * M(3, 0) * M(4, 2) + M(0, 4) * M(1, 1) * M(2, 3) * M(3, 2) * M(4, 0)
1186  - M(0, 4) * M(1, 3) * M(2, 0) * M(3, 1) * M(4, 2) + M(0, 4) * M(1, 3) * M(2, 0) * M(3, 2) * M(4, 1)
1187  + M(0, 4) * M(1, 3) * M(2, 1) * M(3, 0) * M(4, 2) - M(0, 4) * M(1, 3) * M(2, 1) * M(3, 2) * M(4, 0)
1188  - M(0, 4) * M(1, 3) * M(2, 2) * M(3, 0) * M(4, 1) + M(0, 4) * M(1, 3) * M(2, 2) * M(3, 1) * M(4, 0));
1189 
1190  return O;
1191 };

◆ cpuvoigtian()

fptype GooFit::cpuvoigtian ( fptype  x,
fptype  m,
fptype  w,
fptype  s 
)

Definition at line 122 of file Faddeeva.cpp.

References Faddeeva_2().

122  {
123  // This calculation includes the normalisation - integral
124  // over the reals is equal to one.
125 
126  // return constant for zero width and sigma
127  if((0 == s) && (0 == w))
128  return 1;
129 
130  if(s <= 0 || w <= 0)
131  throw GooFit::GeneralError("s {} and w {} must be larger than 0", s, w);
132 
133  fptype coef = -0.5 / (s * s);
134  fptype arg = x - m;
135 
136  // Breit-Wigner for zero sigma
137  if(0 == s)
138  return (1 / (arg * arg + 0.25 * w * w));
139 
140  // Gauss for zero width
141  if(0 == w)
142  return exp(coef * arg * arg);
143 
144  // actual Voigtian for non-trivial width and sigma
145  fptype c = 1. / (sqrt(2) * s);
146  fptype a = 0.5 * c * w;
147  fptype u = c * arg;
148  fpcomplex z(u, a);
149  // printf("Calling Faddeeva %f %f %f %f %f %f %f\n", x, m, s, w, c, a, u);
150  fpcomplex v = Faddeeva_2(z);
151 
152  static const fptype rsqrtPi = 0.5641895835477563;
153  return c * rsqrtPi * v.real();
154 }
Thrown when a general error is encountered.
Definition: Error.h:10
double fptype
thrust::complex< fptype > fpcomplex
Definition: Complex.h:8
fpcomplex Faddeeva_2(const fpcomplex &z)
Definition: Faddeeva.cpp:46

◆ dampingFactorSquare()

__device__ fptype GooFit::dampingFactorSquare ( const fptype cmmom,
const int &  spin,
const fptype mRadius 
)

◆ dev_powi()

__device__ int GooFit::dev_powi ( int  base,
int  exp 
)

Referenced by evalfunc_to_string().

◆ enum_to_underlying()

template<typename E >
constexpr std::underlying_type<E>::type GooFit::enum_to_underlying ( e)

Definition at line 21 of file DalitzPlotHelpers.h.

References get4Vecs(), getmass(), getResonanceAmplitude(), inDalitz(), m12, and m13.

21  {
22  return static_cast<typename std::underlying_type<E>::type>(e);
23 }

◆ evalfunc_to_string()

constexpr const char* GooFit::evalfunc_to_string ( EvalFunc  val)

Definition at line 20 of file GooPdf.h.

References dev_powi(), evalfunc_vals, getMetricPointer(), and maxParams.

20 { return evalfunc_vals[static_cast<size_t>(val)]; }
constexpr const char * evalfunc_vals[]
Definition: GooPdf.h:18

◆ Faddeeva_2()

fpcomplex GooFit::Faddeeva_2 ( const fpcomplex z)

Definition at line 46 of file Faddeeva.cpp.

References M_2PI.

Referenced by cpuvoigtian().

46  {
47  fptype *n, *e, t, u, r, s, d, f, g, h;
48  fpcomplex c, d2, v, w;
49  int i;
50 
51  s = norm(z); // Actually the square of the norm. Don't ask me, I didn't name the function.
52 
53  if(s < 1e-7) {
54  // use Pade approximation
55  fpcomplex zz = z * z;
56  v = exp(zz);
57  c = C[0];
58  d2 = D[0];
59 
60  for(i = 1; i <= 6; i++) {
61  c = c * zz + C[i];
62  d2 = d2 * zz + D[i];
63  }
64 
65  w = fptype(1.0) / v + fpcomplex(0.0, M_2_SQRTPI) * c / d2 * z * v;
66  return w;
67  }
68 
69  // use trapezoid rule
70  // select default table 1
71  n = n1;
72  e = e1;
73  r = M_1_PI * 0.5;
74 
75  // if z is too close to a pole select table 2
76  if(fabs(z.imag()) < 0.01 && fabs(z.real()) < 6.01) {
77  h = fabs(z.real()) * 2;
78  // Equivalent to modf(h, &g). Do this way because nvcc only knows about double version of modf.
79  g = floor(h);
80  h -= g;
81 
82  if(h < 0.02 || h > 0.98) {
83  n = n2;
84  e = e2;
85  r = M_1_PI * 0.53;
86  }
87  }
88 
89  d = (z.imag() - z.real()) * (z.imag() + z.real());
90  f = 4 * z.real() * z.real() * z.imag() * z.imag();
91 
92  g = h = 0.0;
93 
94  for(i = 0; i < 12; i++) {
95  t = d + n[i];
96  u = e[i] / (t * t + f);
97  g += (s + n[i]) * u;
98  h += (s - n[i]) * u;
99  }
100 
101  u = 1 / s;
102 
103  c = r * fpcomplex(z.imag() * (u + 2.0 * g), z.real() * (u + 2.0 * h));
104 
105  if(z.imag() < M_2PI) {
106  s = 2.0 / r;
107  t = s * z.real();
108  u = s * z.imag();
109  s = sin(t);
110  h = cos(t);
111  f = exp(-u) - h;
112  g = 2.0 * exp(d - u) / (s * s + f * f);
113  u = 2.0 * z.real() * z.imag();
114  h = cos(u);
115  t = sin(u);
116  c += g * fpcomplex((h * f - t * s), -(h * s + t * f));
117  }
118 
119  return c;
120 }
double fptype
thrust::complex< fptype > fpcomplex
Definition: Complex.h:8
#define M_2PI
Definition: Faddeeva.cpp:10

◆ fillDataSetMC1D()

void GooFit::fillDataSetMC1D ( GooPdf pdf,
Observable  var,
size_t  nTotal,
unsigned int  seed = 0 
)
inline

Definition at line 13 of file MonteCarlo.h.

References data, GooFit::UnbinnedDataSet::fillWithGrid(), GooFit::Observable::getBinSize(), GooFit::GooPdf::getCompProbsAtDataPoints(), GooFit::PdfBase::getData(), GooFit::UnbinnedDataSet::getValue(), GooFit::PdfBase::setData(), and GooFit::Indexable::setValue().

13  {
14  // Setup bins
15  UnbinnedDataSet data{var};
16  data.fillWithGrid();
17  auto origdata = pdf.getData();
18 
19  if(origdata == nullptr)
20  throw GeneralError("Can't run on a PDF with no DataSet to fill!");
21 
22  pdf.setData(&data);
23  std::vector<double> pdfValues = pdf.getCompProbsAtDataPoints()[0];
24 
25  // Setup random numbers
26  if(seed == 0) {
27  std::random_device rd;
28  seed = rd();
29  }
30  std::mt19937 gen(seed);
31 
32  // Poisson distribution
33  std::poisson_distribution<> d(nTotal);
34  size_t num_events = d(gen);
35 
36  // Uniform distribution
37  std::uniform_real_distribution<> unihalf(-.5, .5);
38  std::uniform_real_distribution<> uniwhole(0.0, 1.0);
39 
40  // CumSum in other languages
41  std::vector<double> integral(pdfValues.size());
42  std::partial_sum(pdfValues.begin(), pdfValues.end(), integral.begin());
43 
44  // Make this a 0-1 fraction by dividing by the end value
45  std::for_each(integral.begin(), integral.end(), [&integral](double &val) { val /= integral.back(); });
46 
47  for(size_t i = 0; i < num_events; i++) {
48  double r = uniwhole(gen);
49 
50  // Binary search for integral[cell-1] < r < integral[cell]
51  size_t j = std::lower_bound(integral.begin(), integral.end(), r) - integral.begin();
52 
53  // Fill in the grid randomly
54  double varValue = data.getValue(var, j) + var.getBinSize() * unihalf(gen);
55 
56  var.setValue(varValue);
57  origdata->addEvent();
58  }
59 
60  pdf.setData(origdata);
61 }
UnbinnedDataSet * data

◆ flatten()

template<typename T >
std::vector<T> GooFit::flatten ( const std::vector< thrust::complex< T >> &  input)

Flatten a complex array into a standard one (1r, 1i, 2r, 2i, ...)

Definition at line 11 of file ComplexUtils.h.

11  {
12  std::vector<T> output;
13  for(auto val : input) {
14  output.push_back(val.real());
15  output.push_back(val.imag());
16  }
17  return output;
18 }

◆ format_arg()

void GooFit::format_arg ( fmt::BasicFormatter< char > &  f,
const char *&  format_str,
const Uncertain s 
)
inline

fmt support

Definition at line 101 of file Uncertain.h.

References GooFit::Uncertain::get_uncertainty(), and GooFit::Uncertain::get_value().

101  {
102  std::string value{format_str};
103  auto end = value.find('}');
104  std::string val = std::string{"{" + value.substr(0, end) + "}"};
105 
106  f.writer().write(val.c_str(), s.get_value());
107  f.writer().write(" ± ");
108  f.writer().write(val.c_str(), s.get_uncertainty());
109 
110  format_str += end + 1; // Remove :xxx}
111 }

◆ get4Vecs()

__device__ void GooFit::get4Vecs ( fptype Vecs,
const unsigned int &  constants,
const fptype m12,
const fptype m34,
const fptype cos12,
const fptype cos34,
const fptype phi 
)

Referenced by enum_to_underlying().

◆ getmass()

__device__ fptype GooFit::getmass ( const unsigned int &  pair,
fptype d1,
fptype d2,
const fptype vecs,
const fptype m1,
const fptype m2,
const fptype m3,
const fptype m4 
)

Referenced by enum_to_underlying().

◆ getMetricPointer()

void* GooFit::getMetricPointer ( std::string  name)

Referenced by evalfunc_to_string().

◆ getResonanceAmplitude()

__device__ fpcomplex GooFit::getResonanceAmplitude ( fptype  m12,
fptype  m13,
fptype  m23,
unsigned int  functionIdx,
unsigned int  pIndex 
)

Referenced by enum_to_underlying().

◆ gooFree()

cudaError_t GooFit::gooFree ( void *  ptr)

◆ gooMalloc()

cudaError_t GooFit::gooMalloc ( void **  target,
size_t  bytes 
)

◆ inDalitz()

__host__ __device__ bool GooFit::inDalitz ( const fptype m12,
const fptype m13,
const fptype bigM,
const fptype dm1,
const fptype dm2,
const fptype dm3 
)

◆ LeviCivita() [1/2]

__device__ fptype GooFit::LeviCivita ( const gpuLVec &  p1,
const gpuLVec &  p2,
const gpuLVec &  p3,
const gpuLVec &  p4 
)

Definition at line 406 of file SpinHelper.h.

406  {
407  // this calculates the determinant of the 4x4 matrix build out of p1,p2,p3,p4
408  return p1.GetZ() * p2.GetY() * p3.GetX() * p4.GetE() - p1.GetY() * p2.GetZ() * p3.GetX() * p4.GetE()
409  - p1.GetZ() * p2.GetX() * p3.GetY() * p4.GetE() + p1.GetX() * p2.GetZ() * p3.GetY() * p4.GetE()
410  + p1.GetY() * p2.GetX() * p3.GetZ() * p4.GetE() - p1.GetX() * p2.GetY() * p3.GetZ() * p4.GetE()
411  - p1.GetZ() * p2.GetY() * p3.GetE() * p4.GetX() + p1.GetY() * p2.GetZ() * p3.GetE() * p4.GetX()
412  + p1.GetZ() * p2.GetE() * p3.GetY() * p4.GetX() - p1.GetE() * p2.GetZ() * p3.GetY() * p4.GetX()
413  - p1.GetY() * p2.GetE() * p3.GetZ() * p4.GetX() + p1.GetE() * p2.GetY() * p3.GetZ() * p4.GetX()
414  + p1.GetZ() * p2.GetX() * p3.GetE() * p4.GetY() - p1.GetX() * p2.GetZ() * p3.GetE() * p4.GetY()
415  - p1.GetZ() * p2.GetE() * p3.GetX() * p4.GetY() + p1.GetE() * p2.GetZ() * p3.GetX() * p4.GetY()
416  + p1.GetX() * p2.GetE() * p3.GetZ() * p4.GetY() - p1.GetE() * p2.GetX() * p3.GetZ() * p4.GetY()
417  - p1.GetY() * p2.GetX() * p3.GetE() * p4.GetZ() + p1.GetX() * p2.GetY() * p3.GetE() * p4.GetZ()
418  + p1.GetY() * p2.GetE() * p3.GetX() * p4.GetZ() - p1.GetE() * p2.GetY() * p3.GetX() * p4.GetZ()
419  - p1.GetX() * p2.GetE() * p3.GetY() * p4.GetZ() + p1.GetE() * p2.GetX() * p3.GetY() * p4.GetZ();
420 }

◆ LeviCivita() [2/2]

__device__ gpuLVec GooFit::LeviCivita ( const gpuLVec &  a,
const gpuLVec &  b,
const gpuLVec &  c 
)
inline

Definition at line 422 of file SpinHelper.h.

422  {
423  gpuLVec v;
424 
425  v.SetE(-1. * a.GetX() * (b.GetY() * c.GetZ() - b.GetZ() * c.GetY())
426  - a.GetY() * (b.GetZ() * c.GetX() - b.GetX() * c.GetZ())
427  - a.GetZ() * (b.GetX() * c.GetY() - b.GetY() * c.GetX()));
428 
429  v.SetZ(a.GetX() * (b.GetE() * c.GetY() - b.GetY() * c.GetE())
430  + a.GetY() * (b.GetX() * c.GetE() - b.GetE() * c.GetX())
431  + a.GetE() * (b.GetY() * c.GetX() - b.GetX() * c.GetY()));
432 
433  v.SetY(a.GetX() * (b.GetZ() * c.GetE() - b.GetE() * c.GetZ())
434  + a.GetZ() * (b.GetE() * c.GetX() - b.GetX() * c.GetE())
435  + a.GetE() * (b.GetX() * c.GetZ() - b.GetZ() * c.GetX()));
436 
437  v.SetX(a.GetY() * (b.GetE() * c.GetZ() - b.GetZ() * c.GetE())
438  + a.GetZ() * (b.GetY() * c.GetE() - b.GetE() * c.GetY())
439  + a.GetE() * (b.GetZ() * c.GetY() - b.GetY() * c.GetZ()));
440 
441  return v;
442 }

◆ make_a_grid()

void GooFit::make_a_grid ( std::vector< Observable ret,
UnbinnedDataSet grid,
Observable eventNum 
)

Definition at line 67 of file UnbinnedDataSet.cpp.

References GooFit::UnbinnedDataSet::addEvent(), GooFit::Indexable::getLowerLimit(), GooFit::Observable::getNumBins(), GooFit::Indexable::getUpperLimit(), GooFit::Indexable::getValue(), GooFit::Observable::isEventNumber(), and GooFit::Indexable::setValue().

Referenced by GooFit::UnbinnedDataSet::fillWithGrid().

67  {
68  if(ret.empty()) {
69  grid->addEvent();
70 
71  if(eventNum != nullptr)
72  eventNum->setValue(eventNum->getValue() + 1);
73 
74  return;
75  }
76 
77  Observable var = ret.back();
78  ret.pop_back(); // safe because this is a copy
79 
80  if(var.isEventNumber()) { // Skip
81  make_a_grid(ret, grid, eventNum);
82  } else {
83  for(int i = 0; i < var.getNumBins(); ++i) {
84  double step = (var.getUpperLimit() - var.getLowerLimit()) / var.getNumBins();
85  var.setValue(var.getLowerLimit() + (i + 0.5) * step);
86  make_a_grid(ret, grid, eventNum);
87  }
88  }
89 }
void make_a_grid(std::vector< Observable > ret, UnbinnedDataSet *grid, Observable *eventNum)

◆ max_fitter_index()

int GooFit::max_fitter_index ( const std::vector< Variable > &  vars)

Get the max fitter index of a variable from a list.

Definition at line 28 of file Variable.cpp.

References GooFit::Variable::getFitterIndex().

Referenced by GooFit::Params::make_minuit_vector(), and GooFit::EventNumber::operator=().

28  {
29  const Variable max_ind_ptr
30  = *std::max_element(std::begin(vars), std::end(vars), [](const Variable &a, const Variable &b) {
31  return a.getFitterIndex() < b.getFitterIndex();
32  });
33  return max_ind_ptr.getFitterIndex();
34 }

◆ max_index() [1/2]

int GooFit::max_index ( const std::vector< Variable > &  vars)

Get the max index of a variable from a list.

Definition at line 8 of file Variable.cpp.

References GooFit::Indexable::getIndex().

Referenced by GooFit::Minuit1::Eval(), GooFit::Params::from_minuit_vector(), and GooFit::EventNumber::operator=().

8  {
9  if(vars.empty())
10  return -1;
11  const Variable &max_ind_ptr
12  = *std::max_element(std::begin(vars), std::end(vars), [](const Variable &a, const Variable &b) {
13  return a.getIndex() < b.getIndex();
14  });
15  return max_ind_ptr.getIndex();
16 }

◆ max_index() [2/2]

int GooFit::max_index ( const std::vector< Observable > &  vars)

Definition at line 18 of file Variable.cpp.

References GooFit::Indexable::getIndex().

18  {
19  if(vars.empty())
20  return -1;
21  const Observable &max_ind_ptr
22  = *std::max_element(std::begin(vars), std::end(vars), [](const Observable &a, const Observable &b) {
23  return a.getIndex() < b.getIndex();
24  });
25  return max_ind_ptr.getIndex();
26 }

◆ operator*() [1/4]

__device__ gpuLVec GooFit::operator* ( gpuLVec  lhs,
fptype  rhs 
)

Definition at line 74 of file SpinHelper.h.

74 { return lhs *= rhs; }

◆ operator*() [2/4]

__device__ gpuLVec GooFit::operator* ( fptype  lhs,
gpuLVec  rhs 
)

Definition at line 75 of file SpinHelper.h.

75 { return rhs *= lhs; }

◆ operator*() [3/4]

Uncertain GooFit::operator* ( fptype  other,
const Uncertain self 
)
inline

Allow int and float multiplies.

Definition at line 91 of file Uncertain.h.

References GooFit::Uncertain::get_uncertainty(), GooFit::Uncertain::get_value(), and GooFit::Uncertain::Uncertain().

91  {
92  return Uncertain(self.get_value() * other, self.get_uncertainty() * other);
93 }

◆ operator*() [4/4]

__device__ SymmLorentzMatrix GooFit::operator* ( fptype  lhs,
const SymmLorentzMatrix rhs 
)

Definition at line 372 of file SpinHelper.h.

372  {
373  SymmLorentzMatrix returnVal(rhs);
374  returnVal *= lhs;
375  return returnVal;
376 }

◆ operator+()

__device__ gpuLVec GooFit::operator+ ( gpuLVec  lhs,
const gpuLVec &  rhs 
)

Definition at line 72 of file SpinHelper.h.

72 { return lhs += rhs; }

◆ operator-()

__device__ gpuLVec GooFit::operator- ( gpuLVec  lhs,
const gpuLVec &  rhs 
)

Definition at line 73 of file SpinHelper.h.

73 { return lhs -= rhs; }

◆ operator/()

__device__ SymmLorentzMatrix GooFit::operator/ ( fptype  lhs,
const SymmLorentzMatrix rhs 
)

Definition at line 377 of file SpinHelper.h.

377  {
378  SymmLorentzMatrix returnVal(rhs);
379  returnVal /= lhs;
380  return returnVal;
381 }

◆ operator<<() [1/3]

std::ostream& GooFit::operator<< ( std::ostream &  stream,
Uncertain  value 
)
inline

Simple << output.

Definition at line 96 of file Uncertain.h.

References GooFit::Uncertain::get_uncertainty(), and GooFit::Uncertain::get_value().

Referenced by GooFit::EventNumber::operator=().

96  {
97  return stream << value.get_value() << " ± " << value.get_uncertainty();
98 }

◆ operator<<() [2/3]

std::ostream & GooFit::operator<< ( std::ostream &  o,
const GooFit::Variable var 
)

Nice print of Variable.

Definition at line 36 of file Variable.cpp.

References GooFit::Variable::blind, GooFit::Variable::getError(), GooFit::Variable::getFitterIndex(), GooFit::Indexable::getIndex(), GooFit::Indexable::getLowerLimit(), GooFit::Indexable::getName(), GooFit::Indexable::getUpperLimit(), GooFit::Indexable::getValue(), and GooFit::Variable::IsFixed().

36  {
37  o << var.getName() << ": " << var.getValue() << " +/- " << var.getError();
38  if(!var.IsFixed())
39  o << " [" << var.getLowerLimit() << ", " << var.getUpperLimit() << "]";
40  if(var.getIndex() >= 0)
41  o << " GooFit index: " << var.getIndex();
42  if(var.getFitterIndex() >= 0)
43  o << " Fitter index: " << var.getFitterIndex();
44  if(*var.blind != 0)
45  o << " Blinded";
46 
47  return o;
48 }
int getFitterIndex() const
Get the index from the fitter.
Definition: Variable.h:194
int getIndex() const
Get the GooFit index.
Definition: Variable.h:58
std::shared_ptr< fptype > blind
A blinding value to add.
Definition: Variable.h:227
fptype getLowerLimit() const
Get the lower limit.
Definition: Variable.h:78
fptype getValue() const
Get the value.
Definition: Variable.h:68
fptype getUpperLimit() const
Get the upper limit.
Definition: Variable.h:73
bool IsFixed() const
Check to see if this is a constant.
Definition: Variable.h:202
fptype getError() const
Get the error.
Definition: Variable.h:189
const std::string & getName() const
Get the name.
Definition: Variable.h:63

◆ operator<<() [3/3]

std::ostream & GooFit::operator<< ( std::ostream &  o,
const GooFit::Observable var 
)

Nice print of Observable.

Definition at line 50 of file Variable.cpp.

References GooFit::Indexable::getIndex(), GooFit::Indexable::getLowerLimit(), GooFit::Indexable::getName(), GooFit::Observable::getNumBins(), GooFit::Indexable::getUpperLimit(), and GooFit::Indexable::getValue().

50  {
51  o << var.getName() << ": " << var.getValue() << " (" << var.getNumBins() << " bins)";
52  o << " [" << var.getLowerLimit() << ", " << var.getUpperLimit() << "]";
53  if(var.getIndex() >= 0)
54  o << " GooFit index: " << var.getIndex();
55 
56  return o;
57 }
size_t getNumBins() const
Get the number of bins.
Definition: Variable.h:130
int getIndex() const
Get the GooFit index.
Definition: Variable.h:58
fptype getLowerLimit() const
Get the lower limit.
Definition: Variable.h:78
fptype getValue() const
Get the value.
Definition: Variable.h:68
fptype getUpperLimit() const
Get the upper limit.
Definition: Variable.h:73
const std::string & getName() const
Get the name.
Definition: Variable.h:63

◆ operator>>()

std::istream & GooFit::operator>> ( std::istream &  i,
GooFit::Observable var 
)

Allow Observable to be read in.

Definition at line 59 of file Variable.cpp.

References GooFit::Indexable::value.

Referenced by GooFit::EventNumber::operator=().

59 { return i >> *var.value; }
std::shared_ptr< fptype > value
The value of the variable.
Definition: Variable.h:28

◆ print_goofit_info()

void GooFit::print_goofit_info ( int  gpuDev_ = 0)

Print out information about GooFit.

Definition at line 74 of file Application.cpp.

References GOOFIT_DEBUG, GOOFIT_INFO, red, and reset.

Referenced by GooFit::Application::pre_callback().

74  {
75  GOOFIT_INFO("GooFit: Version {} ({}) Commit: {}", GOOFIT_VERSION, GOOFIT_TAG, GOOFIT_GIT_VERSION);
76 
77 #if THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA
78  cudaDeviceProp devProp;
79  cudaGetDeviceProperties(&devProp, gpuDev_);
80 
81  GOOFIT_INFO("CUDA: Device {}: {}", gpuDev_, devProp.name);
82 
83  GOOFIT_INFO("CUDA: Compute {}.{}", devProp.major, devProp.minor);
84  GOOFIT_INFO("CUDA: Total global memory: {} GB", devProp.totalGlobalMem / 1.0e9);
85  GOOFIT_INFO("CUDA: Multiprocessors: {}", devProp.multiProcessorCount);
86 
87  GOOFIT_DEBUG("CUDA: Total amount of shared memory per block: {}", devProp.sharedMemPerBlock);
88  GOOFIT_DEBUG("CUDA: Total registers per block: {}", devProp.regsPerBlock);
89  GOOFIT_DEBUG("CUDA: Warp size: {}", devProp.warpSize);
90  GOOFIT_DEBUG("CUDA: Maximum memory pitch: {}", devProp.memPitch);
91  GOOFIT_DEBUG("CUDA: Total amount of constant memory: {}", devProp.totalConstMem);
92 
93 #elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_OMP
94  GOOFIT_INFO("OMP: Number of threads: {}", omp_get_max_threads());
95 #elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_TBB
96  GOOFIT_INFO("TBB: Backend selected");
97 #elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CPP
98  GOOFIT_INFO("CPP: Single threaded mode");
99 #endif
100 
101 #if GOOFIT_ROOT_FOUND
102  GOOFIT_INFO("ROOT: Found");
103 #else
104  GOOFIT_INFO("ROOT: Not found");
105 #endif
106 
107  // Print out warnings if not fully optimized
108  std::cout << red;
109  FeatureDetector::cpu_x86::print_warnings();
110  std::cout << GooFit::reset << std::flush;
111 
112 #if THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA
113  int deviceCount;
114  cudaGetDeviceCount(&deviceCount);
115 
116  for(int i = 0; i < deviceCount; i++) {
117  cudaDeviceProp deviceProp;
118  cudaGetDeviceProperties(&deviceProp, i);
119  GOOFIT_INFO("CUDA: Device {} has compute capability {}.{}", i, deviceProp.major, deviceProp.minor);
120  }
121 #endif
122 }
#define GOOFIT_INFO(...)
Definition: Log.h:10
constexpr rang::fg const red
Definition: Color.h:9
#define GOOFIT_DEBUG(...)
Definition: Log.h:96
constexpr rang::style const reset
Definition: Color.h:16

◆ print_splash()

void GooFit::print_splash ( )

Optional print for splash Orignal: Slant Relief from http://patorjk.com/software/taag/#p=testall&f=Wavy&t=GooFit (tightened a bit) New: Block letters

Definition at line 31 of file Application.cpp.

References dim, green, and reset.

Referenced by GooFit::Application::pre_callback().

31  {
32  std::cout << reset << green << " Welcome to";
33 #if GOOFIT_SPLASH
34  // Just in case, for clang format:
35  // clang-format off
36  std::string splash = R"raw(
37  ██████╗ ████████╗
38  ██╔════╝ █████╗ █████╗ ██╔═════╝ ██╗
39  ██║ ███╗██╔══██╗██╔══██╗█████╗██╗██████╗
40  ██║ ██║██║ ██║██║ ██║██╔══╝██║╚═██╔═╝
41  ╚██████╔╝╚█████╔╝╚█████╔╝██║ ██║ ██║
42  ╚═════╝ ╚════╝ ╚════╝ ╚═╝ ╚═╝ ██║
43  ███████║
44  ╚══════╝
45  )raw";
46  // clang-format on
47 
48  std::cout << reset << dim;
49  bool cur_green = false;
50  for(int i = 0; i < splash.size(); i++) {
51  std::string letter = splash.substr(i, 3);
52  bool is_edge
53  = letter == "╚" || letter == "╝" || letter == "╗" || letter == "╔" || letter == "║" || letter == "═";
54  bool is_block = letter == "█";
55 
56  if(is_block && !cur_green) {
57  std::cout << reset << green;
58  cur_green = true;
59  } else if(is_edge && cur_green) {
60  std::cout << reset << dim;
61  cur_green = false;
62  }
63  std::cout << splash[i];
64  if(splash[i] == '\n')
65  std::cout << std::flush;
66  }
67 #else
68  std::cout << " GooFit\n";
69 #endif
70 
71  std::cout << reset << std::flush;
72 }
constexpr rang::style const dim
Definition: Color.h:18
constexpr rang::style const reset
Definition: Color.h:16
constexpr rang::fg const green
Definition: Color.h:10

◆ read_csv()

template<typename M >
M GooFit::read_csv ( std::string  name,
bool  comma = true 
)

Definition at line 10 of file Eigen.h.

10  {
11  using namespace Eigen;
12 
13  std::ifstream input(name);
14 
15  std::string line;
16  std::vector<typename M::Scalar> values;
17  size_t rows = 0;
18  while(std::getline(input, line)) {
19  std::stringstream lineStream(line);
20  std::string cell;
21  typename M::Scalar value;
22 
23  if(comma)
24  while(std::getline<char>(lineStream, cell, ','))
25  values.push_back(std::stod(cell));
26  else
27  while(lineStream >> value)
28  values.push_back(value);
29 
30  ++rows;
31  }
32  return Map<const Matrix<typename M::Scalar, M::RowsAtCompileTime, M::ColsAtCompileTime, ColMajor>>(
33  values.data(), values.size() / rows, rows);
34 };

◆ readFromFile()

void GooFit::readFromFile ( PdfBase pdf,
const char *  fname 
)

Definition at line 23 of file FunctorWriter.cpp.

References GooFit::PdfBase::getParameters(), GooFit::Variable::setError(), GooFit::Indexable::setLowerLimit(), GooFit::Indexable::setUpperLimit(), and GooFit::Indexable::setValue().

Referenced by makeOverallSignal(), and runCanonicalFit().

23  {
24  std::vector<Variable> params = pdf->getParameters();
25 
26  std::map<std::string, Variable *> tempMap;
27 
28  for(Variable &p : params) {
29  tempMap[p.getName()] = &p;
30  }
31 
32  std::ifstream reader;
33  reader.open(fname);
34  std::string buffer;
35  char discard[1000];
36  int numSet = 0;
37 
38  while(true) {
39  reader >> buffer;
40 
41  if(reader.eof())
42  break;
43 
44  Variable *var = tempMap[buffer];
45 
46  fptype value, error, lowerlimit, upperlimit;
47  size_t numbins;
48 
49  if(var) {
50  reader >> value >> error >> numbins >> lowerlimit >> upperlimit;
51 
52  var->setValue(value);
53  var->setError(error);
54  var->setLowerLimit(lowerlimit);
55  var->setUpperLimit(upperlimit);
56 
57  if(++numSet == tempMap.size())
58  break;
59  } else {
60  reader.getline(discard, 1000);
61  }
62  }
63 
64  reader.close();
65 }
double fptype

◆ readListOfNumbers()

void GooFit::readListOfNumbers ( thrust::host_vector< fptype > &  target,
const char *  fname 
)

Definition at line 67 of file FunctorWriter.cpp.

67  {
68  std::ifstream reader;
69  reader.open(fname);
70  fptype buffer = 0;
71 
72  while(true) {
73  reader >> buffer;
74 
75  if(reader.eof())
76  break;
77 
78  target.push_back(buffer);
79  }
80 
81  reader.close();
82 }
double fptype

◆ signal_handler()

void GooFit::signal_handler ( int  s)

will call the correct exit func, no unwinding of the stack though

Definition at line 25 of file Application.cpp.

References bold, red, and reset.

Referenced by GooFit::Application::Application().

25  {
26  std::cout << std::endl << reset << red << bold;
27  std::cout << "GooFit: Control-C detected, exiting..." << reset << std::endl;
28  std::exit(1);
29 }
constexpr rang::style const bold
Definition: Color.h:17
constexpr rang::fg const red
Definition: Color.h:9
constexpr rang::style const reset
Definition: Color.h:16

◆ spinFactor()

__device__ fptype GooFit::spinFactor ( unsigned int  spin,
fptype  motherMass,
fptype  daug1Mass,
fptype  daug2Mass,
fptype  daug3Mass,
fptype  m12,
fptype  m13,
fptype  m23,
unsigned int  cyclic_index 
)

◆ to_5param()

Eigen::Matrix<fptype, 5, Eigen::Dynamic> GooFit::to_5param ( const Eigen::Matrix< fptype, 16, Eigen::Dynamic > &  mat)

This is a helper to convert values. It copies back and forth, so is only to be used in scripts.

Definition at line 11 of file UserUtils.h.

11  {
12  mcbooster::Particles_h h_p0(mat.cols());
13  mcbooster::Particles_h h_p1(mat.cols());
14  mcbooster::Particles_h h_p2(mat.cols());
15  mcbooster::Particles_h h_p3(mat.cols());
16 
17  for(int i = 0; i < mat.cols(); i++) {
18  h_p0[i].set(mat(3, i), mat(0, i), mat(1, i), mat(2, i));
19  h_p1[i].set(mat(7, i), mat(4, i), mat(5, i), mat(6, i));
20  h_p2[i].set(mat(11, i), mat(8, i), mat(9, i), mat(10, i));
21  h_p3[i].set(mat(15, i), mat(12, i), mat(13, i), mat(14, i));
22  }
23 
24  mcbooster::Particles_d d_p0(h_p0.begin(), h_p0.end());
25  mcbooster::Particles_d d_p1(h_p1.begin(), h_p1.end());
26  mcbooster::Particles_d d_p2(h_p2.begin(), h_p2.end());
27  mcbooster::Particles_d d_p3(h_p3.begin(), h_p3.end());
28 
29  mcbooster::RealVector_d d_m12(mat.cols());
30  mcbooster::RealVector_d d_m34(mat.cols());
31  mcbooster::RealVector_d d_cos12(mat.cols());
32  mcbooster::RealVector_d d_cos34(mat.cols());
33  mcbooster::RealVector_d d_phi(mat.cols());
34 
35  mcbooster::ParticlesSet_d particles = {&d_p0, &d_p1, &d_p2, &d_p3};
36  mcbooster::VariableSet_d variables = {&d_m12, &d_m34, &d_cos12, &d_cos34, &d_phi};
37 
38  Dim5 eval = Dim5();
39  mcbooster::EvaluateArray<Dim5>(eval, particles, variables);
40 
41  mcbooster::RealVector_h h_m12(d_m12.begin(), d_m12.end());
42  mcbooster::RealVector_h h_m34(d_m34.begin(), d_m34.end());
43  mcbooster::RealVector_h h_cos12(d_cos12.begin(), d_cos12.end());
44  mcbooster::RealVector_h h_cos34(d_cos34.begin(), d_cos34.end());
45  mcbooster::RealVector_h h_phi(d_phi.begin(), d_phi.end());
46 
47  Eigen::Matrix<fptype, 5, Eigen::Dynamic> output(5, mat.cols());
48 
49  for(int i = 0; i < mat.cols(); i++) {
50  output(0, i) = h_m12[i];
51  output(1, i) = h_m34[i];
52  output(2, i) = h_cos12[i];
53  output(3, i) = h_cos34[i];
54  output(4, i) = h_phi[i];
55  }
56 
57  return output;
58 }

◆ twoBodyCMmom()

__device__ fptype GooFit::twoBodyCMmom ( double  rMassSq,
fptype  d1m,
fptype  d2m 
)

◆ writeListOfNumbers()

void GooFit::writeListOfNumbers ( thrust::host_vector< fptype > &  target,
const char *  fname 
)

Definition at line 84 of file FunctorWriter.cpp.

Referenced by writeBackgroundHistograms().

84  {
85  std::ofstream writer;
86  writer.open(fname);
87 
88  for(fptype t : target) {
89  writer << t << " ";
90  }
91 
92  writer.close();
93 }
double fptype

◆ writeToFile()

void GooFit::writeToFile ( PdfBase pdf,
const char *  fname 
)

Definition at line 9 of file FunctorWriter.cpp.

References GooFit::PdfBase::getParameters().

Referenced by runBackgroundDalitzFit(), and runSigmaFit().

9  {
10  std::vector<Variable> params = pdf->getParameters();
11 
12  std::ofstream writer;
13  writer.open(fname);
14 
15  for(const Variable &p : params) {
16  writer << p.getName() << " " << p.getValue() << " " << p.getError() << " " << p.getLowerLimit() << " "
17  << p.getUpperLimit() << std::endl;
18  }
19 
20  writer.close();
21 }

Variable Documentation

◆ black

constexpr rang::fg const GooFit::black = rang::fg::black

Definition at line 8 of file Color.h.

◆ blue

constexpr rang::fg const GooFit::blue = rang::fg::blue

Definition at line 12 of file Color.h.

Referenced by GooFit::Application::exit().

◆ bold

constexpr rang::style const GooFit::bold = rang::style::bold

◆ cyan

constexpr rang::fg const GooFit::cyan = rang::fg::cyan

Definition at line 14 of file Color.h.

◆ dev_event_array

fptype * GooFit::dev_event_array

Definition at line 28 of file PdfBase.cpp.

◆ dim

constexpr rang::style const GooFit::dim = rang::style::dim

Definition at line 18 of file Color.h.

Referenced by GooFit::Dim5::Dim5(), and print_splash().

◆ evalfunc_vals

constexpr const char* GooFit::evalfunc_vals[] = {"ptr_to_Eval", "ptr_to_NLL", "ptr_to_Prob", "ptr_to_BinAvg", "ptr_to_BinWithError", "ptr_to_Chisq"}

Definition at line 18 of file GooPdf.h.

Referenced by evalfunc_to_string().

◆ gray

constexpr rang::fg const GooFit::gray = rang::fg::gray

Definition at line 15 of file Color.h.

Referenced by GooFit::FitManagerMinuit2::fit(), and GooFit::FitManagerMinuit1::fit().

◆ green

constexpr rang::fg const GooFit::green = rang::fg::green

Definition at line 10 of file Color.h.

Referenced by GooFit::FitManagerMinuit2::fit(), and print_splash().

◆ host_callnumber

int GooFit::host_callnumber = 0

◆ host_fcn_ptr

void* GooFit::host_fcn_ptr

◆ host_indices

unsigned int GooFit::host_indices

◆ host_normalisation

fptype GooFit::host_normalisation

Definition at line 29 of file PdfBase.cpp.

◆ host_params

fptype GooFit::host_params

Definition at line 30 of file PdfBase.cpp.

Referenced by abort().

◆ italic

constexpr rang::style const GooFit::italic = rang::style::italic

Definition at line 19 of file Color.h.

◆ magenta

constexpr rang::fg const GooFit::magenta = rang::fg::magenta

Definition at line 13 of file Color.h.

Referenced by GooFit::FitManagerMinuit2::fit(), and main().

◆ maxParams

const int GooFit::maxParams = GOOFIT_MAXPAR

Definition at line 38 of file PdfBase.h.

Referenced by evalfunc_to_string(), and GooFit::PdfBase::registerConstants().

◆ red

constexpr rang::fg const GooFit::red = rang::fg::red

◆ reset

constexpr rang::style const GooFit::reset = rang::style::reset

◆ resonanceSize

const int GooFit::resonanceSize = 4

Definition at line 71 of file DalitzPlotHelpers.h.

◆ totalConstants

int GooFit::totalConstants = 1

Definition at line 35 of file PdfBase.cpp.

Referenced by GooFit::PdfBase::registerConstants().

◆ totalParams

int GooFit::totalParams = 0

Definition at line 34 of file PdfBase.cpp.

Referenced by abort().

◆ yellow

constexpr rang::fg const GooFit::yellow = rang::fg::yellow

Definition at line 11 of file Color.h.