ot_tenseur.h

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       ot_tenseur.h
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2025
//####//  Derniere modification par francois
//####//  mer 14 mai 2025 17:54:47 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
#ifndef ot_tenseurH
#define ot_tenseurH
 
 
 
 
 
#include "ot_doubleprecision.h"
#include <vector>
#include <iostream>
#include "ot_mathematique.h"
 
 
 
class OT_VECTEUR_4DD;
 
 
class   OT_TENSEUR
{
 
public:
    OT_TENSEUR();
    OT_TENSEUR(int n);
    OT_TENSEUR(int n,int m);
    OT_TENSEUR(std::vector<OT_VECTEUR_4DD>&,std::vector<OT_VECTEUR_4DD>&);
    OT_TENSEUR(std::vector<OT_VECTEUR_4DD>&);
 
    OT_TENSEUR(const OT_TENSEUR& ot);
    virtual ~OT_TENSEUR();
 
    OT_TENSEUR& operator = (const OT_TENSEUR& ot);
    std::vector<OT_VECTEUR_4DD> operator[](int i);
    double2& operator()(int i,int j);
    double2& operator()(int i,int j)const;
 
    void reinit(int n,int m);
    void identite(void);
    int Get_NbRows()const;
    int Get_NbCols()const;
    virtual OT_TENSEUR transpose();
    virtual OT_TENSEUR inverse_homogene(void);
    virtual OT_TENSEUR inverse(void);
    virtual int est_til_equivalent( OT_TENSEUR& tns);
    virtual void get_orthogonalisation(OT_TENSEUR& a,OT_VECTEUR_4DD& d,OT_TENSEUR& v,int n,int&nrot);
    template<class T>int  existe(const std::vector<T>& vct,T val,int& idx);
    friend OT_VECTEUR_4DD operator*( OT_TENSEUR& ot1, OT_VECTEUR_4DD& ot2);
    friend OT_TENSEUR operator*( OT_TENSEUR& ot1, OT_TENSEUR& ot2);
    friend double2 operator%( OT_TENSEUR& ot1, OT_TENSEUR& ot2);
    friend OT_VECTEUR_3DD operator*( OT_TENSEUR& ot1, OT_VECTEUR_3DD& ot2);
    friend OT_TENSEUR operator*( double2& coef,OT_TENSEUR& ot );
    friend OT_TENSEUR operator*( OT_TENSEUR& ot1, double2& coef);
    friend OT_TENSEUR operator*( double& coef,OT_TENSEUR& ot );
    friend OT_TENSEUR operator*( OT_TENSEUR& ot1, double& coef);
    friend std::vector<double2> operator*( OT_TENSEUR& ot1, std::vector<double2>& v);
    friend OT_TENSEUR operator+( OT_TENSEUR& ot1, OT_TENSEUR& ot2);
    friend int operator == ( OT_TENSEUR& t1, OT_TENSEUR& t2);
    friend std::ostream& operator<<(std::ostream& os, OT_TENSEUR& tns);
    int listes_equivalentes(std::vector<double2>& list1,std::vector<double2>& list2,std::vector<unsigned int>& indx) ;
private:
    double2* data;
    int Dim1;
    int Dim2;
} ;
 
 
int operator==( OT_TENSEUR& t1, OT_TENSEUR&t2);
std::ostream& operator<<(std::ostream& os, OT_TENSEUR& tns);
OT_TENSEUR operator+(OT_TENSEUR& ot1,OT_TENSEUR& ot2) ;
template<class T>int  existe(const std::vector<T>& vct,double val,int& idx);
template<class T>int  existe(const std::vector<T>& vct,double2 val,int& idx);
template<class T>int  existe(const std::vector<int>& vct,int val,int& idx);
OT_TENSEUR operator*( OT_TENSEUR& ot1, double2& coef);
OT_TENSEUR operator*( double2& coef,OT_TENSEUR& ot );
OT_TENSEUR operator*( OT_TENSEUR& ot1, double& coef);
OT_TENSEUR operator*( double& coef,OT_TENSEUR& ot );
OT_TENSEUR operator*( OT_TENSEUR& ot1, OT_TENSEUR& ot2);
std::vector<double2> operator*( OT_TENSEUR& ot1, std::vector<double2>& v);
#endif