PureBasic

C'est encore moi ^^
Je viens à l'instant de faire un petit programme où j'ai dû déclarer 2 tableaux de 120 éléments, j'ai donc du me taper à la main une séquence de touche pour initialiser chaque élément.
Ca donne :

Code : Tout sélectionner

	note(0)		= "C 0"  : note(1)	= "C#0" : note(2)  = "D 0" : note(3) 	 = "D#0" : note(4) 	= "E 0" 
	note(5) 	 	= "F 0"  : note(6)	= "F#0" : note(7)  = "G 0" : note(8) 	 = "G#0" : note(9) 	= "A 0" 
	note(10) 	= "A#0" : note(11)	= "B 0" : note(12) = "C 1" : note(13) = "C#1" : note(14)	= "D 1"
	note(15)	= "D#1" : note(16)	= "E 1" : note(17) = "F 1" : note(18)	 ="F#1" : note(19) = "G 1"
	note(20)    = "G#1" : note(21)  = "A 1" : note(22) = "A#1" : note(23) = "B 1" : note(24) = "C 2"
	note(25)    = "C#2" : note(26)	= "D 2" : note(27) = "D#2" : note(28) = "E 2" : note(29) = "F 2"
	note(30)    = "F#2" : note(31)   = "G 2": note(32) = "G#2" : note(33) = "A 2" : note(34) = "A#2"
	note(35)	= "B 2"	: note(36)	= "C 3" : note(37) = "C#3" : note(38) = "D 3" : note(39) = "D#3"
	note(40)	= "E 3" : note(41)	= "F 3" : note(42) = "F#3" : note(43) = "G 3" : note(44) = "G#3"
	note(45)	= "A 3" : note(46)   = "A#3" : note(47) = "B 3" : note(48) = "C 4" : note(49) = "C#4"
	note(50) = "D 4" : note(51) = "D#4" : note(52) = "E 4" : note(53) = "F 4" : note(54) = "F#4"
	note(55) = "G 4" : note(56) = "G#4" : note(57) = "A 4" : note(58) = "A#4" : note(59) = "B 4"
    note(60) = "C 5" : note(61) = "C#5" : note(62) = "D 5" : note(63) = "D#5" : note(64) = "E 5"
    note(65) = "F 5" : note(66) = "F#5" : note(67) = "G 5" : note(68) = "G#5" : note(69) = "A 5"
    note(70) = "A#5" : note(71) = "B 5" : note(72) = "C 6" : note(73) = "C#6" : note(74) = "D 6"
    note(75) = "D#6" : note(76) = "E 6" : note(77) = "F 6" : note(78) = "F#6" : note(79) = "G 6"
    note(80) = "G#6" : note(81) = "A 6" : note(82) = "A#6" : note(83) = "B 6" : note(84) = "C 7"
    note(85) = "C#7" : note(86) = "D 7" : note(87) = "D#7" : note(88) = "E 7" : note(89) = "F 7"
    note(90) = "F#7" : note(91) = "G 7" : note(92) = "G#7" : note(93) ="A 7" : note(94) = "A#7"
    note(95) = "B 7" : note(96) = "C 8" : note(97) = "C#8" : note(98) = "D 8" : note(99) = "D#8"
    note(100) = "E 8" : note(101) = "F 8" : note(102) = "F#8" : note(103) = "G 8" : note(104) = "G#8" 
    note(105) = "A 8" : note(106) = "A#8" : note(107) = "B 8" : note(108) = "C 9" : note(109) = "C#9"
    note(110) = "D 9" : note(111) = "D#9" : note(112) = "E 9" : note(113) = "F 9" : note(114) = "F#9"
    note(115) = "G 9" : note(116) = "G#9" : note(117) = "A 9" : note(118) = "A#9" : note(119) = "B 9"

Ne serait t-il pas plus souple d'avoir un nouveau type Array que l'on pourra initialiser un peu comme en VB :

Code : Tout sélectionner

Array.s(120)

note = ("C 0", "C#0", "D 0", "D#0" .... )
; ou
note("C 0", "C#0", "D 0", "D#0" .... )

debug note(1) ; "C#0"

Ce qui me parait plus souple d'utilisation en terme de saisie.
Qu'en pensez vous ?

C'est du midi ?

pour répondre à ta demande, as-tu essayé ave une datasection ? associée à un "pointeur tableau" tu n'auras même pas besoin des instructions "Read" pour remplir un tableau "dim"
Si tu veux je te fais un exemple, j'ai fait ce genre de choses pour mon programme de codes barres

[edit]
en plus dans ton cas on peut générer ca avec une boucle si jme gourre pas

Dri

voila un code, j'ai vérifié que les 40 premières lignes et ca a l'air conforme

Code : Tout sélectionner

Dim note.s(119)

num = 0
lettre = 'C'

While num < 120
  note(num) = Chr(lettre) + " " + Str(num / 12)
  num + 1
  If lettre <> 'B' And lettre <> 'E'
    note(num) = Chr(lettre) + "#" + Str(num / 12)
    num + 1
  EndIf
  lettre + 1
  If lettre = 'H'
    lettre = 'A'
  EndIf
Wend

For i = 0 To 119
  Debug note(i)
Next i

Dri

Salut !
Non, le midi et moi, on est pas copain, je suis en train de faire le "port" de FMOD Ex pour purebasic ainsi que les exemples, la c'est pour le pitchshifting : ça affiche le pitch de notre voix au micro ainsi que sa note musical,ici il est calculé via les FFT (algo ici )

Les datasections, c'est pareil, c'est pas forcément plus simple à saisir, il faudra la aussi saisir à chaque ligne "data.s "C 0", "C#0""
"data.s "D 0", "D#0""
Etc ...

C'est plus pour faciliter la saisie dans le cadre d'actions répétées.

ca m'intéresse ton truc !! j'y connais rien en FFT
je connais juste le format wave et les oscilloscopes lol

ta suggestion n'a pas l'air très lisible non plus..., tu imagines une ligne comme ca avec 120 chaines ?
dans une datasection tu peux très bien disposer ca en 9 lignes et comme toutes les chaînes font 3 caracteres (dans ton cas) ca fait quelque chose de plutôt lisible

Dri

PS. y marche mon algo ? v m'en servir pour générer une datasection ^^

Le FFT est celui de FMOD Ex mais il m'en faudra un tôt ou tart en PB, je te ferais signe lorsque ce sera fait

Pour ta suggestion concernant les datasection, en effet, c'est déja mieux et surtout plus lisible, bon la vu que j'ai tout saisis je laisse comme ça mais pour la prochaine fois, je tâcherais d'y penser

Merci en tout cas

PS : ton code marche nickel, je vais voire si ca va réduire la taille de l'éxécutable.

voila le code

Code : Tout sélectionner

Dim note.s(119)

num = 0
lettre = 'C'

While num < 120
  note(num) = Chr(lettre) + " " + Str(num / 12)
  num + 1
  If lettre <> 'B' And lettre <> 'E'
    note(num) = Chr(lettre) + "#" + Str(num / 12)
    num + 1
  EndIf
  lettre + 1
  If lettre = 'H'
    lettre = 'A'
  EndIf
Wend

Debug "datasection"
chaine.s = "  notes:"
For i = 0 To 119
  If i % 12 = 0
    Debug chaine
    chaine = "  Data.s "
  EndIf
  chaine + Chr('"') + note(i) + Chr('"')
  If i % 12 < 11
    chaine + ", "
  EndIf
Next i
Debug "enddatasection"

et apres un copier/coller du debugger dans l'IDE j'obtiens ce très beau

Code : Tout sélectionner

DataSection
  notes:
  Data.s "C 0", "C#0", "D 0", "D#0", "E 0", "F 0", "F#0", "G 0", "G#0", "A 0", "A#0", "B 0"
  Data.s "C 1", "C#1", "D 1", "D#1", "E 1", "F 1", "F#1", "G 1", "G#1", "A 1", "A#1", "B 1"
  Data.s "C 2", "C#2", "D 2", "D#2", "E 2", "F 2", "F#2", "G 2", "G#2", "A 2", "A#2", "B 2"
  Data.s "C 3", "C#3", "D 3", "D#3", "E 3", "F 3", "F#3", "G 3", "G#3", "A 3", "A#3", "B 3"
  Data.s "C 4", "C#4", "D 4", "D#4", "E 4", "F 4", "F#4", "G 4", "G#4", "A 4", "A#4", "B 4"
  Data.s "C 5", "C#5", "D 5", "D#5", "E 5", "F 5", "F#5", "G 5", "G#5", "A 5", "A#5", "B 5"
  Data.s "C 6", "C#6", "D 6", "D#6", "E 6", "F 6", "F#6", "G 6", "G#6", "A 6", "A#6", "B 6"
  Data.s "C 7", "C#7", "D 7", "D#7", "E 7", "F 7", "F#7", "G 7", "G#7", "A 7", "A#7", "B 7"
  Data.s "C 8", "C#8", "D 8", "D#8", "E 8", "F 8", "F#8", "G 8", "G#8", "A 8", "A#8", "B 8"
EndDataSection

Je trouve ca très propre moi comme datasection !!!

[edit]
ah t'as déjà répondu ^^
le code est nickel ? je le garde de côté (juste explique moi ce qu'il représente lol)
je te recommande l'algo à la datasection ou a la saisie manuelle car je suis sûr qu'il ne prend pas beaucoup de place !!
(et même beaucoup moins, c'est ca la magie des boucles)

tu colles ca dans une procédure InitNotes() et hop c'est tout parfait

Dri

C'est beau

En tout cas, ça a réduit d'un kilo octet l'éxécutable, c'est toujours ça de pris (et plus petit que le même exemple en C

)

Pourquoi avoir un tableau puisque tout àl'r de se calculer facilement.
Autant juste faire un algo (une fonction) qui te renvoi la chaine

(ça prendra encore moins de place !!!

)

Pourquoi un tableau ?
si c'est de la FFT j'imagine que c'est en temps réel (surtout si c'est de la capture de micro nan ?)
un tableau ca prend de la place (là ca prend pas beaucoup) mais moins de ressources (notes calculées une seule fois)

Dri

lionel_om a écrit :Pourquoi avoir un tableau puisque tout àl'r de se calculer facilement.
Autant juste faire un algo (une fonction) qui te renvoi la chaine (ça prendra encore moins de place !!! )

Ce qui s'applique à cet exemple, ne s'applique pas à d'autres. (j'aurais du mettre un exemple plus parlant

)

Dr. Dri>c'est l'algo en lui même qui veut ça : pour déterminer la fréquence la plus juste, il faut déterminer la fréquence du spectre la plus proche (courante ? ou la suivante ?).
Les fréquences de la note se trouvent déja dans un tableau : c'est ce que j'aurais du mettre comme exemple de code rébarbatif car j'ai du la aussi saisir 120 fréquences que je ne peux calculer car n'ayant pas de fonction FFT en PB (j'utilise celle de FMOD Ex) :-p

tu peux me debugger les 120 fréquences et mettre le résultat ici ?
j'ai envie de voir ce que ca donne ^^

Dri

Code : Tout sélectionner

	notefreq(0) = 16.35 : notefreq(1) = 17.32 : notefreq(2) = 18.35 : notefreq(3) = 19.45 : notefreq(4) = 20.6 
	notefreq(5) = 21.83 : notefreq(6) = 23.12 : notefreq(7) = 24.5 : notefreq(8) = 25.96 : notefreq(9) = 27.5
	notefreq(10) = 29.14 : notefreq(11) = 30.87 : notefreq(12) = 32.7 : notefreq(13) = 34.65 : notefreq(14) = 36.71
	notefreq(15) = 38.89 : notefreq(16) = 41.2 : notefreq(17) = 43.65 : notefreq(18) = 46.25 : notefreq(19) = 49
	notefreq(20) = 51.91 : notefreq(21) = 55 : notefreq(22) = 58.27 : notefreq(23) = 61.74 : notefreq(24) = 65.41
	notefreq(25) = 69.3 : notefreq(26) = 73.42 : notefreq(27) = 77.78 : notefreq(28) = 82.41 : notefreq(29) = 87.31
	notefreq(30) = 92.5 : notefreq(31) = 98 : notefreq(32) = 103.83 : notefreq(33) = 110 : notefreq(34) = 116.54
	notefreq(35) = 123.47 : notefreq(36) = 130.81 : notefreq(37) = 138.59 : notefreq(38) = 146.83 : notefreq(39) = 155.56
	notefreq(40) = 164.81 : notefreq(41) = 174.61 : notefreq(42) = 185 : notefreq(43) = 196 : notefreq(44) = 207.65
	notefreq(45) = 220 : notefreq(46) = 233.08 : notefreq(47) = 246.94 : notefreq(48) = 261.63 : notefreq(49) = 277.18
	notefreq(50) = 293.66 : notefreq(51) = 311.13 : notefreq(52) = 329.63 : notefreq(53) = 349.23 : notefreq(54) = 369.99
	notefreq(55) = 392 : notefreq(56) = 415.3 : notefreq(57) = 440 : notefreq(58) = 466.16 : notefreq(59) = 493.88
    notefreq(60) = 523.25 : notefreq(61) = 554.37 : notefreq(62) = 587.33 : notefreq(63) = 622.25 : notefreq(64) = 659.26
    notefreq(65) = 698.46 : notefreq(66) = 739.99 : notefreq(67) = 783.99 : notefreq(68) = 830.61 : notefreq(69) = 880
    notefreq(70) = 932.33 : notefreq(71) = 987.77 : notefreq(72) = 1046.5 : notefreq(73) = 1108.73 : notefreq(74) = 1174.66
    notefreq(75) = 1244.51 : notefreq(76) = 1318.51 : notefreq(77) = 1396.91 : notefreq(78) = 1479.98 : notefreq(79) = 1567.98
    notefreq(80) = 1661.22 : notefreq(81) = 1760 : notefreq(82) = 1864.66 : notefreq(83) = 1975.53 : notefreq(84) = 2093
    notefreq(85) = 2217.46 : notefreq(86) = 2349.32 : notefreq(87) = 2489.02 : notefreq(88) = 2637.02 : notefreq(89) = 2793.83
    notefreq(90) = 2959.96 : notefreq(91) = 3135.96 : notefreq(92) = 3322.44 : notefreq(93) = 3520 : notefreq(94) = 3729.31 
    notefreq(95) = 3951.07 : notefreq(96) = 4186.01 : notefreq(97) = 4434.92 : notefreq(98) = 4698.64 : notefreq(99) = 4978.03
    notefreq(100) = 5274.04 : notefreq(101) = 5587.65 : notefreq(102) = 5919.91 : notefreq(103) = 6271.92 : notefreq(104) = 6644.87 
    notefreq(105) = 7040 : notefreq(106) = 7458.62 : notefreq(107) = 7902.13 : notefreq(108) = 8372.01 : notefreq(109) = 8869.84
    notefreq(110) = 9397.27 : notefreq(111) = 9956.06 : notefreq(112) = 10548.08 : notefreq(113) = 11175.3 : notefreq(114) = 11839.82
    notefreq(115) = 12543.85 : notefreq(116) = 13289.75 : notefreq(117) = 14080 : notefreq(118) = 14917.24 : notefreq(119) = 15804.260

PureBasic

Type Array

Type Array