math/rand

Package rand

import "math/rand"

Variables synoptiques	Type
n	int
n32	int32
n64, g	int64
imax	uint64
s, v	float64
src	Source
r	*Rand
z	*Zipf

Type	Description
Source	Source d'entiers int64 uniforme dans [0, 1<<63[
Rand	Générateur de nombres aléatoires dépendant d'une Source
Zipf	Générateur de nombres aléatoires dépendant d'un Rand et d'une loi de Zipf

Fonction	Description	Type du résultat
ExpFloat64()	→ Nombre dans ]0, math.MaxFloat64] aléatoire de loi exponentielle (l=1)	float64
Float64()	→ Nombre dans [0, 1[ aléatoire	float64
Float32()	→ Nombre dans [0, 1[ aléatoire	float32
Int()	→ Entier non négatif aléatoire	int
Intn(n)	→ Entier dans [0..n[ aléatoire	int
Int31()	→ Entier non négatif de 31bits aléatoire	int32
Int31n(n32)	→ Entier dans [0..n32[ aléatoire	int32
Uint32	→ Entier non négatif aléatoire	uint32
Int63()	→ Entier non négatif de 63bits aléatoire	int64
Int63n(n64)	→ Entier dans [0..n64[ aléatoire	int64
NormFloat64()	→ Nombre dans [-math.MaxFloat64, +math.MaxFloat64] aléatoire de loi normale (m=0, s=1)	int64
Perm(n)	→ Permutation des entiers [0..n[ aléatoire	[]int
Seed(g)	Fixe la gaine à g de la source de nombres aléatoires
NewSource(g)	→ Nouvelle source de graine g	Source
New(src)	→ Le rand dépendant de la source src	*Rand
NewZipf(r,s,v,imax)	→ Nouveau Zipf dépendant du rand r, générant des entiers x x dans [0..imax] tel que P(x) proportionel à 1/(v+x)^s	*Zipf
Méthode du type Rand
r.Seed(g)	Fixe la gaine à g de la source de nombres aléatoires dont dépend r
r.ExpFloat64()	→ Nombre dans ]0, math.MaxFloat64] aléatoire produit par r de loi exponentielle (lambda=1)	float64
r.Float64()	→ Nombre dans [0, 1[ aléatoire produit par r	float64
r.Float32()	→ Nombre dans [0, 1[ aléatoire produit par r	float32
r.Int()	→ Entier non négatif aléatoire produit par r	int
r.Intn(n)	→ Entier dans [0..n[ aléatoire produit par r	int
r.Int31()	→ Entier non négatif de 31bits aléatoire produit par r	int32
r.Int31n(n32)	→ Entier dans [0..n32[ aléatoire produit par r	int32
r.Uint32	→ Entier non négatif aléatoire produit par r	uint32
r.Int63()	→ Entier non négatif de 63bits aléatoire produit par r	int64
r.Int63n(n64)	→ Entier dans [0..n64[ aléatoire produit par r	int64
r.NormFloat64()	→ Nombre dans [-math.MaxFloat64, +math.MaxFloat64] aléatoire produit par r de loi normale (m=0, s=1)	int64
r.Perm(n)	→ Permutation des entiers [0..n[ aléatoire produit par r	[]int
Méthode du type Zipf
z.Uint64()	→ Entier aléatoires d'une loi de Zipf, produit par le Zipf z	uint64

Package sort

import "sort"

Variables synoptiques	Type
n,i,j,k	int
n32	int32
n64, g	int64
imax	uint64
v,w	float64
s	string
src	Source
r	*Rand
z	*Zipf
f	func(int)bool
g	func(int,int)bool
L	[]int
V,W	[]float64
S	[]string
M	[]struct{...}
A	Interface

Type	Description
Float64Slice	[]float64 trié dans l'ordre Les valeurs non numériques sont les plus basses.
IntSlice	[]int trié dans l'ordre
StringSlice	[]string trié dans l'ordre
Interface	type satisfaisant sort.interface c.a.d avec les méthodes A.Len(), A.Less(i,j), A.Swap(i,j)

Fonction	Description	Type du résultat
Float64s(V)	Trie V dans l'ordre croissant Les valeurs non numériques sont les plus basses.
Float64sAreSorted(V)	→ true si V est trié, false sinon	bool
Ints(L)	Trie L dans l'ordre croissant
IntsAreSorted(L)	→ true si L est trié, false sinon	bool
Strings(S)	Trie S dans l'ordre croissant
StringsAreSorted(S)	→ true si S est trié, false sinon	bool
Sort(A)	Trie A à l'aide des méthodes A.Len, A.less, A.swap
Stable(A)	Trie A à l'aide des méthodes A.Len, A.less, A.swap en conservant l'odre d'origine des éléments égaux.
IsSorted(L)	→ true si A est trié (utilise la méthode A.less), false sinon	bool
Search(n, f)	→ Le plus petit entier i ∈{0..n-1} tel que f(i), obtenu par recherche dichotomique sachant que f(i) => f(i+1), ou → n si pas trouvé.	int
SearchFloat64s(V, v)	→ L'indice i tel que V[i] = v, ou l'indice i où doit être insérée cette nouvelle valeur, obtenu par recherche dichotomique sachant que V est trié par ordre croissant, ou → len(V) si pas trouvé.	int
SearchInts(L, k)	→ L'indice i tel que L[i] = k, ou l'indice i où doit être insérée cette nouvelle valeur, obtenu par recherche dichotomique sachant que L est trié par ordre croissant.	int
SearchStrings(S,s)	→ L'indice i tel que S[i] = s, ou l'indice i où doit être insérée cette nouvelle valeur, obtenu par recherche dichotomique sachant que L est trié par ordre croissant.	int
Slice(M,g)	Trie M à l'aide de la fonction de comparaison g tel que g(i,j) <=> M[i]<M[j]
SliceStable(M,g)	Trie M à l'aide de la fonction de comparaison g tel que g(i,j) <=> M[i]<M[j] en conservant l'odre d'origine des éléments égaux .
Reverse(A)		interface

Méthode du type Float64Slice
V.Len()		int
V.Less(i,j)		bool
V.Swap(i,j)
V.Search(v)	SearchFloat64s(V, v)	int
V.Sort()	Float64s(V)
Méthode du type IntSlice
L.Len()		int
L.Less(i,j)		bool
L.Swap(i,j)
L.Search(k)	SearchInts(L, k)	int
L.Sort()	Ints(V)
Méthode du type interface
A.Len()		int
A.Less(i,j)		bool
A.Swap(i,j)
Méthode du type StringSlice
L.Len()		int
L.Less(i,j)		bool
L.Swap(i,j)
L.Search(k)	SearchInts(L, k)	int
L.Sort()	Ints(V)