Collection subclass: #VLGCollection
	instanceVariableNames: 'valeur suivant precedent '
	classVariableNames: ''
	poolDictionaries: ''
	category: 'VL-G-Nombres'!


!VLGCollection methodsFor: 'accessing'!

dernier
	^ suivant isNil ifTrue: [ self ]
	ifFalse: [ suivant dernier ]!

precedent
	^precedent!

precedent: unElement
	precedent := unElement!

premier
	^ precedent isNil ifTrue: [ self ]
	ifFalse: [ precedent premier ]!

suivant
	^suivant!

suivant: unElement
	suivant := unElement!

valeur
	^valeur!

valeur: uneValeur
	valeur := uneValeur! !

!VLGCollection methodsFor: 'enumeration'!

do: unBloc
	unBloc value: valeur.
	suivant notNil ifTrue: 
	[ suivant do: unBloc ]! !

!VLGCollection methodsFor: 'private'!

species
	^Array! !

!VLGCollection methodsFor: 'adding'!

add: uneValeur
	^self addLast: uneValeur!

addElementFirst: unElement
	| premier |
	(premier := self premier) precedent: (unElement suivant: premier).
	^ unElement valeur!

addElementLast: unElement
	| dernier |
	(dernier := self dernier) suivant: (unElement precedent: dernier).
	^ unElement valeur!

addFirst: uneValeur
	^ self addElementFirst: (self class with: uneValeur)!

addLast: uneValeur
	^ self addElementLast: (self class with: uneValeur)! !
"-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- "!

VLGCollection class
	instanceVariableNames: ''!


!VLGCollection class methodsFor: 'exemples'!

exemple01
	self with: 1!

exemple02
	(self with: 1) add: 2; yourself!

exemple03
	(self with: 1) addFirst: 2; premier! !

!VLGCollection class methodsFor: 'instance creation'!

with: valeur
	^self new valeur: valeur! !

View subclass: #VLGNombreView
	instanceVariableNames: ''
	classVariableNames: ''
	poolDictionaries: ''
	category: 'VL-G-Nombres'!


!VLGNombreView methodsFor: 'displaying'!

collectPoints: facteur bounds: cadre startAngle: startAngle points: points
	
	| centre angle point taille |
	centre := cadre center.
	
	0 to: facteur valeur - 1 do: [:index  |
		angle := ((360 / facteur valeur * index) + startAngle) .
		point := Point r: ((cadre width min: cadre height) * 1 / 4)
			theta: angle degreesToRadians.
		facteur suivant isNil ifTrue: 
		[ points add: centre + point ]
		ifFalse: 
		[ 	taille := (cadre width min: cadre height) / (facteur valeur).
			self collectPoints: facteur suivant bounds: (centre + point - (taille / 2)
				extent: taille) startAngle:  angle points: points ]
		]!

display: facteur on: gc bounds: cadre startAngle: startAngle

	| centre angle point taille |
	centre := cadre center.
	
	"gc displayRectangularBorder: cadre."

	0 to: facteur valeur - 1 do: [:index  |
		angle := ((360 / facteur valeur * index) + startAngle) .
		point := Point r: (cadre width min: cadre height) / 4 
			theta: angle degreesToRadians.
		facteur suivant isNil ifTrue: 
		[ gc displayDotOfDiameter: 5 at: centre + point ]
		ifFalse: 
		[ 	taille := (cadre width min: cadre height) / 3.
			self display: facteur suivant on: gc bounds: (centre + point - (taille / 2)
				extent: taille) startAngle:  angle ]
		]!

displayOn: gc
	| points taille |
	model isNil ifTrue: [ ^self ].
	"self display: model facteurs on: gc bounds: self bounds startAngle: 0"
	
	points := OrderedCollection new.
	self collectPoints: model facteurs bounds: self bounds startAngle: 0 points: points.

	taille := (self bounds width max: self bounds height) / 2.
	(taille to: 1 by: -4) do: [:rayon |
		points do: [:unPoint | 
			gc paint: (ColorValue brightness: 1 - ((taille - rayon) / taille)).
			gc displayDotOfDiameter: rayon at: unPoint ] ].
	gc paint: ColorValue white.
	points do: [:unPoint | gc displayDotOfDiameter: 4 at: unPoint ].! !
"-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- "!

VLGNombreView class
	instanceVariableNames: ''!


!VLGNombreView class methodsFor: 'exemples'!

exemple08

	(ScheduledWindow new)
		component: (self new model: (VLGNombre new valeur: 2) inspect);
		open! !

VLGCollection subclass: #VLGFacteur
	instanceVariableNames: ''
	classVariableNames: ''
	poolDictionaries: ''
	category: 'VL-G-Nombres'!


Object subclass: #VLGNombre
	instanceVariableNames: 'valeur facteurs '
	classVariableNames: 'Filtre '
	poolDictionaries: ''
	category: 'VL-G-Nombres'!


!VLGNombre methodsFor: 'accessing'!

facteurs
	^facteurs!

valeur: uneValeur
	valeur := uneValeur.
	facteurs := Filtre factoriser: uneValeur! !

!VLGNombre methodsFor: 'printing'!

printOn: aStream
	valeur printOn: aStream.
	aStream nextPutAll: ' --- '.
	facteurs printOn: aStream.
	aStream cr! !
"-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- "!

VLGNombre class
	instanceVariableNames: ''!


!VLGNombre class methodsFor: 'class initialisation'!

initialize
	"self initialize"
	Filtre := VLGFiltre with: 2! !

!VLGNombre class methodsFor: 'exemples'!

exemple06
	^ (2 to: 100) collect: [:n | self new valeur: n ]! !

VLGCollection subclass: #VLGFiltre
	instanceVariableNames: ''
	classVariableNames: ''
	poolDictionaries: ''
	category: 'VL-G-Nombres'!


!VLGFiltre methodsFor: 'accessing'!

factoriser: nombre
	nombre == valeur
	ifTrue: [  ^ VLGFacteur with: valeur ].

	nombre \\ valeur == 0
	ifTrue: [  ^ (VLGFacteur with: valeur)
		addElementFirst: (self factoriser: nombre // valeur) dernier;
		premier ].

	suivant isNil ifTrue: [ | p | p := self premier.
		valeur to: nombre do: [:n | p filtrer: n ]].
	
	^ suivant factoriser: nombre!

filtrer: nombre
	nombre \\ valeur == 0
	ifFalse: [ 
		suivant isNil ifTrue: [ self add: nombre ]
		ifFalse: [ suivant filtrer: nombre ] ]! !
"-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- "!

VLGFiltre class
	instanceVariableNames: ''!


!VLGFiltre class methodsFor: 'instance creation'!

jusqua: n
	| f |
	f := self with: 2.
	3 to: n do: [:nombre |
		f filtrer: nombre ].
	^ f! !

!VLGFiltre class methodsFor: 'exemples'!

exemple04
	^self jusqua: 1000!

exemple05
	^(self jusqua:  2) factoriser: 100! !
VLGNombre initialize!