Récréations mathématiques autour des réels

[invitefd4e7c09]

Bonjour,

Prenons un réel mettons et intéressons nous à ses décimales :


Réécrivons ces décimales en utilisant le fait que chaque décimale *appelle* une autre décimale :
appelle la 4e décimale à savoir
appelle la 1ere décimale à savoir
appelle la 42e décimale à savoir
(et oui car 4 à déja était appelé donc on prend l'entier composé par deux décimales)
appelle la 13e décimale à savoir
appelle la 5e décimale à savoir
appelle la 6e décimale à savoir
....
On aboutit au final à la création d'un réel dont les décimales sont :


Questions :
*********
1/ Existe t il des gens qui se sont intéressés à ce type de transformation ?
2/ Pensez vous qu'on puisse en déduire des propriétés ?
Je pensais notamment aux invariances (cf nombre de Champernowne)
Je pensais également à des réels qui au fil des transformations deviendraient invariants.

Cordialement
Anthony
-----

[invitefd4e7c09]

Re,

Peut être n'ai je pas écrit sur le bon forum (mathématiques du supérieur).
Médiat peut il me réorienter vers un forum plus approprié pour ce type de discussion (récréations mathématiques)?

Cordialement
Anthony

[Médiat]

Bonjour,

Je veux bien le mettre où vous voulez, mais si le mode est ludique, les démonstrations pour trouver des cycles doivent être très difficiles (pour les invariants, je ne serais pas surpris que le seul soit la constante de Champernowne (dans toutes les bases)

[invite986312212]

bonjour,

je ne connais pas cette transformation, mais si tu t'intéresses à ce genre de "récréations" je ne peux que te conseiller le livre de Richard K Guy "unsolved problems in number theory" qui contient quelques problèmes un peu dans ce style (et qui est abordable sans connaissances très pointues). Je vois qu'il se trouve sur google books.

[A voir en vidéo sur Futura]

[invitefd4e7c09]

Bonjour,
(pour les invariants, je ne serais pas surpris que le seul soit la constante de Champernowne (dans toutes les bases)

En fait il y en a une infinité de nombres réels invariants avec ce type de transformation :
****************************** ****************************** *********




etc ...
mais aussi (plus subtil) :
*******************


etc ...


etc ...


etc etc etc ....

Qu'entendez vous par base ?

[invitefd4e7c09]

bonjour,

je ne peux que te conseiller le livre de Richard K Guy "unsolved problems in number theory" qui contient quelques problèmes un peu dans ce style (et qui est abordable sans connaissances très pointues).

Merci pour l'info peut être que ce Richard K Guy s'est intéressé précisément à ce type de transformation.

[Médiat]

Effectivement, je me suis fait avoir, car je pensais qu'il fallait que le premier nombre génère entièrement le deuxième.

Par base, je parlais des bases de numération.

[invitefd4e7c09]

Re,

Aujourd'hui j'ai tenté d'appliquer ce type de transformation sur les décimales de et comme vous pouvez vous en douter, on aboutit à rien de spécialement parlant :

L'inverseur de Plouffe boude ces décimales et je vous avouerais que je n'ai pas le courage de calculer les transformées successives de car c'est long et sujet aux erreurs.
Au même titre que les dérivées nième, la moindre erreur sur la transformée de *niveau* entraine inexorablement une erreur sur les transformées suivantes.

Face à cela, je me demande s'il est possible à l'aide d'un logiciel type Maple d'aller chercher la nième décimale de . Ce logiciel possédant une bibliothèque de fonctions assez vaste, il doit être possible d'aller chercher la nième décimale de ?

[Dlzlogic]

Bonjour,
A mon avis, pour faire un logiciel qui va chercher la nième décimale de pi, il faudrait en avoir besoin, mais je pense que c'est pas très difficile à réaliser.

[invite4492c379]

Hello,

le plus simple pour accéder à la nième décimale de PI est d'utiliser internet comme ressource. Une brève recherche donne par exemple un lien vers un site qui propose un fichier qui en contient 4 millions : http://zenwerx.com/projects/pi-digits/pi/

[invitefd4e7c09]

Oui je connais aussi un site qui donne beaucoup de décimales de écrites savamment par lignes de 100 et par paragraphes ....
Mais je pense avoir trouvé sur Maple une façon simple d'avoir la nieme décimale de

Exemple avec la 97e décimale :
*************************
Digits := 99;
eval(Pi);

il suffit alors de récupérer l'avant dernière décimale à droite de l'écran.

[invitefd4e7c09]

Voici un petit programme gracieusement offert :

DECIMALE:=proc(x,n)local n1,q; 
> n1:=floor(x*10^n);
> q:=n1 mod 10: 
> end proc:
> DECIMALE((Pi),97);

                                  0

> evalf(Pi);

  3.14159265358979323846264338327950288419716939937510582097494459\
        2307816406286208998628034825342117068

> Digits:=100;

                            Digits := 100

Ci dessus vous pouvez apercevoir le calcul de la 97e décimale de
Cela fonctionne bien mais je veux aller plus loin encore.

[invite4492c379]

Plus loin ? Beaucoup plus loin ? Tu n'as besoin que du nème chiffres ?

[invitefd4e7c09]

Plus loin ? Beaucoup plus loin ? Tu n'as besoin que du nème chiffres ?

J aimerais rentrer une suite de décimales a Maple et qu il me retourne directement la transformée

[invitefd4e7c09]

J'ai commencé à travailler avec les décimales de pi avec ce code :

> Digits:=100;

                            Digits := 100

> DECIMALE:=proc(x,n)
> local n1,q;
> n1:=floor(x*10^n);
> q:=n1 mod 10:
> end proc:
> DECIMALE(evalf(Pi),15);

                                  3

> for i from 1 to 10 do print(DECIMALE(evalf(Pi),DECIMALE(evalf(Pi),i))) end do;

                                  1


                                  5


                                  1


                                  9


                                  3


                                  4


                                  2


                                  9


                                  1


                                  9

Mais ce code ne gère pas le cas d'une décimale déjà utilisée :

Exemple :
*********

141592653

1 appelle la 1ere décimale à savoir 1
4 appelle la 4e décimale à savoir 5
1 appelle la 1ere décimale à savoir 1 mais cette décimale à déjà été utilisé donc je prend deux décimales :
15 appelle la 15e décimale à savoir 3
9 appelle la 9e décimale à savoir 3
2 appelle la 2e décimale à savoir 4
.......

[invite4492c379]

Àmha, ta méthode est lourde (récupérer les décimales de pi en faisant des calculs flottants ...)

A priori il serait plus simple de traiter ton problème comme une simple réécriture. Tu stockes tes décimales dans un tableau (ou chaine de caractères par exemple), puis tu le parcours en construisant l'index du caractère que tu recherches en n'oubliant pas de stocker également les index déjà utilisés (soit dans ton objet pi soit à côté).

En gros un truc du genre

type décimale :
        valeur  : entier
        utilisée : booléen
fin type

fonction Réécrire( entrée : décimale[] ) : décimale[]
début
        indexEntrée : entier // sera l'index de la décimale courante
        indexCalculé : entier // sera l'index de la décimale pour la réécriture
        indexSortie : entier // sera l'index pour écrire dans le tableau de sortie

        sortie : decimale[]

        valide : booléen

        indexEntrée = 0 // mes tableaux commencent à 0
        indexCalculé = 0
        indexSortie = 0

        tant que indexEntrée<entrée.Longueur faire
            faire
                indexCalculé = indexCalculé * 10 + entrée[indexEntrée].valeur
                indexEntrée = indexEntrée + 1
                si (indexCalculé > entrée.Longueur) ou (indexEntrée>=entrée.Longueur) alors
                    retourner sortie
            tant que entrée[indexCalculé].utilisée = vrai

            sortie[indexSortie] = entrée[indexCalculé]
            indexSortie = indexSortie + 1
            indexCalculé = 0
        fin tantque

        retourner sortie
fin

Bon un algo simple jeté comme ça, il n'est certainement pas parfait mais c'est pour te donner une idée.

[invitefd4e7c09]

Àmha, ta méthode est lourde

C'est fort probable car je suis toujours une calamité en informatique.

type décimale :
        valeur  : entier
        utilisée : booléen
fin type

fonction Réécrire( entrée : décimale[] ) : décimale[]
début
        indexEntrée : entier // sera l'index de la décimale courante
        indexCalculé : entier // sera l'index de la décimale pour la réécriture
        indexSortie : entier // sera l'index pour écrire dans le tableau de sortie

        sortie : decimale[]

        valide : booléen

        indexEntrée = 0 // mes tableaux commencent à 0
        indexCalculé = 0
        indexSortie = 0

        tant que indexEntrée<entrée.Longueur faire
            faire
                indexCalculé = indexCalculé * 10 + entrée[indexEntrée].valeur
                indexEntrée = indexEntrée + 1
                si (indexCalculé > entrée.Longueur) ou (indexEntrée>=entrée.Longueur) alors
                    retourner sortie
            tant que entrée[indexCalculé].utilisée = vrai

            sortie[indexSortie] = entrée[indexCalculé]
            indexSortie = indexSortie + 1
            indexCalculé = 0
        fin tantque

        retourner sortie
fin

Ou la la mais ne serait ce pas du C ou du java ce code ?
J'ai pas tout compris mais je vais voir ce que ça donne.
Existe t il un espace en ligne pour pouvoir tester ce code ?

[invite4492c379]

C'est un algo, donc pas de langage particulier. Il faut juste l'implémenter ensuite ; généralement tant que devient while, si alors devient if then , etc ...

Un algo ne fait que décrire en Français ce que tu veux faire.

[invitefd4e7c09]

Un algo ne fait que décrire en Français ce que tu veux faire.

Eh bien c'est loupé car je ne comprends rien de tout cela.
A la limite je préfère encore le langage du GRAFCET qui est beaucoup plus clair (du moins à mes yeux)
Je crois que je suis fâché en fait avec les langages de programmation (surtout avec le C)

[invite4492c379]

Imagine :

Tu as une feuille devant toi sur laquelle sont inscrites les 1000 premières décimales de pi. Elle sont rangées dans un tableau, une décimale par cellule, chaque cellule est numérotée. Par convention on va dire que la première décimale se trouve dans la case numérotée 0.

Je dispose de la même feuille, identique en tout point. Je dispose d'un stylo et le but est de me faire écrire le nombre que tu désires en me faisant effectuer des manipulations simples.

Les ordres que tu peux utiliser sont :

me faire créer un tableau, une liste ou des variables de type quelconque.
récupérer ou mettre un valeur dans un tableau ou une variable.
me faire répéter des action en utilisant des mots comme "pour tous les éléments du tableau", "tant que «cette condition» est vraie", "si «condition» alors action sinon action"

Alors vas-y, explique moi ce que je dois faire

[invitefd4e7c09]

Alors vas-y, explique moi ce que je dois faire

A peu près ce qui se trouve sur le fichier ci-joint

[invite4492c379]

Hello,

Imagine un nombre dont les cent premières décimales sont des 1 et les cent suivantes des 2 ... il va y avoir un petit problème avec ton algo.

Tu arrives à traduire cet algo dans un langage particulier ?

[invitefd4e7c09]

Voici ci joint une méthode plus fiable pour transformer une série de décimales :
GRAFCET-1.pdf

[invite4492c379]

Hello,

Ça a l'air mieux. Tu peux également fusionner les deux branches, car le cas une décimale correspond au cas k=1.

Arrives tu à l'implémenter maintenant ?

[invitefd4e7c09]

Tu peux également fusionner les deux branches, car le cas une décimale correspond au cas k=1.

Arrives tu à l'implémenter maintenant ?

C'est exactement ce que je pensais, la branche de gauche est de trop et peut être effacer à condition d'initialiser la variable k à 1.

Non je n'arrive pas à l'implémenter mais je vais déjà essayer de le reformuler sous forme de GRAFCET en m'affranchissant de cette longue divergence en OU qui est inutile.

[invitefd4e7c09]

Après avoir nettoyé le GRAFCET, j'aboutis finalement à ceci :

GRAFCET2.pdf

NB : Après coup, je me suis rendu compte que la numérotation des étapes ne ressemble plus à grand chose mais qu'importe ce ne sont que des nombres pour désigner des étapes

[invitefd4e7c09]

Je ne sais plus si ce fil qui vire à l'informatique a toujours sa place en mathématique mais je poursuis :

Mon programme pourrait commencer par la déclaration des variables ainsi que leurs initialisations.
Je distingue ainsi 5 variables :
***********************
* i, j, k et n qui sont des entiers
* tab qui est un tableau

Initialisation :
**********
i:=1
j:=0
k:=1
n dépend directement du nombre de décimales inscrites par l'utilisateur
tab=0

[invitefd4e7c09]

En y réfléchissant je crois que n n'est pas une variable mais plutôt une constante qui est définie par le nombre de décimales inscrites par l'utilisateur.

[invitefd4e7c09]

Re,

Après essais, j'aboutis à un résultat qui n'a peut être rien de surprenant :

Observons les décimales de et notons la transformée de niveau de . Par analogie avec la dérivée on parlera de transformée nième :
****************************** *








Autrement dit, les transformations successives de convergent vers (3+1/9) et cela dès la transformée 3e de .

Cordialement
Anthony

[invitefd4e7c09]

De la même manière, les transformations successives des décimales constituées par la suite des nombres premiers convergent vers et cela dès la transformée 2e.
A contrario, les transformations successives des décimales de ne convergent pas et oscillent entre et . C'est comme s'il y avait une période qui vaut deux.
D'autres cas encore admettent des périodes égales à tel