ngsolve 6.2.2501.post16.dev1__cp313-cp313-macosx_10_15_universal2.whl → 6.2.2501.post34.dev1__cp313-cp313-macosx_10_15_universal2.whl

netgen/include/tpintrule.hpp

@@ -1,224 +0,0 @@
-#ifndef TPINTRULE_HPP
-#define TPINTRULE_HPP
-
-
-#include "scalarfe.hpp"
-#include "coefficient.hpp"
-
-namespace ngfem
-{
-  class TPIntegrationRule : public IntegrationRule
-  {
-    const ArrayMem< const IntegrationRule *,2> irs;
-    public:
-      INLINE TPIntegrationRule(const Array< const IntegrationRule *> & airs) : irs(airs)
-      {
-        this->size = irs[0]->GetNIP()*irs[1]->GetNIP();
-      }
-      INLINE TPIntegrationRule(int asize)
-      {
-        this->size = asize;
-      }
-    INLINE const IntegrationRule & operator() (int i) const {return *irs[i];}
-  };
-
-///////////////////////////////////////////////////////////////////////////////
-
-  class NGS_DLL_HEADER TPMappedIntegrationRule  : public BaseMappedIntegrationRule
-  { 
-    ArrayMem<BaseMappedIntegrationRule *,2> irs;
-    ArrayMem<int,2> dims;
-    int facet = -1;
-    public:
-    INLINE TPMappedIntegrationRule(const IntegrationRule & ir, const ElementTransformation & eltrans ) : BaseMappedIntegrationRule(ir, eltrans) {
-    }
-    INLINE TPMappedIntegrationRule(BaseMappedIntegrationRule & mirx, BaseMappedIntegrationRule & miry, const IntegrationRule & tpir, const ElementTransformation & eltrans ) : BaseMappedIntegrationRule(tpir, eltrans) {
-    irs[0] = &mirx;
-    irs[1] = &miry;
-    dims[0] = mirx.GetTransformation().SpaceDim();
-    dims[1] = miry.GetTransformation().SpaceDim();
-    }
-    INLINE void SetFacet(int afacet) { 
-      facet = afacet;
-    }
-    virtual ~TPMappedIntegrationRule() {}
-    virtual BaseMappedIntegrationRule & Range(int first, int next, LocalHeap & lh) const
-    { throw Exception("TPMappedIntegrationRule::Range not implemented"); }
-    virtual SliceMatrix<> GetPoints() const
-    { throw Exception("TPMappedIntegrationRule::GetPoints not implemented"); }
-    virtual SliceMatrix<> GetNormals() const
-    { throw Exception("TPMappedIntegrationRule::GetNormals not implemented"); }
-    virtual void ComputeNormalsAndMeasure (ELEMENT_TYPE et, int facetnr)
-    { throw Exception("TPMappedIntegrationRule::ComputeNormalsAndMeasure not implemented"); }
-    virtual bool IsComplex() const
-    {
-      return false;
-    }
-    INLINE void AppendDim(int adim) {
-      dims.Append(adim);
-    }
-    INLINE void AppendIR(BaseMappedIntegrationRule * miri) {
-      irs.Append(miri);
-    }
-    INLINE const Array<int> & GetDims() const {
-      return dims;
-    }
-    INLINE Array<int> & GetDims() {
-      return dims;
-    }    
-    INLINE const Array<BaseMappedIntegrationRule *> & GetIRs() const {
-      return irs;
-    }
-    INLINE Array<BaseMappedIntegrationRule *> & GetIRs() {
-      return irs;
-    }
-    INLINE const int GetFacet() const {
-      return facet;
-    }
-    virtual BaseMappedIntegrationRule & Range(size_t first, size_t next, LocalHeap & lh) const 
-    { throw Exception("TPMappedIntegrationRule::Range not implemented"); }
-  };
-
-///////////////////////////////////////////////////////////////////////////////////////
-  class TPElementTransformation : public ElementTransformation 
-  {
-    ElementId ei;
-    ArrayMem<ElementTransformation*, 2> trafos;
-    
-  public:
-  INLINE TPElementTransformation ( ElementId aei ) : 
-    ElementTransformation (ET_POINT, VOL, aei.Nr(), 0), ei(aei)
-    {
-        //trafos.SetSize(nmeshes);
-    }
-    INLINE ElementTransformation & GetTrafo(int i) const {return *trafos[i];}
-    void SetTrafos(Array<ElementTransformation *> & atrafos) {trafos = atrafos;}
-    virtual void CalcJacobian (const IntegrationPoint & ip, FlatMatrix<> dxdxi) const {
-      throw Exception("TPElementTransformation::CalcJacobian not implemented");
-    }     
-    virtual void CalcPoint (const IntegrationPoint & ip, FlatVector<> point) const {
-      throw Exception("TPElementTransformation::CalcPoint not implemented");
-    }
-    virtual void CalcPointJacobian (const IntegrationPoint & ip, FlatVector<> point, FlatMatrix<> dxdxi) const {
-      throw Exception("TPElementTransformation::CalcPointJacobian not implemented");
-    }
-    virtual void CalcMultiPointJacobian (const IntegrationRule & ir, BaseMappedIntegrationRule & bmir) const {
-      throw Exception("TPElementTransformation::CalcMultiPointJacobian not implemented");
-    }
-    virtual void CalcMultiPointJacobian (const SIMD_IntegrationRule & ir, SIMD_BaseMappedIntegrationRule & mir) const {
-      throw Exception("TPElementTransformation::CalcMultiPointJacobian not implemented");
-    }
-    virtual int SpaceDim () const { 
-      return trafos[0]->SpaceDim() + trafos[1]->SpaceDim();
-    }
-    virtual VorB VB() const {
-      return VorB( (trafos[0]->VB()==BND) || (trafos[1]->VB() == BND) );
-    }
-    virtual BaseMappedIntegrationPoint & operator() (const IntegrationPoint & ip, Allocator & lh) const {
-      throw Exception("TPElementTransformation::operator() not implemented"); }
-    
-    virtual BaseMappedIntegrationRule & operator() (const IntegrationRule & ir, Allocator & lh) const 
-    {
-      const TPIntegrationRule & tpir = dynamic_cast<const TPIntegrationRule &>(ir);
-      TPMappedIntegrationRule * mir = new (lh) TPMappedIntegrationRule(ir, *this);
-      for(int i=0;i<2;i++)
-      {
-        BaseMappedIntegrationRule & miri = (*trafos[i])(tpir(i),lh);
-        mir->AppendDim(trafos[i]->SpaceDim());
-        mir->AppendIR(&miri);
-      }
-      return *mir;
-    }
-  };
-////////////////////////////////////////////////////////////////////////////////////////////
-
-
-  class TPHighOrderFE : public FiniteElement
-  { 
-  public:    
-    ArrayMem<const FiniteElement *,2> elements;
-    HD NGS_DLL_HEADER 
-    virtual void CalcShape (const IntegrationPoint & ip, 
-                            SliceVector<> shape) const
-    { cout << "calcshape ip" << endl; }
-    
-    /// compute dshape, matrix: ndof x spacedim
-    HD NGS_DLL_HEADER 
-    virtual void CalcDShape (const IntegrationPoint & ip, 
-			     SliceMatrix<> dshape) const
-    { cout << "calcdshape ip" << endl; }
-
-    HD NGS_DLL_HEADER 
-    virtual void CalcShape (const IntegrationRule & irbase, SliceMatrix<> shape) const
-    {
-      const TPIntegrationRule & ir = dynamic_cast<const TPIntegrationRule &>(irbase);
-      int ndof0 = elements[0]->GetNDof();
-      int ndof1 = elements[1]->GetNDof();
-      int nip0 = ir(0).Size();
-      int nip1 = ir(1).Size();
-      Matrix<double> shape0( ndof0, ir(0).Size() ); 
-      Matrix<double> shape1( ndof1, ir(1).Size() ); 
-      dynamic_cast<const BaseScalarFiniteElement*>(elements[0])->CalcShape( ir(0), shape0 );
-      dynamic_cast<const BaseScalarFiniteElement*>(elements[1])->CalcShape( ir(1), shape1 );
-      int ii=0;
-      for(int m=0;m<ndof0;m++)
-        for(int n=0;n<ndof1;n++)
-        {
-          int ip=0;
-          for(int i=0;i<nip0;i++)
-            for(int j=0;j<nip1;j++)
-              shape(ii,ip++) = shape0(m,i)*shape1(n,j);
-          ii++;
-        }
-    }
-    INLINE const FiniteElement* Elements(int i) { return elements[i]; }
-    //int NElements() { return elements.Size();}
-    HD virtual ELEMENT_TYPE ElementType() const { return ET_POINT; }
-
-    INLINE TPHighOrderFE (Array<const FiniteElement *> & els) 
-    {
-      //elements.SetSize(els.Size());
-      elements = els;
-      ndof = elements[0]->GetNDof()*elements[1]->GetNDof();
-      order = max2(elements[0]->Order(),elements[1]->Order());
-    }
-    HD virtual NGS_DLL_HEADER ~TPHighOrderFE () { ; }
-    
-  };
-
-  class ProlongateCoefficientFunction : public CoefficientFunction
-  {
-  private:
-    shared_ptr<CoefficientFunction> coef;
-    int prolongateto;
-    int dimx,dimy;
-  public:
-    ///
-    ProlongateCoefficientFunction(shared_ptr<CoefficientFunction> acoef,int aprolongateto,int adimension,int adimx,int adimy, bool ais_complex = false) 
-         : CoefficientFunction(adimension,ais_complex), coef(acoef), prolongateto(aprolongateto), dimx(adimx), dimy(adimy)
-    { ; }
-    ///
-    virtual double Evaluate (const BaseMappedIntegrationPoint & ip) const;
-    ///
-    virtual void Evaluate (const BaseMappedIntegrationRule & ir, BareSliceMatrix<double> values) const;
-    virtual void EvaluateStdRule (const BaseMappedIntegrationRule & ir, FlatMatrix<double> values) const;
-  };
-  
-  class ProlongateCoefficientFunctionVisualization : public CoefficientFunction
-  {
-  private:
-    const ProlongateCoefficientFunction & pcf;
-  public:
-    ///
-    ProlongateCoefficientFunctionVisualization(const ProlongateCoefficientFunction & apcf) 
-         : CoefficientFunction(apcf.Dimension(),apcf.IsComplex()), pcf(apcf)
-    { ; }
-    ///
-      using CoefficientFunction::Evaluate;
-    virtual double Evaluate (const BaseMappedIntegrationPoint & ip) const { return pcf.Evaluate(ip); }
-    ///
-    virtual void Evaluate (const BaseMappedIntegrationRule & ir, FlatMatrix<double> values) const { pcf.EvaluateStdRule(ir,values); }
-  };
-  
-}
-#endif // TPINTRULE_HPP

netgen/include/triangular.hpp

@@ -1,465 +0,0 @@
-#ifndef FILE_TRIANGULAR
-#define FILE_TRIANGULAR
-
-/****************************************************************************/
-/* File:   triangular.hpp                                                   */
-/* Author: Joachim Schoeberl                                                */
-/* Date:   Nov 2020                                                         */
-/****************************************************************************/
-
-namespace ngbla
-{
-
-
-  enum TRIG_SIDE { LowerLeft, UpperRight };
-  enum TRIG_NORMAL { NonNormalized = 0, Normalized = 1 };
-  constexpr TRIG_SIDE operator! (TRIG_SIDE s)
-  { return (s == LowerLeft) ? UpperRight : LowerLeft; }
-
-
-  // Solve T X = Y
-  // rhs is overwritten by solution
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized,
-            typename TT, typename TX, ORDERING OT, ORDERING OX>
-  void TriangularSolve (BareSliceMatrix<TT,OT> T, SliceMatrix<TX,OX> X)
-  {
-    size_t n = X.Height();
-  
-    if (n == 0) return;
-    if (n == 1)
-      {
-        if (NORM == NonNormalized)
-          X.Row(0) *= 1.0/T(0.0);
-        return;
-      }
-
-    if (n < 8)
-      {
-        if constexpr (SIDE == UpperRight)
-            for (size_t i = n; i-- > 0; )
-              {
-                for (size_t j = i+1; j < n; j++)
-                  X.Row(i) -= T(i,j) * X.Row(j);
-                if (NORM==NonNormalized)
-                  X.Row(i) *= 1.0/T(i,i);
-              }
-        else
-          for (size_t i = 0; i < n; i++)
-            {
-              for (size_t j = 0; j < i; j++)
-                X.Row(i) -= T(i,j) * X.Row(j);
-              if (NORM==NonNormalized)
-                X.Row(i) *= 1.0/T(i,i);
-            }
-        return;
-      }
-
-
-
-    
-    if (X.Width() > 256)
-      {
-        size_t m = X.Width();
-        IntRange r1(0,m/2), r2(m/2,m);      
-        TriangularSolve<SIDE,NORM> (T, X.Cols(r1));
-        TriangularSolve<SIDE,NORM> (T, X.Cols(r2));
-        return;
-      }
-
-  
-    IntRange r1(0,n/2), r2(n/2,n);
-    auto T11 = T.Rows(r1).Cols(r1);
-    auto T12 = T.Rows(r1).Cols(r2).AddSize(r1.Size(), r2.Size());
-    auto T21 = T.Rows(r2).Cols(r1).AddSize(r2.Size(), r1.Size());
-    auto T22 = T.Rows(r2).Cols(r2);
-    auto X1 = X.Rows(r1);
-    auto X2 = X.Rows(r2);
-
-    if (SIDE == LowerLeft)
-      {
-        TriangularSolve<SIDE,NORM> (T11.Bare(), X1);
-        X2 -= T21 * X1;
-        TriangularSolve<SIDE,NORM> (T22.Bare(), X2);
-      }
-    else
-      {
-        TriangularSolve<SIDE,NORM> (T22.Bare(), X2);
-        X1 -= T12 * X2;
-        TriangularSolve<SIDE,NORM> (T11.Bare(), X1);
-      }
-  }
-
-  extern NGS_DLL_HEADER void TriangularSolveLL (BareSliceMatrix<double> T, SliceMatrix<double> X);
-  template <> inline void TriangularSolve<LowerLeft,NonNormalized> (BareSliceMatrix<double> T, SliceMatrix<double> X)
-  {
-    TriangularSolveLL(T,X);
-  }
-  extern NGS_DLL_HEADER void TriangularSolveLLN (BareSliceMatrix<double> T, SliceMatrix<double> X);
-  template <> inline void TriangularSolve<LowerLeft,Normalized> (BareSliceMatrix<double> T, SliceMatrix<double> X)
-  {
-    TriangularSolveLLN(T,X);
-  }
-
-  extern NGS_DLL_HEADER void TriangularSolveUR (BareSliceMatrix<double> T, SliceMatrix<double> X);
-  template <> inline void TriangularSolve<UpperRight,NonNormalized> (BareSliceMatrix<double> T, SliceMatrix<double> X)
-  {
-    TriangularSolveUR(T,X);
-  }
-  extern NGS_DLL_HEADER void TriangularSolveURN (BareSliceMatrix<double> T, SliceMatrix<double> X);
-  template <> inline void TriangularSolve<UpperRight,Normalized> (BareSliceMatrix<double> T, SliceMatrix<double> X)
-  {
-    TriangularSolveURN(T,X);
-  }
-
-  
-
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized, typename TT, typename TX,
-            typename enable_if<IsConvertibleToBareSliceMatrix<TT>(),int>::type = 0,
-            typename enable_if<IsConvertibleToSliceMatrix<TX>(),int>::type = 0>
-  void TriangularSolve (const TT & T, TX && X)
-  {
-    TriangularSolve<SIDE,NORM> (make_BareSliceMatrix(T), make_SliceMatrix(X));
-  }
-
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized, typename TT, 
-            typename enable_if<IsConvertibleToSliceMatrix<TT>(),int>::type = 0>
-  void TriangularSolve (const TT & T, FlatVector<> x)
-  {
-    TriangularSolve<SIDE,NORM> (make_BareSliceMatrix(T), SliceMatrix<>(x.Size(),1,1,&x(0)));
-  }
-
-
-
-
-
-  // Y = T X
-  // input X is overwritten 
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized,
-            typename TT, typename TX, ORDERING OT, ORDERING OX>
-  void TriangularMult2 (BareSliceMatrix<TT,OT> T, SliceMatrix<TX,OX> X)
-  {
-    // static Timer t("TriangularMult generic, rec"); RegionTimer r(t);
-    
-    size_t n = X.Height();
-  
-    if (n == 0) return;
-    if (n == 1)
-      {
-        if (NORM == NonNormalized)
-          X.Row(0) *= T(0.0);
-        return;
-      }
-
-    if (n < 8) {
-      if constexpr (SIDE == UpperRight) { 
-          for (size_t i = 0; i < n; i++)
-            {
-              if (NORM==NonNormalized)
-                X.Row(i) *= T(i,i);
-              for (size_t j = i+1; j < n; j++)
-                X.Row(i) += T(i,j) * X.Row(j);
-            }
-        }
-      else {
-        for (size_t i = n; i > 0; i--)
-          {
-            size_t im = i-1;
-            if (NORM==NonNormalized)
-              X.Row(im) *= T(im,im);
-            for (size_t j = 0; j < im; j++)
-              X.Row(im) += T(im,j) * X.Row(j);
-          }
-      }
-      return;
-    }
-
-    size_t n2 = n/2;
-    // if (n2 > 4) n2 = n2 - n2%4;
-    IntRange r1(0,n2), r2(n2,n);
-    auto T11 = T.Rows(r1).Cols(r1);
-    auto T12 = T.Rows(r1).Cols(r2).AddSize(r1.Size(), r2.Size());;
-    auto T21 = T.Rows(r2).Cols(r1).AddSize(r2.Size(), r1.Size());
-    auto T22 = T.Rows(r2).Cols(r2);
-    auto X1 = X.Rows(r1);
-    auto X2 = X.Rows(r2);
-
-    if (SIDE == LowerLeft)
-      {
-        TriangularMult2<SIDE,NORM> (T22.Bare(), X2);
-        X2 += T21 * X1;
-        TriangularMult2<SIDE,NORM> (T11.Bare(), X1);
-      }
-    else
-      {
-        TriangularMult2<SIDE,NORM> (T11.Bare(), X1);
-        X1 += T12 * X2;
-        TriangularMult2<SIDE,NORM> (T22.Bare(), X2);
-      }
-  }
-
-  // Y = T X
-  // input X is overwritten 
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized,
-            typename TT, typename TX, ORDERING OT, ORDERING OX>
-  void TriangularMult (BareSliceMatrix<TT,OT> T, SliceMatrix<TX,OX> X)
-  {
-    static Timer t("TriangularMult generic"); RegionTimer r(t);
-    size_t i = 0;
-    constexpr size_t bw = 256;
-    for ( ; i+bw <= X.Width(); i += bw)
-      TriangularMult2<SIDE,NORM> (T, X.Cols(i,i+bw));
-    if (i < X.Width())
-      TriangularMult2<SIDE,NORM> (T, X.Cols(i,X.Width()));      
-  }
-
-  
-  extern NGS_DLL_HEADER void TriangularMultLL (BareSliceMatrix<double> T, SliceMatrix<double> X);
-  extern NGS_DLL_HEADER void TriangularMultLLN (BareSliceMatrix<double> T, SliceMatrix<double> X);
-  extern NGS_DLL_HEADER void TriangularMultLL (BareSliceMatrix<double,ColMajor> T, SliceMatrix<double> X);
-  extern NGS_DLL_HEADER void TriangularMultLLN (BareSliceMatrix<double,ColMajor> T, SliceMatrix<double> X);
-
-  template <> inline void TriangularMult<LowerLeft,NonNormalized> (BareSliceMatrix<double> T, SliceMatrix<double> X)
-  {
-    TriangularMultLL(T,X);
-  }
-
-  template <> inline void TriangularMult<LowerLeft,Normalized> (BareSliceMatrix<double> T, SliceMatrix<double> X)
-  {
-    TriangularMultLLN(T,X);
-  }
-
-  template <> inline void TriangularMult<LowerLeft,NonNormalized> (BareSliceMatrix<double,ColMajor> T, SliceMatrix<double> X)
-  {
-    TriangularMultLL(T,X);
-  }
-
-  template <> inline void TriangularMult<LowerLeft,Normalized> (BareSliceMatrix<double,ColMajor> T, SliceMatrix<double> X)
-  {
-    TriangularMultLLN(T,X);
-  }
-
-
-  
-  extern NGS_DLL_HEADER void TriangularMultUR (BareSliceMatrix<double> T, SliceMatrix<double> X);
-  extern NGS_DLL_HEADER void TriangularMultURN (BareSliceMatrix<double> T, SliceMatrix<double> X);
-  extern NGS_DLL_HEADER void TriangularMultUR (BareSliceMatrix<double,ColMajor> T, SliceMatrix<double> X);
-  extern NGS_DLL_HEADER void TriangularMultURN (BareSliceMatrix<double,ColMajor> T, SliceMatrix<double> X);
-  
-  template <> inline void TriangularMult<UpperRight,NonNormalized> (BareSliceMatrix<double> T, SliceMatrix<double> X)
-  {
-    TriangularMultUR(T,X);
-  }
-
-  template <> inline void TriangularMult<UpperRight,Normalized> (BareSliceMatrix<double> T, SliceMatrix<double> X)
-  {
-    TriangularMultURN(T,X);
-  }
-
-  template <> inline void TriangularMult<UpperRight,NonNormalized> (BareSliceMatrix<double,ColMajor> T, SliceMatrix<double> X)
-  {
-    TriangularMultUR(T,X);
-  }
-  template <> inline void TriangularMult<UpperRight,Normalized> (BareSliceMatrix<double,ColMajor> T, SliceMatrix<double> X)
-  {
-    TriangularMultURN(T,X);
-  }
-
-  
-  
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized, typename TT, typename TX,
-            typename enable_if<IsConvertibleToSliceMatrix<TT>(),int>::type = 0,
-            typename enable_if<IsConvertibleToSliceMatrix<TX>(),int>::type = 0>
-  void TriangularMult (const TT & T, TX & X)
-  {
-    TriangularMult<SIDE,NORM> (make_BareSliceMatrix(T), make_SliceMatrix(X));
-  }
-  
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized, typename TT, 
-            typename enable_if<IsConvertibleToSliceMatrix<TT>(),int>::type = 0>
-  void TriangularMult (const TT & T, FlatVector<> x)
-  {
-    TriangularMult<SIDE,NORM> (make_BareSliceMatrix(T), SliceMatrix<>(x.Size(),1,1,&x(0)));
-  }
-
-
-  // X = X * T
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized, typename TT, typename TX,
-            typename enable_if<IsConvertibleToSliceMatrix<TT>(),int>::type = 0,
-            typename enable_if<IsConvertibleToSliceMatrix<TX>(),int>::type = 0>
-  void MultTriangular (TX & X, const TT & T)
-  {
-    TriangularMult<!SIDE,NORM> (Trans(make_BareSliceMatrix(T)), Trans(make_SliceMatrix(X)));
-  }
-
-
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized,
-            typename TT, typename TX, ORDERING OT, ORDERING OX>
-  void MultTriangular (SliceMatrix<TX,OX> X, SliceMatrix<TT,OT> T)
-  {
-    TriangularMult<!SIDE,NORM> (Trans(T), Trans(X));
-  }
-
-  extern NGS_DLL_HEADER void MultTriangularLLN (SliceMatrix<double> X, BareSliceMatrix<double> T);
-  template <> inline void MultTriangular<LowerLeft,Normalized> (SliceMatrix<double> X, SliceMatrix<double> T)
-  {
-    MultTriangularLLN(X,T);
-  }
-  extern NGS_DLL_HEADER void MultTriangularUR (SliceMatrix<double> X, BareSliceMatrix<double> T);
-  template <> inline void MultTriangular<UpperRight> (SliceMatrix<double> X, SliceMatrix<double> T)
-  {
-    MultTriangularUR(X,T);
-  }
-
-
-
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized, ORDERING OT, ORDERING OXY>
-  extern NGS_DLL_HEADER void GeneralizedTriangularMult_SM (SliceMatrix<double, OT> T,
-                                                           SliceMatrix<double, OXY> X,
-                                                           SliceMatrix<double, OXY> Y);
-    
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized, typename TT, typename TX, typename TY>
-  void GeneralizedTriangularMult (const TT & T,
-                                  const TX & X,
-                                  const TY & Y)
-  {
-    GeneralizedTriangularMult_SM<SIDE,NORM> (make_SliceMatrix(T), make_SliceMatrix(X), make_SliceMatrix(Y));
-  }
-  
-
-
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized, ORDERING OT, ORDERING OXY>
-  extern NGS_DLL_HEADER void GeneralizedTriangularSub_SM (SliceMatrix<double, OT> T,
-                                                           SliceMatrix<double, OXY> X,
-                                                           SliceMatrix<double, OXY> Y);
-
-    
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized, typename TT, typename TX, typename TY>
-  void GeneralizedTriangularSub (const TT & T,
-                                 const TX & X,
-                                 const TY & Y)
-  {
-    GeneralizedTriangularSub_SM<SIDE,NORM> (make_SliceMatrix(T), make_SliceMatrix(X), make_SliceMatrix(Y));
-  }
-  
-
-  
-
-
-  
-
-  /*
-  static Timer triginv_loops ("TriangularInvert loops");
-  static Timer triginv_L1 ("TriangularInvert L1");
-  static Timer triginv_L2 ("TriangularInvert L2");
-  static Timer triginv_R1 ("TriangularInvert R1");
-  static Timer triginv_R2 ("TriangularInvert r2");
-  */
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized,
-            typename TT, ORDERING TO>
-  void TriangularInvert (SliceMatrix<TT,TO> T)
-  {
-    size_t n = T.Height();
-  
-    if (n == 0) return;
-    if (n == 1)
-      {
-        if (NORM == NonNormalized)
-          T(0,0) = 1.0/T(0,0);
-        return;
-      }
-
-    if (n < 16)
-      {
-        // RegionTimer reg(triginv_loops);
-        for (size_t j = 0; j < n; j++)
-          {
-            auto rowj = T.Row(j);
-            TT invdiag = 1.0;
-            if constexpr (NORM == NonNormalized) {
-                invdiag = 1.0/T(j,j);  
-                
-                if constexpr (SIDE==LowerLeft) {
-                    rowj.Range(0,j) *= invdiag;
-                  }
-                else
-                  rowj.Range(j+1,n) *= invdiag;
-                rowj(j) = invdiag;
-              }
-            
-            if constexpr (SIDE == UpperRight) {
-                for (size_t k = 0; k < j; k++)
-                  {
-                    auto rowk = T.Row(k);
-                    TT help = rowk(j);
-                    rowk.Range(j+1,n) -= help * rowj.Range(j+1,n);
-                    rowk(j) = -help*invdiag;
-                  }
-              }
-            else
-              for (size_t k = j+1; k < n; k++)
-                {
-                  auto rowk = T.Row(k);                  
-                  TT help = rowk(j);
-                  rowk.Range(j) -= help * rowj.Range(j);
-                  rowk(j) = -help*invdiag;
-                }
-          }
-        
-        return;
-      }
-
-    size_t n2 = n/2;
-    IntRange r1(0,n2), r2(n2,n);
-    auto T11 = T.Rows(r1).Cols(r1);
-    auto T12 = T.Rows(r1).Cols(r2);
-    auto T21 = T.Rows(r2).Cols(r1);
-    auto T22 = T.Rows(r2).Cols(r2);
-
-    TriangularInvert<SIDE,NORM> (T11);
-    TriangularInvert<SIDE,NORM> (T22);
-    
-    if (SIDE == LowerLeft)
-      {
-        T21 *= -1;
-        // triginv_L1.Start();
-        TriangularMult<SIDE,NORM> (T22, T21);
-        // triginv_L1.Stop();
-        // triginv_L2.Start();        
-        // TriangularMult<!SIDE,NORM> (Trans(T11), Trans(T21));
-        MultTriangular<SIDE,NORM> (T21, T11);
-        // triginv_L2.Stop();        
-      }
-    else
-      {
-        T12 *= -1;
-        // triginv_R1.Start();        
-        TriangularMult<SIDE,NORM> (T11, T12);
-        // triginv_R1.Stop();        
-        // triginv_R2.Start();        
-        // TriangularMult<!SIDE,NORM> (Trans(T22), Trans(T12));
-        MultTriangular<SIDE,NORM> (T12, T22);
-        // triginv_R2.Stop();                
-      }
-  }
-
-  template <TRIG_SIDE SIDE, TRIG_NORMAL NORM=NonNormalized, typename TT, 
-            typename enable_if<IsConvertibleToSliceMatrix<TT>(),int>::type = 0>
-  void TriangularInvert (const TT & T)
-  {
-    TriangularInvert<SIDE,NORM> (make_SliceMatrix(T));
-  }
-
-
-
-
-  
-  extern NGS_DLL_HEADER void CalcLU (SliceMatrix<double> A, FlatArray<int> p);
-  extern NGS_DLL_HEADER void InverseFromLU (SliceMatrix<double> A, FlatArray<int> p);
-  extern NGS_DLL_HEADER void SolveFromLU (SliceMatrix<double> A, FlatArray<int> p, SliceMatrix<double,ColMajor> X);
-  extern NGS_DLL_HEADER void SolveTransFromLU (SliceMatrix<double> A, FlatArray<int> p, SliceMatrix<double,ColMajor> X);
-  
-
-  
-  
-}
-#endif