Calcul tensoriel/Espace-temps plan/Référentiel tournant I

Changement de coordonnées.
Partant d'un référentiel galiléen plan formula_1, construisons un référentiel tournant
avec la fréquence angulaire formula_2. La transformation s'écrit
Tenseur métrique.
De la relation formula_5 est facile d'obtenir le
tenseur métrique
dans le référentiel tournant. Il n'est pas diagonal :
La formule formula_7 avec formula_8, conduit au même résultat.
Équation géodésique.
Pour les vitesses petites devant la vitesse de la lumière, on a formula_15
et on peut écrire
On retrouve les termes classiques d'accélération centrifuge et d'accélération de Coriolis.
Tenseur de courbure.
Nul. Le calcul peut se faire à partir de la formule ou plus simplement en remarquant que le tenseur de courbure de l'espace pseudo-euclidien de métrique constante formula_17
est nul, et reste nul dans toute autre système de coordonnées.

Calcul tensoriel/Espace-temps plan/Référentiel tournant

Référentiel tournant en coordonnées cartésiennes
Référentiel tournant en coordonnées circulaires

Calcul tensoriel/Espace-temps plan/Référentiel tournant II

Changement de coordonnées.
Partant d'un référentiel galiléen plan en coordonnées circulairesformula_1,
construisons un référentiel tournant avec la fréquence angulaire formula_2. La transformation s'écrit
formula_3
Tenseur métrique.
De la relation formula_4 est facile d'obtenir le
tenseur métrique
dans le référentiel tournant. Il n'est pas diagonal :
formula_5
Déterminant du tenseur métrique.
formula_6
Matrice inverse du tenseur métrique.
formula_7
Dérivées partielles du tenseur métrique.
formula_8
Symbole de Christoffel.
formula_9
formula_10

Programmation C++/Les pointeurs
Introduction.
Une variable correspond à un emplacement en mémoire (adresse) où se trouve une valeur.
Toute variable "a" permet d'accéder :
int a;
a = 10; // écriture de la valeur de a
cout « "A vaut " « a ; // lecture de la valeur de a
cout « "L'adresse de A est " « &a ; // lecture de l'adresse de a
Un pointeur désigne un type particulier de variable dont la valeur est une adresse.
Un pointeur permet donc de contourner la restriction sur le choix de l'adresse d'une variable, et permet essentiellement d'utiliser la mémoire allouée dynamiquement.
Il est utilisé lorsque l'on veut manipuler les données stockées à cette adresse.
C'est donc un moyen indirect de construire et de manipuler des données souvent très complexes.
Déclaration.
 "type* identificateur;"
La variable "identificateur" est un pointeur vers une valeur de type "type".
L'opérateur &.
C'est l'opérateur d"'indirection". Il permet d'obtenir l'adresse d'une variable, c'est-à-dire un pointeur vers cette variable.
 "&identificateur" // permet d'obtenir l'adresse mémoire de la variable "identificateur"
Il renvoie en réalité une adresse mémoire, l'adresse où est stockée physiquement la variable "identificateur".
L'opérateur *.
 "*variable"
C'est l'opérateur de "déréférencement". Il permet d'obtenir et donc de manipuler les données pointées par la variable "variable". Ainsi codice_1 permet d'accéder à la valeur pointée par "pointeur" en lecture et en écriture.
Comparaison avec une variable classique.
int a;
int* pA;
pA = &a; // l'adresse de a est stockée dans pA
Le pointeur codice_2 peut par la suite pointer l'adresse d'une autre variable, où bien pointer l'adresse d'un bloc de mémoire alloué dynamiquement.
Exemple de programme.
using namespace std;
int main()
 int a, b, c;
 int *x, *y;
 a = 98;
 x = &a;
 c = *x + 5;
 y = &b;
 *y = a + 10;
 cout « "La variable b vaut : " « b « endl;
 cout « "La variable c vaut : " « c « endl;
 return 0;
Exécution.
 La variable b vaut 108
 La variable c vaut 103
Opérations arithmétiques sur les pointeurs.
Hormis l'opérateur de déréférencement, les pointeurs peuvent être utilisés avec l'opérateur d'addition ( "+" ). L'addition d'un pointeur avec une valeur entière permet d'avancer ou reculer le pointeur du nombre d'éléments indiqué.
Exemple 1.
char* ptr="Pointeur"; // ptr pointe le premier caractère de la chaîne de caractères
cout « ptr « endl; // affiche "Pointeur"
ptr = ptr+3;
cout « ptr « endl; // affiche "nteur"
cout « ++ptr « endl; // affiche "teur"
cout « --ptr « endl; // affiche "nteur"
Comme l'exemple précédent le montre, il est également possible d'utiliser les opérateurs d'incrémentation et de décrémentation.
Exemple 2.
int premiers[] = { 2, 3, 5, 7, 11, 13, 17 };
int* ptr = premiers; // pointe le premier élément du tableau
cout « hex « ptr « endl; // affiche l'adresse pointée (par exemple 01C23004) 
cout « *ptr « endl; // affiche "2"
cout « *(ptr+5) « endl; // affiche "13"
ptr=&premiers[3]; // pointe le 4e élément (index 3)
cout « hex « ptr « endl; // affiche l'adresse pointée (par exemple 01C23018)
cout « *ptr « endl; // affiche "7"
cout « *(ptr-1) « endl; // affiche "5"
Dans l'exemple 2, la différence d'adresse est de 20 octets (codice_8).
Cela montre que l'adresse contenue dans le pointeur est toujours incrémentée ou décrémentée d'un multiple de la taille d'un élément (codice_9).
Opération utilisant deux pointeurs.
La seule opération valable (ayant un sens) utilisant deux pointeurs de même type est la soustraction ( codice_10 ) donnant le nombre d'éléments entre les deux adresses.
Elle n'a de sens que si les deux pointeurs pointent dans le même tableau d'éléments.
Exemple :
char str[]="Message où rechercher des caractères.";
char *p1 = strchr(str,'a'); // recherche le caractère 'a' dans str
char *p2 = strchr(str,'è'); // recherche le caractère 'è' dans str
cout « "Nombre de caractères de 'a' à 'è' = " « (p2-p1) « endl;
// affiche : Nombre de caractères de 'a' à 'è' = 28
Pointeur constant et pointeur vers valeur constante.
Il ne faut pas confondre un pointeur constant (qui ne peut pointer ailleurs) avec un pointeur vers une valeur constante (l'adresse contenue dans le pointeur peut être modifiée mais pas la valeur pointée).
Dans les 2 cas le mot clé codice_11 est utilisé, mais à 2 endroits différents dans le type de la variable.
Pointeur vers une valeur constante.
Le mot-clé codice_11 placé avant le type du pointeur permet d'empêcher la modification de la valeur pointée.
Exemple:
const char* msg = "essai constant";
msg = "Test"; // OK -> le pointeur contient l'adresse de "Test"
Pointeur constant.
Le mot-clé codice_11 placé entre le type du pointeur et le nom de la variable permet d'empêcher la modification du pointeur lui-même (l'adresse).
Exemple:
char* const msg = "essai constant";
msg = "Test"; // <- Interdit (erreur de compilation),
 // ne peut pointer la chaîne "Test"
Pointeur constant vers une valeur constante.
Le mot-clé codice_11 apparaissant aux 2 endroits empêche à la fois la modification du pointeur lui-même et celle de la valeur pointée.
Exemple:
const char* const msg = "essai constant";
msg = "Test"; // <- Interdit (erreur de compilation),
 // ne peut pointer la chaîne "Test"
Position du mot clé codice_11.
Une méthode simple a été proposée par Dan Sacks pour déterminer si c'est la valeur pointée ou le pointeur lui-même qui est constant.
Elle se résume en une seule phrase mais n'a jamais été intégrée dans les compilateurs :
 "codice_11 s'applique toujours à ce qui le précède".
Par conséquent, une déclaration ne commencera jamais par codice_11 qui ne serait précédé de rien et qui ne pourrait donc s'appliquer à rien.
En effet, les deux déclarations suivantes sont strictement équivalentes en C++ :
 const char * msg; // déclaration habituelle
 char const * msg; // déclaration Sacks
Cette méthode peut s'avérer précieuse dans le cas de déclarations plus complexes :
 int const ** const *ptr; // ptr est un pointeur vers un pointeur constant de pointeur d'entier constant :
 // *ptr et ***ptr ne peuvent être modifiés