PureBasic

Intéressant et surprenant! (notamment la 3ème méthode).

Moi, j'en ai une quatrième un peu "folklorique".
ça consiste à tirer au pif dans un carré de côté 2.
Il y a une zone circulaire inscrite dans ce carré (cercle de rayon 1).
Pour savoir si le tir est dans la zone, on fait une vérif de distance par rapport au centre du carré (qui est aussi le centre du cercle).
On comptabilise le nombre de tirs dans le cercle et le nombre de tirs hors de ce cercle.
Le ration Dedans/(Dedans + Dehors) est censé se rapprocher de Pi * R² (surface d'un cercle en fonction du rayon) donc de 4*Pi.

Code : Tout sélectionner

R.F = 1000000000
In.F
Out.F
Pi.F

Repeat

   Tip.I + 1
   Tip & 255
   If Tip = 0: Delay(1): EndIf
   X.F = Random(R * 2.0 - 1.0) - R
   Y.F = Random(R * 2.0 - 1.0) - R
   If Sqr((X * X) + (Y * Y) ) <= R
      In + 1.0
   Else
      Out + 1.0
   EndIf
   Pi.F = (In / (In + Out) )
   Debug Pi * 4.0
   
ForEver

Ah c'est sympa de l'avoir ressortie celle-là! D'ailleurs on peut tirer n'importe quel nombre de cette manière, en adaptant les formes

Là il faut comprendre le rapport au cercle et au carré, et se rappeler d'où vient Pi ; bon je frime, je connaissais cette astuce d'un vieux bouquin (ST-Mag je crois)

curieux en effet

toutefois chez moi ça rend plus un 3.15 ,3.16

mais c'est deja tres étonnant

.......................

Bonjour à tous,

J'ajoute un type, les nombres complexes avec une librairie de fonction (Mélange de macros et de procédures)
Pour ceux ont besoin de faire des calculs de courant alternatif ainsi que des calculs de conception vibratoire.

Petite mise à jour :
- ProductByScalar --> Ajouté
- DivideByScalar --> Ajouté

Code : Tout sélectionner

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; Nom du projet : Lib Nombre Complex
; Nom du Fichier : Lib_Complex_Number.pb
; Version du Fichier : 1.0.1
; Programmation : OK
; Programmé par : Guimauve
; Date : 10-10-2009
; Mise à jour : 11-10-2009
; Codé avec PureBasic V4.40 BETA 4
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Déclaration de la Structure <<<<<

Structure Complex
  
  X.d
  Y.d
  
EndStructure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Les observateurs <<<<<

Macro GetComplexX(ComplexA)
  
  ComplexA\X
  
EndMacro

Macro GetComplexY(ComplexA)
  
  ComplexA\Y
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Les mutateurs <<<<<

Macro SetComplexX(ComplexA, P_X)
  
  GetComplexX(ComplexA) = P_X
  
EndMacro

Macro SetComplexY(ComplexA, P_Y)
  
  GetComplexY(ComplexA) = P_Y
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Update <<<<<

Macro UpdateComplex(ComplexA, P_X, P_Y)
  
  SetComplexX(ComplexA, P_X)
  SetComplexY(ComplexA, P_Y)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Reset <<<<<

Macro ResetComplex(ComplexA)
  
  SetComplexX(ComplexA, 0)
  SetComplexY(ComplexA, 0)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Copy : A = Source : B = Destination <<<<<

Macro CopyComplex(ComplexA, ComplexB)
  
  SetComplexX(ComplexB, GetComplexX(ComplexA))
  SetComplexY(ComplexB, GetComplexY(ComplexA))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Compare <<<<<

Macro CompareComplex(ComplexA, ComplexB)
  
  CompareMemory(ComplexA, ComplexB, SizeOf(Complex))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Swap <<<<<

Macro SwapComplex(ComplexA, ComplexB)
  
  Swap GetComplexX(ComplexA), GetComplexX(ComplexB)
  Swap GetComplexY(ComplexA), GetComplexY(ComplexB)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Plus : R = A + B <<<<<

Macro PlusComplex(ComplexR, ComplexA, ComplexB)
  
  SetComplexX(ComplexR, GetComplexX(ComplexA) + GetComplexX(ComplexB))
  SetComplexY(ComplexR, GetComplexY(ComplexA) + GetComplexY(ComplexB))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Minus : R = A - B <<<<<

Macro MinusComplex(ComplexR, ComplexA, ComplexB)
  
  SetComplexX(ComplexR, GetComplexX(ComplexA) - GetComplexX(ComplexB))
  SetComplexY(ComplexR, GetComplexY(ComplexA) - GetComplexY(ComplexB))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur ProductByScalar : R = A * Scalar <<<<<

Macro ProductByScalarComplex(ComplexR, ComplexA, Scalar)
  
  SetComplexX(ComplexR, GetComplexX(ComplexA) * Scalar)
  SetComplexY(ComplexR, GetComplexY(ComplexA) * Scalar)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur DivideByScalar : R = A / Scalar <<<<<

Macro DivideByScalarComplex(ComplexR, ComplexA, Scalar)
  
  SetComplexX(ComplexR, GetComplexX(ComplexA) / Scalar)
  SetComplexY(ComplexR, GetComplexY(ComplexA) / Scalar)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Zero <<<<<

Macro ZeroComplex(ComplexA)
  
  SetComplexX(ComplexA, 0)
  SetComplexY(ComplexA, 0)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Macro de déboguage <<<<<

Macro DebugComplex(ComplexA)
  
  Debug GetComplexX(ComplexA)
  Debug GetComplexY(ComplexA)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Macro de Formatage <<<<<

Macro FormatComplex(ComplexA, Decimal = 3)
  
  StrD(GetComplexX(ComplexA), Decimal) + " + " + StrD(GetComplexY(ComplexA), Decimal) + "i"
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Product : R = A * B <<<<<

Macro ProductComplex(ComplexR, ComplexA, ComplexB)
  
  SetComplexX(ComplexR, GetComplexX(ComplexA) * GetComplexX(ComplexB) - GetComplexY(ComplexA) * GetComplexY(ComplexB))
  SetComplexY(ComplexR, GetComplexX(ComplexA) * GetComplexY(ComplexB) + GetComplexY(ComplexA) * GetComplexX(ComplexB))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Square <<<<<

Macro SquareComplex(ComplexR, ComplexA)
  
  SetComplexX(ComplexR, GetComplexX(ComplexA) * GetComplexX(ComplexA) - GetComplexY(ComplexA) * GetComplexY(ComplexA))
  SetComplexY(ComplexR, GetComplexX(ComplexA) * GetComplexY(ComplexA) * 2.0)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur SumSquare <<<<<

Macro SumSquareComplex(ComplexA)
  
  (GetComplexX(ComplexA) * GetComplexX(ComplexA) + GetComplexY(ComplexA) * GetComplexY(ComplexA))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Magnitude <<<<<

Macro MagnitudeComplex(ComplexA)
  
  Sqr(SumSquareComplex(ComplexA))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Sinus <<<<<

Macro SinusComplex(ComplexR, ComplexA)
  
  SetComplexX(ComplexR, Sin(GetComplexX(ComplexA)) * CosH(GetComplexY(ComplexA)))
  SetComplexY(ComplexR, Cos(GetComplexX(ComplexA)) * SinH(GetComplexY(ComplexA)))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Cosinus <<<<<

Macro CosinusComplex(ComplexR, ComplexA)
  
  SetComplexX(ComplexR, Cos(GetComplexX(ComplexA)) * CosH(GetComplexY(ComplexA)))
  SetComplexY(ComplexR, -Sin(GetComplexX(ComplexA)) * SinH(GetComplexY(ComplexA)))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Sinus Hyperbolique <<<<<

Macro SinusHyperbolicComplex(ComplexR, ComplexA)
  
  SetComplexX(ComplexR, SinH(GetComplexX(ComplexA)) * Cos(GetComplexY(ComplexA)))
  SetComplexY(ComplexR, CosH(GetComplexX(ComplexA)) * Sin(GetComplexY(ComplexA)))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Cosinus Hyperbolique <<<<<

Macro CosinusHyperbolicComplex(ComplexR, ComplexA)
  
  SetComplexX(ComplexR, CosH(GetComplexX(ComplexA)) * Cos(GetComplexY(ComplexA)))
  SetComplexY(ComplexR, SinH(GetComplexX(ComplexA)) * Sin(GetComplexY(ComplexA)))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Ln <<<<<

Macro LnComplex(ComplexR, ComplexA)
  
  SetComplexX(ComplexR, Log((GetComplexX(ComplexA) * GetComplexX(ComplexA)) + (GetComplexY(ComplexA) * GetComplexY(ComplexA))) / 2.0)
  SetComplexY(ComplexR, (2 * ATan(GetComplexY(ComplexA) / (Sqr(GetComplexX(ComplexA) * GetComplexX(ComplexA) + GetComplexY(ComplexA) * GetComplexY(ComplexA))+GetComplexX(ComplexA)))))
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Divide : R = A / B <<<<<

Procedure DivideComplex(*ComplexR.Complex, *ComplexA.Complex, *ComplexB.Complex)
  
  ComplexModulus.d = GetComplexX(*ComplexB) * GetComplexX(*ComplexB) + GetComplexY(*ComplexB) * GetComplexY(*ComplexB)
  
  SetComplexX(*ComplexR, (GetComplexX(*ComplexA) * GetComplexX(*ComplexB) + GetComplexY(*ComplexA) * GetComplexY(*ComplexB)) / ComplexModulus)
  SetComplexY(*ComplexR, (GetComplexX(*ComplexA) * GetComplexY(*ComplexB) - GetComplexY(*ComplexA) * GetComplexX(*ComplexB)) / ComplexModulus)
  
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Tangeante <<<<<

Procedure TangentComplex(*ComplexR.Complex, *ComplexA.Complex)
  
  SinusComplex(ComplexSin.Complex, *ComplexA)
  CosinusComplex(ComplexCos.Complex, *ComplexA)
  DivideComplex(*ComplexR.Complex, ComplexSin, ComplexCos)
  
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Tangeante Hyperbolique <<<<<

Procedure TangentHyperbolicComplex(*ComplexR.Complex, *ComplexA.Complex)
  
  SinusHyperbolicComplex(ComplexSinH.Complex, *ComplexA)
  CosinusHyperbolicComplex(ComplexCosH.Complex, *ComplexA)
  DivideComplex(*ComplexR.Complex, ComplexSinH, ComplexCosH)
  
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Exponential <<<<<

Procedure ExponentialComplex(*ComplexR.Complex, *ComplexA.Complex)
  
  ComplexEx.d = Pow(2.71828182846, GetComplexX(*ComplexA))
  
  SetComplexX(*ComplexR, ComplexEx * Cos(GetComplexY(*ComplexA)))
  SetComplexY(*ComplexR, ComplexEx * Sin(GetComplexY(*ComplexA)))
  
EndProcedure

;/ <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
;/ <<<<< ATTENTION - CODE D'ESSAI - ATTENTION <<<<<
;/ <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Nombre complexe originaux"

UpdateComplex(ComplexA.Complex, 5, 3)
UpdateComplex(ComplexB.Complex, 3, 5)

Debug FormatComplex(ComplexA)
Debug FormatComplex(ComplexB)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test d'addition de nombre complexe"

PlusComplex(PlusComplexR.Complex, ComplexA, ComplexB)
Debug FormatComplex(PlusComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de soustraction de nombre complexe"

MinusComplex(MinusComplexR.Complex, ComplexA, ComplexB)
Debug FormatComplex(MinusComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de Produit par un scalaire de nombre complexe"

ProductByScalarComplex(ProdByScalarComplexR.Complex, ComplexA, 5)
Debug FormatComplex(ProdByScalarComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de Division par un scalaire de nombre complexe"

DivideByScalarComplex(DividByScalarComplexR.Complex, ComplexA, 5)
Debug FormatComplex(DividByScalarComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de multiplication de nombre complexe"

ProductComplex(ProdComplexR.Complex, ComplexA, ComplexB)
Debug FormatComplex(ProdComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de division de nombre complexe"

DivideComplex(DividComplexR.Complex, ComplexA, ComplexB)
Debug FormatComplex(DividComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de Square de nombre complexe --> A²"

SquareComplex(SqrComplexR.Complex, ComplexA)
Debug FormatComplex(SqrComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de e^(A) de nombre complexe"

ExponentialComplex(ExpComplexR.Complex, ComplexA)
Debug FormatComplex(ExpComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de Sin(A) de nombre complexe"

SinusComplex(SinComplexR.Complex, ComplexA)
Debug FormatComplex(SinComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de Cos(A) de nombre complexe"

CosinusComplex(CosComplexR.Complex, ComplexA)
Debug FormatComplex(CosComplexR)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de Tan(A) de nombre complexe"

TangentComplex(TanComplexR.Complex, ComplexA)
Debug FormatComplex(TanComplexR, 6)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de SinH(A) de nombre complexe"

SinusHyperbolicComplex(SinHComplexR.Complex, ComplexA)
Debug FormatComplex(SinHComplexR, 4)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de CosH(A) de nombre complexe"

CosinusHyperbolicComplex(CosHComplexR.Complex, ComplexA)
Debug FormatComplex(CosHComplexR, 4)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de TanH(A) de nombre complexe"

TangentHyperbolicComplex(TanHComplexR.Complex, ComplexA)
Debug FormatComplex(TanHComplexR, 6)

Debug ""
Debug "; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
Debug "; Test de Ln de nombre complexe"

LnComplex(LnComplexR.Complex, ComplexA)
Debug FormatComplex(LnComplexR, 5)

; <<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< FIN DU FICHIER <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<

Il est possible que vous ayez besoin également de ces 2 macros en plus. (Si vous ne les avez pas encore compilé quelque part)

Code : Tout sélectionner

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Sinus Hyperbolique <<<<<

Macro SinH(Angle)
  
   ((Pow(2.71828182846, Angle) - Pow(2.71828182846, -Angle)) / 2)
  
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Cosinus Hyperbolique <<<<<

Macro CosH(Angle)
  
   ((Pow(2.71828182846, Angle) + Pow(2.71828182846, -Angle)) / 2)
  
EndMacro

A+
Guimauve

Un peu de nostalgie de la 1ère.

Dobro a écrit :petit code traduit du PowerBasic
pour afficher les phases lunaires , d'un mois, de n'importe qu'elle année

Excellent !

bombseb a écrit :un autre truc tout con :

Chiffre négatif = ennemis
chiffre positif = amis

les amis de mes amis sont mes amis : un chiffre positif * un chiffre positif = un chiffre positif

marche avec toutes les combinaisons...

c'est intéressant!!

__________________________________________________________________________________________________________coque lg google nexus 5 coque nokia lumia 520 coque nokia X

Bien Utile comme rubrique

PureBasic

Astuces et codes utiles sur les Mathématiques

Re: Astuces et codes utiles sur les Mathématiques

Re: Astuces et codes utiles sur les Mathématiques

Re:

Re:

Re: Astuces et codes utiles sur les Mathématiques