Bibm@th

Forum de mathématiques - Bibm@th.net

Bienvenue dans les forums du site BibM@th, des forums où on dit Bonjour (Bonsoir), Merci, S'il vous plaît...

Vous n'êtes pas identifié(e).

#226 Re : Entraide (supérieur) » Approche logico-algébrique vulgarisée des complexes » 24-09-2024 15:06:16

Reouven a écrit :

Il ne faut pas mélanger le sujet et l'initiative du document, avec l'objectif de cette discussion.

Qui est uniquement de recueillir toutes remarques sur l'initiative avec le moins de censure possible.

Bonjour,

L’initiative, c’est la présentation d’un document mathématique sur un forum dédié. On peut discuter certes du document lui-même, sa formulation par exemple, on peut aussi discuter des informations spécialisées qui vont être fournies.

Si elles sont intégrées au document, cela devient un travail collectif, et si elles sont négligées, quel est alors l’intérêt d’une présentation ?

Autrement dit, le document est-il une ébauche qui cherche à bénéficier des interventions de spécialistes ou est-il un travail achevé pas vraiment discutable ?

#227 Re : Entraide (supérieur) » Approche logico-algébrique vulgarisée des complexes » 24-09-2024 15:02:43

bridgslam a écrit :

Bref, pour conclure, je dirais avec une conviction certaine que le mieux (avis tout personnel ) est d'éviter d'ennuyer des lycéens avec un document qui, outre sa notation tarabiscotée, ne fait que tourner autour du pot, sans rien créer ni inventer.

Bonjour,

Sur ce point on est bien sûr d’accord. Au début, j’ai cru que la présentation allait simplifier les choses, en ce qui me concerne cela n’a pas été le cas, donc j’ai décroché.

#228 Re : Entraide (supérieur) » Approche logico-algébrique vulgarisée des complexes » 24-09-2024 10:48:47

bridgslam a écrit :

Le terme "doublement" tient au fait que son existence, encore une fois à 100% hypothétique en suivant vôtre démarche, est pure imagination.
Ça enfonce le clou, puisque l'objet sorti d'un chapeau a une bouille justement d'....imaginaire ( i au hasard ?)

Bonjour,

Moi les objets mathématiques sortis d’un chapeau ne m’ont jamais dérangé, vu que tous ont à mes yeux cette propriété. Choisir des capitales creuses genre $\mathbb{N}$, $\mathbb{Z}$, $\mathbb{Q}$, $\mathbb{R}$ ou $\mathbb{C}$ auxquelles on ajoute des $^{\ast +0}$ à sa convenance, pour moi c’est du même registre. Se mettre à distinguer les infinis à coup d’$\aleph$, même chose. Ou les divisions par zéro strictement interdites paraît-il mais qu’on évalue quand même obstinément. En math tout est possible, ce ne sont pas les chapeaux qui manquent. On m’a expliqué la topologie avec des trous et des ficelles, la géométrie avec des trompettes et des selles de cheval, alors ici un tilde de plus ou de moins n’est pas le sujet, je le dis comme je pense. On ne peut pas à la fois promouvoir le questionnement en mathématiques et renvoyer d’un ton goguenard à des médaillés Fields celui qui essaie de nouvelles approches, quand bien même elles seraient stériles.

Comme je crois l’avoir exprimé, je décroche parce que la notation m’est hermétique et que je ne la comprends pas, rien d’autre. Je n’ai aucune idée de sa validité ou de son utilité. N’empêche, il y a quelque chose d’intéressant à faire des maths en amateur, c’est un peu comme dessiner ou chanter. Ce n’est pas parce qu’on n’a pas le niveau Beaux-Arts ou Conservatoire qu’on ne trouve pas du plaisir à découvrir des choses, à expérimenter, on le voit d’ailleurs avec la conjecture de Syracuse ou les triplets pythagoriciens, le bonheur d’inventer l’eau tiède...

#229 Re : Entraide (supérieur) » Approche logico-algébrique vulgarisée des complexes » 22-09-2024 17:50:40

Bonjour,

Un avis succinct sur le document (tiens, j’ai noté une coquille au deuxième paragraphe, « De document présente … » au lieu de « Ce document … ») d’un non mathématicien simplement bachelier en section scientifique.

Au départ, si un tel document s’adresse à des personnes ayant déjà abordé les complexes, c’est mort : la confrontation à $i^{2}=-1$ a déjà eu lieu.

La référence à des structures algébriques est, en ce qui me concerne, largement dissuasive (et j’en suis désolé) pour aborder de façon plus accessible le concept de $i^{2}$, vu que je n’ai pas retenu grand-chose des structures d’anneau, de groupe, de corps ou de je ne sais quoi d’autre.

Et hélas, une nouvelle notation est carrément rédhibitoire – toujours en ce qui me concerne – parce qu’elle fait disparaître l’exposant qui n’a donc plus de valeur qui lui serait propre, et que cette notation m’est étrangère. Pour moi toujours, noter $n\sim$ pour $n^{2}$ consiste simplement à remplacer un exposant par un tilde. Bon, ok, pourquoi pas, sauf qu’il est écrit « apparaît un autre $m$ », quel autre, je ne sais pas d’où il sort, je n’ai jamais vu le premier, et enfin $n~$ devient $n *\sim m$ ce qui pour moi n’a plus aucun sens puisque $n$ redevient une variable, j’imagine que $*$ représente ici la multiplication (donc $n\times \ldots$), que le tilde l’exposant ($n\times n$) et je ne comprends pas l’apparition du $m$.

Je ne suis donc pas allé plus loin.

En tout cas voilà le regard extérieur de quelqu’un avec un bagage certes limité mais quand même déjà construit, donc avec une logique qui lui est propre. Je voulais t’en faire part pour que tu aies un retour naïf ou candide sur une présentation sur laquelle je décroche faute des automatismes supposés à la manipulation de tels concepts.

#230 Re : Entraide (collège-lycée) » Taux de conversion » 15-09-2024 10:18:21

Bastos a écrit :

je bloque a savoir a quel point il est plus intéressant d'utiliser le turbocarburant soit en pourcentage soit en nombre entier et avec quel calcul si possible que je puisse progresser.

Bonjour,

Le mieux, c'est de tout ramener à l'unité. Par exemple 18,75 uT -> 625 MW est équivalent à écrire que 1 unité Turbo est égale à 625/18,75 MW. Une fois que tu as cela, tu peux calculer l'énergie de 10 unité ou de 0,75 unité, il suffira de multiplier l'énergie unitaire par la quantité de carburant Turbo dont tu disposes.

Même chose bien sûr avec le carburant normal, calculer l'énergie unitaire.

Une fois arrivé là, tu auras l'énergie d'une unité Turbo et d'une unité Normal. Reste à appliquer le taux de conversion, c'est peut-être là le moins intuitif quand on a fait plusieurs opérations avant.

Combien de carburant turbo obtient-on avec une unité normale ? Toujours la même logique, 45 u -> 37,5 uT revient à dire qu'une unité normale fabrique 37,5/45 unité turbo. Il suffit de multiplier par l'énergie Turbo unitaire trouvé précédement pour avoir l'énergie obtenue par une unité normale de carburant si transformation.

De là tu as deux nombres : l'énergie fournie par 1 litre de carburant normal, et celle fournie par le même litre après conversion. Pour en faire le pourcentage, même logique, tu divises le nombre converti par le nombre normal, tu multiplies par 100, et tu as le pourcentage d'amélioration ou de perte en passant au Turbo carburant.

Bonne progression !

#231 Re : Programmation » [Python]Kit d'aide à la cryptanalyse » 01-09-2024 21:20:40

Bonsoir,

DrStone a écrit :

Pour te donner une idée, voici vers quoi tu veux te lancer : https://www.math.univ-paris13.fr/~boyer … to2010.pdf. Et il s'agit seulement d'un cours pour "débutant".

Ah oui, c'est touffu. J'aime beaucoup le point 1.2 et 1.3 qui expliquent bien, je trouve, les développements actuels et surtout la nécessité de l'open source. Merci pour ce lien.

#232 Re : Entraide (supérieur) » Dénombrement » 01-09-2024 21:13:54

Bonsoir,

Michel Coste a écrit :

Dénombrement pour deux alignés (dans une des trois directions) sur le plateau d'Abalone :
$$(1\times24+6\times22+12\times20+18\times18+24\times 16)/2$$Ce qui fait une proba (en supposant les positions équiprobables) de $92/305 \simeq 30,16\%$

Ah oui, très bien ! Je suis toujours admiratif de ces formules, perso il me faut des millions de simulations pour approcher cette valeur, qu’on en juge :

Avec Python et interpréteur en ligne :

Taille du plateau: 5 emplacements par côté
Nombre de billes: 2
Nombre total de simulations: 1 000 000
Nombre d'alignements trouvés: 302 100
Taux d'alignement: 30,2100 %
Temps d'exécution total: 31,66 secondes

En C compilé sur ma bécane :

Taille du plateau: 5 emplacements par côté
Nombre de billes: 2
Nombre total de simulations: 100 000 000
Nombre d'alignements trouvés: 30 161 130
Taux d'alignement: 30,1611 %
Temps d'exécution total: 24,98 secondes

En poussant les feux j’arrive au milliard (C multi-threadé sur ma bécane i7 8 coeurs)

Taille du plateau: 5 emplacements par côté
Nombre de billes: 2
Nombre total de simulations: 1 000 000 000
Nombre d'alignements trouvés: 301 620 323
Taux d'alignement: 30,1620 %
Temps d'exécution total: 34,87 secondes

Bon, il n’y a peut-être pas besoin d’autant, n’empêche que je suis content de voir qu’on trouve la même chose, j’ai toujours peur de me planter.

#233 Re : Entraide (supérieur) » Dénombrement » 01-09-2024 18:17:06

bridgslam a écrit :

pour dénombrer les cas favorables, il faut bien se placer dans un cas de figure déterminé et s'y tenir.

C'est vrai, d'autant que ce qu'on appelle « alignement » est déjà en soi une problématique.

En restant sur un tableau orthogonal classique genre papier quadrillé, quid des diagonales ? Les grandes diagonales ok, mais celles qui lui sont parallèles ? Puisque les jetons peuvent être superposés, rien n'empêche d'avoir les cinq jetons sur quatre ou trois emplacements seulement, donc des diagonales courtes, voire alignés « géométriquement » comme dans ces quelques exemples :

. . x . .     o . . x .     x . . . o
. . . x o     . . o . .     . . x . .
. . . o x     . . x . o     . . . o x
. . o . .     . . . . .     . . . . .
. o . . .     . x . . .     . . o . .
. . . x .     . . . x .     . . . . .
. . . . x     . x . . .     . . . . .
. . . . o     . . . . .     o . . . .
. . . . .     o . . . .     . . . x .
. . o . .     . . . o .     . . . . .

On revient donc bien au problème des dénombrements, titre de cette enfilade, et je me souviens de casse-têtes géométriques dans lesquels on devait dénombrer les triangles ou des rectangles crées par des figures enchevêtrées, rigolo.

#234 Re : Entraide (supérieur) » Dénombrement » 01-09-2024 17:53:29

bridgslam a écrit :

simulations avec 5 jetons placés au hasard sur un plateau ... d'Abalone ... :-)

Re-bonjour,
J’ai d’abord testé un plateau d’Abalone avec deux billes au hasard – qui ne peuvent pas se superposer, normal, ce sont des billes – avec affichage si alignement ou non, pour ce genre de sortie :

Plateau 15:
        . . . . .
       . . . . ● .
      . ● . . . . .
     . . . . . . . .
    . . . . . . . . .
     . . . . . . . .
      . . . . . . .
       . . . . . .
        . . . . .
NON

Plateau 16:
        . . . . .
       . . . . . .
      . . . . . . .
     . . . . . . . .
    . . . . . . ● . .
     . . . . . . . .
      . . . . . . .
       . . . . . .
        . . . ● .
NON

Plateau 17:
        . . . . .
       . . ● . . .
      . . . . . . .
     . . . . . . . .
    . . . . . . . . .
     . . . . . . . .
      . . . . . . .
       . . . . . ●
        . . . . .
OUI

Plateau 18:
        . . . . .
       . . . . . .
      . . . . ● . .
     . . . . . . . .
    . . . . . . . . .
     . . . ● . . . .
      . . . . . . .
       . . . . . .
        . . . . .
OUI

Plateau 19:
        . . . . .
       . . . . . .
      . . ● . . . .
     . . . . . . . .
    . ● . . . . . . .
     . . . . . . . .
      . . . . . . .
       . . . . . .
        . . . . .
NON

Plateau 20:
        . . ● . .
       . . . . . .
      . . . . . . .
     . . . . . . . .
    . . . . . . . . .
     . . . . . . ● .
      . . . . . . .
       . . . . . .
        . . . . .
OUI

Une fois que c’est validé, statistiques sur une centaine de tirages, extrait :

Alignement trouvé (simulation 91):
        . . . . .
       . . . . . .
      . . . . . . .
     . . . . . . . .
    . ● ● . . . . . .
     . . . . . . . .
      . . . . . . .
       . . . . . .
        . . . . .

Alignement trouvé (simulation 93):
        . . . . .
       . . . . . .
      . . . ● ● . .
     . . . . . . . .
    . . . . . . . . .
     . . . . . . . .
      . . . . . . .
       . . . . . .
        . . . . .

Alignement trouvé (simulation 97):
        . . . . .
       . . . ● . .
      . . . . . . .
     . . . . . . . .
    . . . . . . . . .
     . . . . . . . .
      . . . . . . .
       ● . . . . .
        . . . . .

Alignement trouvé (simulation 100):
        . . . . .
       . . . . . .
      . . . . . . .
     . . . . . . . .
    . . . . . . . . .
     . . . . . . . .
      . . . . . . .
       . . . . . .
        . ● . . ●

Statistiques finales:
Nombre total de simulations: 100
Nombre d'alignements trouvés: 31
Taux d'alignement: 31.00%

Donc ça marche, fin des procédures de vérification.

Dans ce cas, proba d’alignement de $2$ billes sur un plateau d’Abalone :
Nombre total de simulations: 1 000 000
Nombre d'alignements trouvés: 301 203
Taux d'alignement: 30.120%
Temps d'exécution total: 27.26 secondes

On passe à $3$ billes, les probas s’effondrent :
Nombre total de simulations: 1 000 000
Nombre d'alignements trouvés: 27 366
Taux d'alignement: 2.737%
Temps d'exécution total: 30.76 secondes

Et enfin avec $5$ billes :
Nombre total de simulations: 1 000 000
Nombre d'alignements trouvés: 156
Taux d'alignement: 0.016%
Temps d'exécution total: 42.26 secondes

J’ai mis ici le programme en Python, qui permet de modifier la taille du plateau, le nombre de billes et le nombre de simulations directement dans le script, tout en bas :

import random
import time

class Board:
    def __init__(self, side_length):
        self.side_length = side_length
        self.cells = {}
        for q in range(-side_length + 1, side_length):
            r_start = max(-side_length + 1, -q - side_length + 1)
            r_end = min(side_length - 1, -q + side_length - 1)
            for r in range(r_start, r_end + 1):
                s = -q - r
                self.cells[(q, r, s)] = None

    def place_random_marble(self):
        empty_cells = [coord for coord, value in self.cells.items() if value is None]
        if empty_cells:
            chosen_cell = random.choice(empty_cells)
            self.cells[chosen_cell] = "black"
            return chosen_cell
        return None

def are_marbles_aligned(marbles):
    if len(marbles) < 2:
        return True
   
    for axis in range(3):
        if all(marble[axis] == marbles[0][axis] for marble in marbles):
            return True
    return False

def run_simulations(num_simulations, num_marbles, side_length):
    start_time = time.time()
    alignments = 0
    for _ in range(num_simulations):
        board = Board(side_length)
        marbles = []
        aligned = True
        for _ in range(num_marbles):
            new_marble = board.place_random_marble()
            if new_marble is None:
                aligned = False
                break
            marbles.append(new_marble)
            if not are_marbles_aligned(marbles):
                aligned = False
                break
       
        if aligned:
            alignments += 1

    end_time = time.time()
    execution_time = end_time - start_time

    alignment_rate = (alignments / num_simulations) * 100

    print(f"Statistiques finales:")
    print(f"Taille du plateau: {side_length} emplacements par côté")
    print(f"Nombre de billes: {num_marbles}")
    print(f"Nombre total de simulations: {num_simulations:,}")
    print(f"Nombre d'alignements trouvés: {alignments:,}")
    print(f"Taux d'alignement: {alignment_rate:.4f}%")
    print(f"Temps d'exécution total: {execution_time:.2f} secondes")

# Définir une seed aléatoire
random.seed(int(time.time()))

# Paramètres configurables
NUM_SIMULATIONS = 1_000_000
NUM_MARBLES = 5
SIDE_LENGTH = 5  # Nombre d'emplacements sur chaque côté du plateau

# Exécuter les simulations
run_simulations(NUM_SIMULATIONS, NUM_MARBLES, SIDE_LENGTH)

#235 Re : Entraide (supérieur) » Dénombrement » 01-09-2024 09:46:18

Bon, je termine.

Les simulations, je les avais programmé tranquillou chez moi, mais pour un forum valait mieux du standard que tout le monde puisse utiliser. La grande mode actuelle c’est Python, ok, mais c’est quand même pas mal lent.

J’ai donc utilisé un assistant IA, ici Perplexity, et je lui ai expliqué ce que j’attendais. Résultat, il m’a pondu ces deux programmes sans une ligne de code de ma part. Bon, faut être honnête, je savais quand même assez bien ce qu’il fallait faire. Quant à l’exécution de ces programmes, il fallait qu’elle soit accessible à tous, donc rien sur ma machine mais tout à distance sur des sites qui proposent les calculs.

On peut se faire une idée de la démarche, la discussion complète (erreurs comprises) est > ici <. Il est toujours possible bien sûr de copier / remplacer le code dans les sites donnés précédemment pour reproduire la progression complète, mais il est peut être plus simple de lire uniquement mes interventions en gras pour comprendre à quel point la méthode de travail est efficace.

(je me demande d'ailleurs s'il ne faudrait pas dupliquer ces deux derniers messages dans la partie « programmation »)

#236 Re : Entraide (supérieur) » Dénombrement » 01-09-2024 09:25:20

Bonjour encore,

Voici le code Python qui permet d’évaluer un million de configurations en moins de dix secondes en le copiant / collant sur ce site (script à gauche, execute en bas)

import random
import time

def optimized_trials(n, num_trials):
    successes = 0
    for _ in range(num_trials):
        rows = [0] * n
        cols = [0] * n
        for _ in range(n):
            x, y = random.randrange(n), random.randrange(n)
            rows[y] += 1
            if rows[y] == n:
                successes += 1
                break
            cols[x] += 1
            if cols[x] == n:
                successes += 1
                break
    return successes

def main():
    n = 5
    num_trials = 1000000
   
    start_time = time.time()
   
    successes = optimized_trials(n, num_trials)
   
    end_time = time.time()
    elapsed_time = end_time - start_time
   
    success_rate = (successes / num_trials) * 100
   
    print(f"Nombre de tirages : {num_trials}")
    print(f"Nombre de succès : {successes}")
    print(f"Pourcentage de succès : {success_rate:.5f}%")
    print(f"Temps d'exécution : {elapsed_time:.2f} secondes")

if __name__ == "__main__":
    main()

En def main() on peut bien sûr s'amuser à changer le nombre de jetons et de tirages.

Le C est beaucoup plus efficace, on peut s'en rendre compte par exemple en copiant / remplaçant le programme sur ce site (script à gauche, execute en haut).

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 5
#define NUM_TRIALS 1000000
#define RAND_MAX_PLUS_1 ((unsigned long long)RAND_MAX + 1)
#define RAND_MAX_PLUS_1_SQUARE ((unsigned long long)RAND_MAX_PLUS_1 * RAND_MAX_PLUS_1)

static inline unsigned long long xorshift64star(void) {
    static unsigned long long x = 1;
    x ^= x >> 12;
    x ^= x << 25;
    x ^= x >> 27;
    return x * 0x2545F4914F6CDD1DULL;
}

static inline unsigned int fast_rand(void) {
    return (unsigned int)(xorshift64star() & 0xFFFFFFFF);
}

static inline unsigned int fast_rand_range(unsigned int limit) {
    return (unsigned int)((fast_rand() * (unsigned long long)limit) >> 32);
}

int main(void) {
    unsigned int successes = 0;
    unsigned int rows[N], cols[N];
    unsigned int i, j, x, y;
    clock_t start, end;
    double cpu_time_used;

    start = clock();

    for (i = 0; i < NUM_TRIALS; ++i) {
        for (j = 0; j < N; ++j) {
            rows[j] = cols[j] = 0;
        }

        for (j = 0; j < N; ++j) {
            x = fast_rand_range(N);
            y = fast_rand_range(N);
            if (++rows[y] == N || ++cols[x] == N) {
                ++successes;
                break;
            }
        }
    }

    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;

    printf("Nombre de tirages : %d\n", NUM_TRIALS);
    printf("Nombre de succès : %u\n", successes);
    printf("Pourcentage de succès : %.5f%%\n", (double)successes / NUM_TRIALS * 100);
    printf("Temps d'exécution : %.2f secondes\n", cpu_time_used);

    return 0;
}

On peut s'amuser à changer le nombre de jetons et le nombre d’essais (N 5 et NUM_TRIAL 1000000 lignes 4 et 5), n'importe comment on tombe bien sur la formule de @bridgslam. Au-delà d'un certain $n$ ça devient compliqué (temps de plus en plus long et nécessité d’augmenter les essais pour avoir quelques succès tant la proba devient faible).

#237 Re : Entraide (supérieur) » Dénombrement » 01-09-2024 09:00:50

Bonjour toujours,

En fait il y a deux cas de figure. Si on compte toutes les dispositions possibles, on obtient ce genre de choses :

n |  Total  |  Alignés | Temps (s)
----------------------------------
1 |       1 |        1 | 0.0000
2 |      16 |       12 | 0.0000
3 |     729 |      153 | 0.0010
4 |   65536 |     2032 | 0.1250
5 | 9765625 |    31225 | 19.410

Si on ne compte que les dispositions uniques, on obtient ce genre de choses :

n |  Total  | Alignées | Temps (s)
-----------------------------------
1 |       1 |        1 | 0.0000
2 |      10 |        8 | 0.0000
3 |     165 |       51 | 0.0000
4 |    3876 |      264 | 0.0080
5 |  118755 |     1235 | 0.2390

En fait il doit y avoir une question d’équiprobabilité là-dedans, quand je simule je tombe sur les premiers chiffres, pas les seconds. Je vais mettre les programmes plus bas, au cas où ça intéresse quelqu’un.

#238 Re : Entraide (supérieur) » Dénombrement » 01-09-2024 08:56:37

Bonjour tout le monde,

Dans mes simulations les jetons sont indistincts. Au départ je pose les cinq au hasard puis j’étudie la validité du placement. Pour n petit cela marche bien, les probabilités d’alignement restent assez élevées et les calculs sont vite menés, mais quand n grandit cela devient problématique parce qu’il y a de moins en moins d’alignements et donc je perds de plus en plus de temps à faire un tas de calculs pour rien, pas top.

Pour aller plus vite, je teste la pose à chaque jeton et je passe à l’essai suivant dès qu’un jeton est mal placé et empêche tout succès ultérieur. Pour tester la validité de ce jeton, inutile d’ailleurs de mémoriser son emplacement exact, il suffit d’incrémenter la ligne et la colonne où il se place. À ce moment, s’il n’y en a pas au moins une des deux qui correspond au nombre de jetons déjà posés, c’est qu’on est hors ligne et hors colonne, donc échec, inutile d’aller plus loin, j’arrête cette tentative. Si le cinquième passe sans échec, c’est un succès, yeah !

#239 Re : Entraide (supérieur) » Dénombrement » 31-08-2024 12:47:00

Bonjour,

Le problème est intéressant, à cause des différentes configurations possibles. En plus ce que j’aime bien avec les forums, c’est qu’on a le temps d’y réfléchir, d’y revenir, de peaufiner tout ça, donc ce genre de petit problème c’est sympa. Bref, sur ce coup j’ai eu envie de programmer une simulation, pour voir...

bridgslam a écrit :

Avec n jetons différents sur un damier nxn  , le résultat (pour moi ) est $2 \times n^{n+1} - n^2$

Eh bien les résultats que j’obtiens sont parfaitement en accord avec cette formule, donc je dis bravo, étant incapable de calculer des probabilités théoriques, admiration sincère.

À noter que si j’arrive à une concordance de plusieurs décimales pour des $n$ petits, à partir de la dizaine c’est mort puisqu’il faut plusieurs milliards de tirages pour voir apparaître des occurrences, d’où le manque de précision de ma méthode.

Comme quoi les formules, il n’y a que ça de vrai !

#240 Re : Café mathématique » Jeux mathématiques » 31-08-2024 12:22:26

Bonjour,

Intéressante, cette vision d'un monde.

Perso je ne vois rien de ludique là-dedans, aucune convivialité, aucun partage, aucun rire. Il s'agit uniquement de concurrents avec ou sans préparation en train de s’affronter dans des épreuves jusqu’en finale d’une compétition. Les mots utilisés sont ceux de l’article, pas une charge de ma part (on notera en passant les T-shirts nationalistes). Si c’est ça l’idée que se font les organisateurs d’une mathématique ludique, euh, comment dire...

#241 Re : Entraide (collège-lycée) » Croissance comparée en spécialité maths » 27-08-2024 07:48:05

Bonjour,

Borassus a écrit :

Ma remarque concernait ton commentaire « # on le multiplie 32 fois par lui-même ».

Ah ok, j’avions pas percuté à quoi cela se rapportait. Je suis bien sûr d’accord avec ce que tu expliques, cela fait partie des innombrables impropriétés du langage courant, un peu comme les augmentations de 200 % pour un facteur 2 ou les « c’est pas droit » pour dire penché.

#242 Re : Entraide (collège-lycée) » Croissance comparée en spécialité maths » 27-08-2024 00:48:02

yoshi a écrit :

J'ignore s'il est adaptable à Maple.

Bonsoir Yoshi,

Sur ce coup j’ai demandé à un assistant AI de me traduire ça en Maple (l'échange complet ici), ça me sort le millier de décimales instantanément et termine par « Temps écoulé (affichage inclus): 0.000 s », donc moins d’un millième, bravo pour ton script.

Ce qui montre combien les outils actuels (Geogébra, Python, Maple, Wolfram, les assistants AI tout ça) sont en train d’intégrer une expertise considérable, c’est absolument fabuleux.

#243 Re : Entraide (collège-lycée) » Croissance comparée en spécialité maths » 26-08-2024 22:05:42

Borassus a écrit :

Toute petite rectification, si je peux me permettre : un nombre multiplié 32 fois par lui-même est égal à ce nombre élevé à la puissance... 33.  :-)
En effet, $v^2 = v \times v$ (le nombre est multiplié une fois par lui-même ; $v^3 = v \times v \times v$ (le nombre est multiplié deux fois par lui-même) ; etc.

En fait ici, comme je fais $v\times v$ plusieurs fois de suite, cela revient à obtenir $v^{2}$, $v^{4}$, $v^{8}$, $v^{16}$, ..., $v^{4294967296}$ c'est pourquoi je choisis comme exposant initial une puissance de 2 (et pas 26).

#244 Re : Entraide (collège-lycée) » Croissance comparée en spécialité maths » 26-08-2024 21:53:20

Hello Borassus, bonsoir tout le monde,

Borassus a écrit :

Pourquoi as-tu choisi $k = 2^{32}$, et non, par exemple $2^{16}$ ou $2^{26}$ ?

En fait je suis parti sur les calculs de Yoshi qui ne trouvait pas cela terrible au regard des résultats qu’il avait avec des méthodes de calcul de racines. Je me suis dit qu’il fallait faire mieux. Avec $2^{16}$ j’arrivais à 20 termes, le développement de ces termes dépassait une ligne, j’ai donc poussé pour obtenir le truc en 10 termes. Comme toujours avec moi, c’est un compromis et c’est arbitraire.

Ah oui, on notera que plus on augmente la puissance de 2, moins on a besoin de termes. On peut même finir avec un seul et unique terme si on adopte un exposant de… 334, vu que dans ce cas on retrouve la formule originelle avec la même valeur au dénominateur et en exposant.


L'idée de considérer le nombre $e$ comme étant $(e^{\frac 1 x})^x$ est une véritable perle !

Content que tu apprécies, j'ai trouvé cela dans ce papier de 2004 où l’auteur regroupe les termes pour converger plus vite et calcule également à partir de l’inverse (voir l'équation (14) et les paragraphes associés en bas de la cinquième page marquée 38). Je ne voulais pas regrouper – sinon c’est autre chose – mais ce qui m’a vraiment plu c’est l’idée de passer par des racines de plus en plus importantes et ensuite de restaurer avec des exposants de plus en plus grands. J’ai donc développé, sans trop optimiser pour que tout reste bien lisible.

#245 Re : Entraide (collège-lycée) » Croissance comparée en spécialité maths » 26-08-2024 21:38:47

Bonsoir Yoshi, bonsoir tout le monde,

Hé hé, c’est un peu grâce à toi et à tes 71 termes que j’ai essayé de faire mieux, faut bien le dire.

yoshi a écrit :

J'ai adapté ton script à Python, il ne fonctionne pas : je reprends demain...

Ok, celui-là devrait marcher, je l'ai essayé dans plusieurs moteurs Python dispo en ligne sans problème.

import decimal

decimal.getcontext().prec = 120

k = 2**32
x = k
v = decimal.Decimal(1)
f = decimal.Decimal(1)

for i in range(1, 11):
    f *= i
    v += 1 / (f * x)
    x *= k

for _ in range(32):
    v = v * v

print(f"{v:.103f}")

(je ne suis pas un spécialiste, j’ai simplement demandé à un assistant AI de me traduire le code Maple en Python)

#246 Re : Entraide (collège-lycée) » Croissance comparée en spécialité maths » 26-08-2024 10:50:52

Borassus a écrit :

J'essaiera tantôt de rendre le développement en série moins hermétique...

Bonjour,

En fait le développement en série ne me dérange pas trop. On peut l’utiliser en calculant par exemple exp(1/x) qu’on élève ensuite à la puissance x, ce qui est équivalent à exp(1). L’avantage du procédé, c’est que le développement de exp(1/x) produit des dénominateurs rapidement gigantesques et permet d’obtenir les cent décimales avec seulement dix termes :

convergence

C’est là qu’on se rend compte de l’efficacité d’algorithmes spécifiques je trouve.

#247 Re : Entraide (collège-lycée) » Croissance comparée en spécialité maths » 24-08-2024 19:05:01

Borassus a écrit :

Pourquoi précisément $202$ pour le nombre de décimales, et pas une autre ?
Pourquoi aussi la puissance $334$, et pas une autre ?

Hello Borassus,

Au départ, je mène les calculs avec une précision interne vraiment grande pour éviter les erreurs d’arrondi, par exemple 500 décimales, et j’essaie différentes puissances à la louche. Je m’approche des cent décimales par essais et erreurs jusqu’à arriver pile poil avec 334.

Une fois cette valeur trouvée, je réduis progressivement le nombre de décimales des calculs internes jusqu’à perdre la précision, ici autour de deux cents. C’est donc par tâtonnement que j’arrive à ces nombres qui paraissent tout droit sortis d’un chapeau.

Bon, sur ce coup être minimaliste n’était pas vraiment utile, faut bien reconnaître, je voulais simplement montrer qu’avec la formule originelle on pouvait obtenir une belle précision en rusant.

À noter qu’en ce qui me concerne, c’est avec les intérêts composés - et donc cette formule - que j’ai le mieux appréhendé ce qu’était $e$, et pas du tout avec la définition usuelle qui me reste complètement hermétique.

En définitive, quelle doit être dans la formule classique la valeur de $n$ pour atteindre 100 décimales justes ?

Aucune idée. Autant Maple est capable de manipuler des nombres avec des milliers de décimales, autant il est incapable de faire lui-même une exponentiation un peu sérieuse, Wolfram non plus d’ailleurs. Faut dire que l'exposant est assez impressionnant puisque qu'il est quand même supérieur à 2^333, c'est-à-dire 17498005798264095394980017816940970922825355447145699491406164851279623993595007385788105416184430592

Je suis toujours aussi admiratif de pouvoir manipuler aujourd'hui de tels nombres, c'est fou. Bonne soirée à tous !

#248 Re : Entraide (collège-lycée) » Croissance comparée en spécialité maths » 23-08-2024 11:13:18

yoshi a écrit :

Je n'ose même pas envisager 100 décimales

Bonjour,

On peut obtenir sans problème une centaine de décimales avec la formule classique. On commence par choisir pour n une belle puissance de 2, grâce à celle-ci on calcule ensuite la valeur 1+1/n, et il suffit alors de multiplier cette valeur par elle-même le même nombre de fois que cette puissance. C'est facile, c'est rapide, c'est efficace, exemple avec Maple et quelques centaines de boucles seulement :

décimales de e

Ce genre de calcul est quasi instantané. Maple par exemple calcule en moins d’un dixième de seconde mille décimales avec le programme modifié et une puissance de 2 de plusieurs milliers. Appréhender de « grands » nombres aujourd’hui n’a plus grand chose à voir avec le coup de l’échiquier et des grains de riz, faut bien le dire…

Sur le fond, je pense qu’il n’est nul besoin de savoir calculer une constante, il suffit que quelqu’un l’ait fait une fois pour toute et hop ça marche, et cela aussi bien pour e que pour Pi ou pour la vitesse de la lumière, bien pratique.

#249 Re : Café mathématique » Quel est la formule mathématique pour un calcul simple » 18-06-2024 13:09:37

En résumé, ce sont là des programmes bourrins qui n’ont aucune compréhension de quoi que ce soit. Ils appliquent des mécanismes automatiques à partir de méthodes figées, rien d’autre. Il ne viendrait à l’esprit de personne de parler d’ouvrier intelligent en parlant d’une tractopelle ? Eh bien là c’est la même chose, évoquer une intelligence artificielle est simplement grotesque.

#250 Re : Café mathématique » Quel est la formule mathématique pour un calcul simple » 18-06-2024 13:08:30

Et enfin avec Perplexity

Pour faire 16 cigarettes à partir de mégots, en sachant qu'il faut 4 mégots pour 1 cigarette et qu'il restera toujours 1 mégot à la fin, le calcul est le suivant:
Pour 1 cigarette, il faut 4 mégots
Donc pour 16 cigarettes, il faut 16 x 4 = 64 mégots
Cependant, comme il restera toujours 1 mégot à la fin, il faut en ajouter 1 de plus.
Donc pour faire 16 cigarettes en récupérant les mégots, avec 1 mégot restant à la fin, il vous faudra 64 + 1 = 65 mégots

Pied de page des forums