Arcane  4.2.1.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
Référence de la classe Arcane::Real2Proxy

Classe gérant un vecteur de réel de dimension 2. Plus de détails...

#include <arcane/utils/Real2Proxy.h>

Fonctions membres publiques

 Real2Proxy (Real2 &value, const MemoryAccessInfo &info)
 Construit le couplet (ax,ay).
 Real2Proxy (const Real2Proxy &f)
 Construit un couple identique à f.
const Real2 & operator= (Real2Proxy f)
const Real2 & operator= (Real2 f)
const Real2 & operator= (Real v)
 Affecte à l'instance le couple (v,v).
 operator Real2 () const
Real2 copy () const
 Retourne une copie du couple.
Real2Proxy & reset ()
 Réinitialise le couple avec les constructeurs par défaut.
Real2Proxy & assign (Real ax, Real ay)
 Affecte à l'instance le couple (ax,ay,az).
Real2Proxy & assign (Real2 f)
 Copie le couple f.
bool isNearlyZero () const
 Compare le couple avec le couple nul.
Real abs2 () const
 Retourne la norme au carré du couple \(x^2+y^2+z^2\).
Real abs () const
 Retourne la norme du couple \(\sqrt{x^2+y^2+z^2}\).
istream & assign (istream &i)
 Lit un couple sur le flot i Le couple est lu sous la forme de trois valeur de type #value_type.
ostream & print (ostream &o) const
 Ecrit le couple sur le flot o lisible par un assign().
ostream & printXy (ostream &o) const
 Ecrit le couple sur le flot o sous la forme (x,y).
Real2Proxy & add (Real2 b)
 Ajoute b au couple.
Real2Proxy & sub (Real2 b)
 Soustrait b au couple.
Real2Proxy & mul (Real2 b)
 Multiple chaque composante du couple par la composant correspondant de b.
Real2Proxy & div (Real2 b)
 Divise chaque composante du couple par la composant correspondant de b.
Real2Proxy & addSame (Real b)
 Ajoute b à chaque composante du couple.
Real2Proxy & subSame (Real b)
 Soustrait b à chaque composante du couple.
Real2Proxy & mulSame (Real b)
 Multiplie chaque composante du couple par b.
Real2Proxy & divSame (Real b)
 Divise chaque composante du couple par b.
Real2Proxy & operator+= (Real2 b)
 Ajoute b au couple.
Real2Proxy & operator-= (Real2 b)
 Soustrait b au couple.
Real2Proxy & operator*= (Real2 b)
 Multiplie chaque composante du couple par la composant correspondant de b.
void operator*= (Real b)
 Multiplie chaque composante du couple par le réel b.
Real2Proxy & operator/= (Real2 b)
 Divise chaque composante du couple par la composant correspondant de b.
void operator/= (Real b)
 Divise chaque composante du couple par le réel b.
Real2 operator+ (Real2 b) const
 Créé un couple qui vaut ce couple ajouté à b.
Real2 operator- (Real2 b) const
 Créé un couple qui vaut b soustrait de ce couple.
Real2 operator- () const
 Créé un couple opposé au couple actuel.
Real2 operator* (Real2 b) const
 Créé un couple qui vaut ce couple dont chaque composant a été multipliée par la composante correspondante de b.
Real2 operator/ (Real2 b) const
 Créé un couple qui vaut ce couple dont chaque composant a été divisée par la composante correspondante de b.
Real2Proxy & normalize ()
 Normalise le couple.
bool operator== (Real2 b) const
 Compare le couple à b.
bool operator!= (Real2 b) const
 Compare deux couples. Pour la notion d'égalité, voir operator==().
Real2 getValue () const
Real2 & getValueMutable ()

Attributs publics

RealProxy x
 première composante du couple
RealProxy y
 deuxième composante du couple

(Notez que ce ne sont pas des fonctions membres)

ostream & operator<< (ostream &o, Real2Proxy t)
 Ecrit le couple t sur le flot o.
istream & operator>> (istream &i, Real2Proxy &t)
 Lit le couple t à partir du flot o.

Description détaillée

Classe gérant un vecteur de réel de dimension 2.

Le vecteur comprend deuxs composantes x et y qui sont du type Real.

Real2Proxy value (1.0,2.3); // Créé un couple (x=1.0, y=2.3)
cout << value.x; // Imprime la composante x
value.y += 3.2; // Ajoute 3.2 à la composante \b y
Arcane::Real2Proxy::Real2Proxy
Real2Proxy(Real2 &value, const MemoryAccessInfo &info)
Construit le couplet (ax,ay).
Definition Real2Proxy.h:44

Définition à la ligne 39 du fichier Real2Proxy.h.

Documentation des constructeurs et destructeur

◆ Real2Proxy() [1/2]

Arcane::Real2Proxy::Real2Proxy ( Real2 & value,
const MemoryAccessInfo & info )
inline

Construit le couplet (ax,ay).

Définition à la ligne 44 du fichier Real2Proxy.h.

Références x, et y.

Référencé par add(), addSame(), assign(), assign(), div(), divSame(), mul(), mulSame(), normalize(), operator*=(), operator+=(), operator-=(), operator/=(), operator<<(), operator>>(), Real2Proxy(), reset(), sub(), et subSame().

◆ Real2Proxy() [2/2]

Arcane::Real2Proxy::Real2Proxy ( const Real2Proxy & f)
inline

Construit un couple identique à f.

Définition à la ligne 47 du fichier Real2Proxy.h.

Références Real2Proxy(), x, et y.

Documentation des fonctions membres

◆ abs()

Real Arcane::Real2Proxy::abs ( ) const
inline

Retourne la norme du couple \(\sqrt{x^2+y^2+z^2}\).

Définition à la ligne 109 du fichier Real2Proxy.h.

Références abs2().

Référencé par normalize().

◆ abs2()

Real Arcane::Real2Proxy::abs2 ( ) const
inline

Retourne la norme au carré du couple \(x^2+y^2+z^2\).

Définition à la ligne 106 du fichier Real2Proxy.h.

Références x, et y.

Référencé par abs().

◆ add()

Real2Proxy & Arcane::Real2Proxy::add ( Real2 b)
inline

Ajoute b au couple.

Définition à la ligne 123 du fichier Real2Proxy.h.

Références Real2Proxy(), Arcane::Real2POD::x, x, Arcane::Real2POD::y, et y.

Référencé par operator+=().

◆ addSame()

Real2Proxy & Arcane::Real2Proxy::addSame ( Real b)
inline

Ajoute b à chaque composante du couple.

Définition à la ligne 131 du fichier Real2Proxy.h.

Références Real2Proxy(), x, et y.

◆ assign() [1/2]

Real2Proxy & Arcane::Real2Proxy::assign ( Real ax,
Real ay )
inline

Affecte à l'instance le couple (ax,ay,az).

Définition à la ligne 81 du fichier Real2Proxy.h.

Références Real2Proxy(), x, et y.

Référencé par operator>>().

◆ assign() [2/2]

Real2Proxy & Arcane::Real2Proxy::assign ( Real2 f)
inline

Copie le couple f.

Définition à la ligne 84 du fichier Real2Proxy.h.

Références Real2Proxy(), Arcane::Real2POD::x, x, Arcane::Real2POD::y, et y.

◆ copy()

Real2 Arcane::Real2Proxy::copy ( ) const
inline

Retourne une copie du couple.

Définition à la ligne 77 du fichier Real2Proxy.h.

◆ div()

Real2Proxy & Arcane::Real2Proxy::div ( Real2 b)
inline

Divise chaque composante du couple par la composant correspondant de b.

Définition à la ligne 129 du fichier Real2Proxy.h.

Références Real2Proxy(), Arcane::Real2POD::x, x, Arcane::Real2POD::y, et y.

Référencé par operator/=().

◆ divSame()

Real2Proxy & Arcane::Real2Proxy::divSame ( Real b)
inline

Divise chaque composante du couple par b.

Définition à la ligne 137 du fichier Real2Proxy.h.

Références Real2Proxy(), x, et y.

Référencé par normalize().

◆ getValue()

Real2 Arcane::Real2Proxy::getValue ( ) const
inline

Définition à la ligne 211 du fichier Real2Proxy.h.

◆ getValueMutable()

Real2 & Arcane::Real2Proxy::getValueMutable ( )
inline

Définition à la ligne 216 du fichier Real2Proxy.h.

◆ isNearlyZero()

bool Arcane::Real2Proxy::isNearlyZero ( ) const
inline

Compare le couple avec le couple nul.

Dans le cas d'un type #value_type de type intégral, le couple est nul si et seulement si chacune de ses composantes est égal à 0.

Pour #value_type du type flottant (float, double ou Real), le couple est nul si et seulement si chacune de ses composant est inférieure à un espilon donné. La valeur de l'epsilon utilisée est celle de float_info<value_type>::nearlyEpsilon():

\[A=0 \Leftrightarrow |A.x|<\epsilon,|A.y|<\epsilon \]

Valeurs retournées
truesi le couple est égal au couple nul,
falsesinon.

Définition à la ligne 101 du fichier Real2Proxy.h.

Références x, et y.

◆ mul()

Real2Proxy & Arcane::Real2Proxy::mul ( Real2 b)
inline

Multiple chaque composante du couple par la composant correspondant de b.

Définition à la ligne 127 du fichier Real2Proxy.h.

Références Real2Proxy(), Arcane::Real2POD::x, x, Arcane::Real2POD::y, et y.

Référencé par operator*=().

◆ mulSame()

Real2Proxy & Arcane::Real2Proxy::mulSame ( Real b)
inline

Multiplie chaque composante du couple par b.

Définition à la ligne 135 du fichier Real2Proxy.h.

Références Real2Proxy(), x, et y.

◆ normalize()

Real2Proxy & Arcane::Real2Proxy::normalize ( )
inline

Normalise le couple.

Si le couple est non nul, divise chaque composante par la norme du couple (abs()), de telle sorte qu'après l'appel à cette méthode, abs() valent 1. Si le couple est nul, ne fait rien.

Définition à la ligne 174 du fichier Real2Proxy.h.

Références abs(), divSame(), Arcane::math::isZero(), et Real2Proxy().

◆ operator Real2()

Arcane::Real2Proxy::operator Real2 ( ) const
inline

Définition à la ligne 56 du fichier Real2Proxy.h.

◆ operator!=()

bool Arcane::Real2Proxy::operator!= ( Real2 b) const
inline

Compare deux couples. Pour la notion d'égalité, voir operator==().

Valeurs retournées
truesi les deux couples sont différents,
falsesinon.

Définition à la ligne 206 du fichier Real2Proxy.h.

Références operator==().

◆ operator*()

Real2 Arcane::Real2Proxy::operator* ( Real2 b) const
inline

Créé un couple qui vaut ce couple dont chaque composant a été multipliée par la composante correspondante de b.

Définition à la ligne 160 du fichier Real2Proxy.h.

Références Arcane::Real2POD::x, x, Arcane::Real2POD::y, et y.

◆ operator*=() [1/2]

void Arcane::Real2Proxy::operator*= ( Real b)
inline

Multiplie chaque composante du couple par le réel b.

Définition à la ligne 145 du fichier Real2Proxy.h.

Références x, et y.

◆ operator*=() [2/2]

Real2Proxy & Arcane::Real2Proxy::operator*= ( Real2 b)
inline

Multiplie chaque composante du couple par la composant correspondant de b.

Définition à la ligne 143 du fichier Real2Proxy.h.

Références mul(), et Real2Proxy().

◆ operator+()

Real2 Arcane::Real2Proxy::operator+ ( Real2 b) const
inline

Créé un couple qui vaut ce couple ajouté à b.

Définition à la ligne 151 du fichier Real2Proxy.h.

Références Arcane::Real2POD::x, x, Arcane::Real2POD::y, et y.

◆ operator+=()

Real2Proxy & Arcane::Real2Proxy::operator+= ( Real2 b)
inline

Ajoute b au couple.

Définition à la ligne 139 du fichier Real2Proxy.h.

Références add(), et Real2Proxy().

◆ operator-() [1/2]

Real2 Arcane::Real2Proxy::operator- ( ) const
inline

Créé un couple opposé au couple actuel.

Définition à la ligne 155 du fichier Real2Proxy.h.

Références x, et y.

◆ operator-() [2/2]

Real2 Arcane::Real2Proxy::operator- ( Real2 b) const
inline

Créé un couple qui vaut b soustrait de ce couple.

Définition à la ligne 153 du fichier Real2Proxy.h.

Références Arcane::Real2POD::x, x, Arcane::Real2POD::y, et y.

◆ operator-=()

Real2Proxy & Arcane::Real2Proxy::operator-= ( Real2 b)
inline

Soustrait b au couple.

Définition à la ligne 141 du fichier Real2Proxy.h.

Références Real2Proxy(), et sub().

◆ operator/()

Real2 Arcane::Real2Proxy::operator/ ( Real2 b) const
inline

Créé un couple qui vaut ce couple dont chaque composant a été divisée par la composante correspondante de b.

Définition à la ligne 165 du fichier Real2Proxy.h.

Références Arcane::Real2POD::x, x, Arcane::Real2POD::y, et y.

◆ operator/=() [1/2]

void Arcane::Real2Proxy::operator/= ( Real b)
inline

Divise chaque composante du couple par le réel b.

Définition à la ligne 149 du fichier Real2Proxy.h.

Références x, et y.

◆ operator/=() [2/2]

Real2Proxy & Arcane::Real2Proxy::operator/= ( Real2 b)
inline

Divise chaque composante du couple par la composant correspondant de b.

Définition à la ligne 147 du fichier Real2Proxy.h.

Références div(), et Real2Proxy().

◆ operator=() [1/3]

const Real2 & Arcane::Real2Proxy::operator= ( Real v)
inline

Affecte à l'instance le couple (v,v).

Définition à la ligne 54 du fichier Real2Proxy.h.

Références x, et y.

◆ operator=() [2/3]

const Real2 & Arcane::Real2Proxy::operator= ( Real2 f)
inline

Définition à la ligne 51 du fichier Real2Proxy.h.

◆ operator=() [3/3]

const Real2 & Arcane::Real2Proxy::operator= ( Real2Proxy f)
inline

Définition à la ligne 49 du fichier Real2Proxy.h.

◆ operator==()

bool Arcane::Real2Proxy::operator== ( Real2 b) const
inline

Compare le couple à b.

Dans le cas d'un type #value_type de type intégral, deux couples sont égaux si et seulement si chacune de leur composant sont strictement égales.

Pour #value_type du type flottant (float, double ou Real), deux couples sont identiques si et seulement si la valeur absolue de la différence entre chacune de leur composant correspondante est inférieure à un espilon donné. La valeur de l'epsilon utilisée est celle de float_info<value_type>::nearlyEpsilon():

\[A=B \Leftrightarrow |A.x-B.x|<\epsilon,|A.y-B.y|<\epsilon,|A.z-B.z|<\epsilon \]

Valeurs retournées
truesi les deux couples sont égaux,
falsesinon.

Définition à la ligne 198 du fichier Real2Proxy.h.

Références Arcane::Real2POD::x, x, Arcane::Real2POD::y, et y.

Référencé par operator!=().

◆ reset()

Real2Proxy & Arcane::Real2Proxy::reset ( )
inline

Réinitialise le couple avec les constructeurs par défaut.

Définition à la ligne 79 du fichier Real2Proxy.h.

Références Real2Proxy(), x, et y.

◆ sub()

Real2Proxy & Arcane::Real2Proxy::sub ( Real2 b)
inline

Soustrait b au couple.

Définition à la ligne 125 du fichier Real2Proxy.h.

Références Real2Proxy(), Arcane::Real2POD::x, x, Arcane::Real2POD::y, et y.

Référencé par operator-=().

◆ subSame()

Real2Proxy & Arcane::Real2Proxy::subSame ( Real b)
inline

Soustrait b à chaque composante du couple.

Définition à la ligne 133 du fichier Real2Proxy.h.

Références Real2Proxy(), x, et y.

◆ operator<<()

ostream & operator<< ( ostream & o,
Real2Proxy t )
related

Ecrit le couple t sur le flot o.

Définition à la ligne 288 du fichier Real2Proxy.h.

Références printXy(), et Real2Proxy().

◆ operator>>()

istream & operator>> ( istream & i,
Real2Proxy & t )
related

Lit le couple t à partir du flot o.

Définition à la ligne 298 du fichier Real2Proxy.h.

Références assign(), et Real2Proxy().

Documentation des données membres

◆ x

RealProxy Arcane::Real2Proxy::x

première composante du couple

Définition à la ligne 66 du fichier Real2Proxy.h.

Référencé par abs2(), add(), addSame(), assign(), assign(), div(), divSame(), isNearlyZero(), mul(), mulSame(), Arcane::operator*(), Arcane::operator*(), operator*(), operator*=(), operator+(), operator-(), operator-(), Arcane::operator/(), operator/(), operator/=(), operator=(), operator==(), Real2Proxy(), Real2Proxy(), reset(), sub(), et subSame().

◆ y

RealProxy Arcane::Real2Proxy::y

deuxième composante du couple

Définition à la ligne 67 du fichier Real2Proxy.h.

Référencé par abs2(), add(), addSame(), assign(), assign(), div(), divSame(), isNearlyZero(), mul(), mulSame(), Arcane::operator*(), Arcane::operator*(), operator*(), operator*=(), operator+(), operator-(), operator-(), Arcane::operator/(), operator/(), operator/=(), operator=(), operator==(), Real2Proxy(), Real2Proxy(), reset(), sub(), et subSame().

La documentation de cette classe a été générée à partir du fichier suivant :