Le Pub du Ctrl V

Citation : https://fr.audiofanzine.com/img/membres/normal/9/8/98961.jpg

Citation : http://rue89.com/2007/05/13/cecilia_sarkozy_na_pas_vote_un_scoop_censure_du_jdd

Citation : #open "random" ;;

(*"int 10 ;; donne un entier compris entre 0 et 9 non inclus"*)

let generateur_probleme taille valeur_max =
let matrice=(make_matrix taille taille 0) in
for k=0 to (taille-1)
do for q=k+1 to (taille-1)
do let a=int valeur_max in
(matrice.(k)).(q)<-a ;
(matrice.(q)).(k)<-a
done
done;
matrice
;;

(*utilise la fonction "random" (=tire au hasard un entier) pour creer une mautrice de flux ou de distance (note: ces matrices sont symétriques*)

let evaluation_legere place i j flux distance = let r=ref 0 in
let n =(vect_length place) in
for k = 0 to (n-1)
do r:=(((distance.(i)).(k))
*(((flux.(place.(i))).(place.(k)))
-((flux.(place.(j))).(place.(k))))+(!r))
done;
for k=0 to (n-1)
do r:=(((distance.(j)).(k))
*(((flux.(place.(j))).(place.(k)))
-((flux.(place.(i))).(place.(k))))+(!r))
done;(-(!r))
;;

(*implimente la formule plus "fine" vu dans le commentaire.
elle permet d'évaluer non pas le coût globale mais seulement la variation de ce coût*)

(*evaluation_legere [|1;0;2|]
1 2
[|[|0;5;1|];[|5;0;7|];[|1;7;0|]|]
[|[|0;1;2|];[|1;0;1|];[|2;1;0|]|] *)

let rec evaluation_sytematique_auxiliaire place liste flux distance =
match liste with
[(a,b)]->(a,b)
|[]->(0,0)
|(a,d)::b->

let (r,e)=
evaluation_sytematique_auxiliaire place b flux distance
in

if (evaluation_legere place r e flux distance )>
(evaluation_legere place a d flux distance )
then (a,d)
else (r,e)
;;

(*au départ on a un PLACEMENT des composants, la matrice des FLUX, celle des DISTANCES et enfin une LISTE DE PERMUTATIONS POSSIBLES.

l'algorithme est une fonction récursive simple: si le delta du mouvement selectionné est inférieur à celui du delta de la queue de la liste
alors il est sélectionné, sinon on prend celui de la queue de la liste.
on a bien diminution de la taille de la liste à chaque itération.
on arrête lorsqu'il n'y a plus qu'une permutation.
pour le cas où il n'y a pas de mouvement selectionné (liste vide), on affiche un message d'erreur (l'algorithme à échoué)*)


let selection_aleatoire place n = let l=((vect_length place))
and list= ref []
in

for k=1 to n
do list:=((int l),(int l)):!list)
done;
(!list)
;;





let transpose i j vect = let v=copy_vect vect in
v.(i)<-vect.(j);
v.(j)<-vect.(i);
v
;;

let controle permutation place interdiction rang =
let (i,j)=permutation in
let place2=transpose i j place in

if ((interdiction.(i)).(place2.(j)))<rang
&& ((interdiction.(j)).(place2.(i)))<rang
then [(i,j)]
else []
;;


let rec controletotal permutations place interdiction rang =
match permutations with
[]->[]
|a::b->(controle a place interdiction rang)
@(controletotal b place interdiction rang)

;;

let creation_tableau n = let tab=make_vect n 0 in
for k=0 to (n-1)
do tab.(k)<-k
done;tab
;;

let transpose2 i j vect = let a=(vect.(i)) in
vect.(i)<-(vect.(j));
vect.(j)<-a;
;;


let remplir_interdiction interdiction
nombres_mvt interdictionmin place i j rang =
let a = (rang+(int nombres_mvt-interdictionmin)
-interdictionmin)
in
(interdiction.(i)).(place.(i))<-a;
(interdiction.(j)).(place.(j))<-a
;;

let rec selection resultat_intermediaire nombres_mvt mat_interdiction compteur=


let a=( controletotal(selection_aleatoire resultat_intermediaire nombres_mvt) resultat_intermediaire mat_interdiction compteur)

in
if a=[]
then (selection resultat_intermediaire
nombres_mvt mat_interdiction compteur)
else a

;;







let euristhique etapes nombres_mvt interdictionmin flux distance =
let taille = (vect_length flux) in
let mat_interdiction=(make_matrix taille taille 0) in
let resultat_final= ref (creation_tableau taille) in
let resultat_intermediaire=creation_tableau taille in
let compteur = ref 0 in
let delta = ref 0 in

for k = 1 to etapes
do (incr compteur);
let a =( controletotal(selection_aleatoire resultat_intermediaire nombres_mvt)
resultat_intermediaire mat_interdiction (!compteur))
in
let (c,d) = (evaluation_sytematique_auxiliaire resultat_intermediaire
a flux distance)
in
transpose2 c d resultat_intermediaire ;
let var=(!delta)+(evaluation_legere resultat_intermediaire c d flux distance) in
if var<(!delta)
then resultat_final:=resultat_intermediaire ;
remplir_interdiction mat_interdiction nombres_mvt interdictionmin
resultat_intermediaire c d (!compteur);
delta:=var
done;(!resultat_final)
;;

let selection n resultat_intermediaire nombres_mvt mat_interdiction compteur = let compte=ref 0 in
let a= ref (selectionbis resultat_intermediaire nombres_mvt mat_interdiction compteur )in
while (((!a)=[]) || ((!compte)<n))
do a:= (selectionbis resultat_intermediaire nombres_mvt mat_interdiction compteur) ;
compte:= ((!compte)+1);
done;!a
;;

let euristhique etapes nombres_mvt interdictionmin flux distance =
let taille = (vect_length flux) in
let mat_interdiction=(make_matrix taille taille 0) in
let resultat_final= ref (creation_tableau taille) in
let resultat_intermediaire=creation_tableau taille in
let compteur = ref 0 in
let delta = ref 0 in

for k = 1 to etapes
do (incr compteur);
let a =(selection taille resultat_intermediaire nombres_mvt mat_interdiction (!compteur))
in
let (c,d) = (evaluation_sytematique_auxiliaire resultat_intermediaire
a flux distance)
in
transpose2 c d resultat_intermediaire ;
let var=(!delta)+(evaluation_legere resultat_intermediaire c d flux distance) in
if var<(!delta)
then resultat_final:=resultat_intermediaire ;
remplir_interdiction mat_interdiction nombres_mvt interdictionmin
resultat_intermediaire c d (!compteur);
delta:=var
done;(!resultat_final)
;;


let evaluation place flux distance = let resultat = ref 0
and l = ((vect_length place)-1) in
for k=0 to l
do for q=k to l
do resultat:=(!resultat)+((flux.((place.(k)))).((place.(q))))
*(distance.(k)).(q)
done
done;
!resultat
;;
let rec insert e list = match list with
[]->[e]
|a::b->if a>e then (e::a::b) else (a::insert e b)
;;



let rec rajoute tab i j list = match j with
0->tab.(i)<-(hd list)
|_->rajoute tab i (j-1) (tl list)
;;

let rec proche e d list = match list with
[]->0
|[a]->a
|a::b->let d2=a-e in if (0<d2 &&d2<d) then let h=(proche e d2 b) in (min h a)
else proche e d b
;;

let rec retire e list = match list with
[]->[]
|a::b->if a=e then b else a:retire e b)
;;

let suivant tab = let lg= vect_length tab in
let reserve= ref [] in
let k= ref (lg-1) in
let maxi = ref (-1) in

while (!maxi)<tab.(!k)
do reserve:=(insert (tab.(!k))(!reserve));
maxi:= tab.(!k);
k:=((!k)-1)
done;
let t=tab.(!k) in
tab.(!k)<-(proche (tab.(!k)) lg (!reserve));
reserve:=(insert t(!reserve));
reserve:=(retire (tab.(!k)) (!reserve));
for q = (!k)+1 to (lg-1)
do (rajoute tab q (q-((!k)+1)) (!reserve))
done
;;

suivant [|0;1;2;3|] ;;

let creer n = let tab=make_vect n 0 in
for k = 1 to (n-1)
do tab.(k)<-k
done;tab
;;

let creerb n = let tab=make_vect n 0 in
for k = 0 to (n-1)
do tab.(k)<-(n-k-1)
done;tab
;;

let evaluation_barbar flux distance =

let tab=(creer (vect_length flux)) in
let fin=(creerb (vect_length flux)) in
let resultat=ref (copy_vect tab) in
let cout= ref (evaluation tab flux distance) in
suivant tab ;

while tab<>fin
do let a=(evaluation tab flux distance) in if a<(!cout)
then (resultat:=(copy_vect tab) ; cout:=a);
suivant tab;
done;if (!cout)>(evaluation fin flux distance)
then fin
else(!resultat)
;;


let make_matricecubique n = let tab=(make_vect n (make_vect n (make_vect n (-1))))in
let m= ( make_vect n (-1) ) in

for i=0 to (n-1)
do for j = 0 to (n-1)
do (tab.(i)).(j)<-(copy_vect m)
done
done;
tab;;


let statistique n max etapes = let flux=generateur_probleme n max in
let distance=generateur_probleme n max in
let delta = (evaluation (evaluation_barbar flux distance) flux distance) in
let resultat = make_matricecubique etapes in
for k=1 to etapes
do for i = 1 to etapes
do for j = 1 to etapes
do let a=euristhique k i j flux distance in resultat.(i-1).(j-1).(k-1)<-((evaluation a flux distance)-delta)
done done done; resultat;;


statistique 10 10 10 ;;


#open "random" ;;

(*"int 10 ;; donne un entier compris entre 0 et 9 non inclus"*)

let generateur_probleme taille valeur_max =
let matrice=(make_matrix taille taille 0) in
for k=0 to (taille-1)
do for q=k+1 to (taille-1)
do let a=int valeur_max in
(matrice.(k)).(q)<-a ;
(matrice.(q)).(k)<-a
done
done;
matrice
;;

(*utilise la fonction "random" (=tire au hasard un entier) pour creer une mautrice de flux ou de distance (note: ces matrices sont symétriques*)

let evaluation_legere place i j flux distance = let r=ref 0 in
let n =(vect_length place) in
for k = 0 to (n-1)
do r:=(((distance.(i)).(k))
*(((flux.(place.(i))).(place.(k)))
-((flux.(place.(j))).(place.(k))))+(!r))
done;
for k=0 to (n-1)
do r:=(((distance.(j)).(k))
*(((flux.(place.(j))).(place.(k)))
-((flux.(place.(i))).(place.(k))))+(!r))
done;(-(!r))
;;

(*implimente la formule plus "fine" vu dans le commentaire.
elle permet d'évaluer non pas le coût globale mais seulement la variation de ce coût*)

(*evaluation_legere [|1;0;2|]
1 2
[|[|0;5;1|];[|5;0;7|];[|1;7;0|]|]
[|[|0;1;2|];[|1;0;1|];[|2;1;0|]|] *)

let rec evaluation_sytematique_auxiliaire place liste flux distance =
match liste with
[(a,b)]->(a,b)
|[]->(0,0)
|(a,d)::b->

let (r,e)=
evaluation_sytematique_auxiliaire place b flux distance
in

if (evaluation_legere place r e flux distance )>
(evaluation_legere place a d flux distance )
then (a,d)
else (r,e)
;;

(*au départ on a un PLACEMENT des composants, la matrice des FLUX, celle des DISTANCES et enfin une LISTE DE PERMUTATIONS POSSIBLES.

l'algorithme est une fonction récursive simple: si le delta du mouvement selectionné est inférieur à celui du delta de la queue de la liste
alors il est sélectionné, sinon on prend celui de la queue de la liste.
on a bien diminution de la taille de la liste à chaque itération.
on arrête lorsqu'il n'y a plus qu'une permutation.
pour le cas où il n'y a pas de mouvement selectionné (liste vide), on affiche un message d'erreur (l'algorithme à échoué)*)


let selection_aleatoire place n = let l=((vect_length place))
and list= ref []
in

for k=1 to n
do list:=((int l),(int l)):!list)
done;
(!list)
;;





let transpose i j vect = let v=copy_vect vect in
v.(i)<-vect.(j);
v.(j)<-vect.(i);
v
;;

let controle permutation place interdiction rang =
let (i,j)=permutation in
let place2=transpose i j place in

if ((interdiction.(i)).(place2.(j)))<rang
&& ((interdiction.(j)).(place2.(i)))<rang
then [(i,j)]
else []
;;


let rec controletotal permutations place interdiction rang =
match permutations with
[]->[]
|a::b->(controle a place interdiction rang)
@(controletotal b place interdiction rang)

;;

let creation_tableau n = let tab=make_vect n 0 in
for k=0 to (n-1)
do tab.(k)<-k
done;tab
;;

let transpose2 i j vect = let a=(vect.(i)) in
vect.(i)<-(vect.(j));
vect.(j)<-a;
;;


let remplir_interdiction interdiction
nombres_mvt interdictionmin place i j rang =
let a = (rang+(int nombres_mvt-interdictionmin)
-interdictionmin)
in
(interdiction.(i)).(place.(i))<-a;
(interdiction.(j)).(place.(j))<-a
;;

let rec selection resultat_intermediaire nombres_mvt mat_interdiction compteur=


let a=( controletotal(selection_aleatoire resultat_intermediaire nombres_mvt) resultat_intermediaire mat_interdiction compteur)

in
if a=[]
then (selection resultat_intermediaire
nombres_mvt mat_interdiction compteur)
else a

;;







let euristhique etapes nombres_mvt interdictionmin flux distance =
let taille = (vect_length flux) in
let mat_interdiction=(make_matrix taille taille 0) in
let resultat_final= ref (creation_tableau taille) in
let resultat_intermediaire=creation_tableau taille in
let compteur = ref 0 in
let delta = ref 0 in

for k = 1 to etapes
do (incr compteur);
let a =( controletotal(selection_aleatoire resultat_intermediaire nombres_mvt)
resultat_intermediaire mat_interdiction (!compteur))
in
let (c,d) = (evaluation_sytematique_auxiliaire resultat_intermediaire
a flux distance)
in
transpose2 c d resultat_intermediaire ;
let var=(!delta)+(evaluation_legere resultat_intermediaire c d flux distance) in
if var<(!delta)
then resultat_final:=resultat_intermediaire ;
remplir_interdiction mat_interdiction nombres_mvt interdictionmin
resultat_intermediaire c d (!compteur);
delta:=var
done;(!resultat_final)
;;

let selection n resultat_intermediaire nombres_mvt mat_interdiction compteur = let compte=ref 0 in
let a= ref (selectionbis resultat_intermediaire nombres_mvt mat_interdiction compteur )in
while (((!a)=[]) || ((!compte)<n))
do a:= (selectionbis resultat_intermediaire nombres_mvt mat_interdiction compteur) ;
compte:= ((!compte)+1);
done;!a
;;

let euristhique etapes nombres_mvt interdictionmin flux distance =
let taille = (vect_length flux) in
let mat_interdiction=(make_matrix taille taille 0) in
let resultat_final= ref (creation_tableau taille) in
let resultat_intermediaire=creation_tableau taille in
let compteur = ref 0 in
let delta = ref 0 in

for k = 1 to etapes
do (incr compteur);
let a =(selection taille resultat_intermediaire nombres_mvt mat_interdiction (!compteur))
in
let (c,d) = (evaluation_sytematique_auxiliaire resultat_intermediaire
a flux distance)
in
transpose2 c d resultat_intermediaire ;
let var=(!delta)+(evaluation_legere resultat_intermediaire c d flux distance) in
if var<(!delta)
then resultat_final:=resultat_intermediaire ;
remplir_interdiction mat_interdiction nombres_mvt interdictionmin
resultat_intermediaire c d (!compteur);
delta:=var
done;(!resultat_final)
;;


let evaluation place flux distance = let resultat = ref 0
and l = ((vect_length place)-1) in
for k=0 to l
do for q=k to l
do resultat:=(!resultat)+((flux.((place.(k)))).((place.(q))))
*(distance.(k)).(q)
done
done;
!resultat
;;
let rec insert e list = match list with
[]->[e]
|a::b->if a>e then (e::a::b) else (a::insert e b)
;;



let rec rajoute tab i j list = match j with
0->tab.(i)<-(hd list)
|_->rajoute tab i (j-1) (tl list)
;;

let rec proche e d list = match list with
[]->0
|[a]->a
|a::b->let d2=a-e in if (0<d2 &&d2<d) then let h=(proche e d2 b) in (min h a)
else proche e d b
;;

let rec retire e list = match list with
[]->[]
|a::b->if a=e then b else a:retire e b)
;;

let suivant tab = let lg= vect_length tab in
let reserve= ref [] in
let k= ref (lg-1) in
let maxi = ref (-1) in

while (!maxi)<tab.(!k)
do reserve:=(insert (tab.(!k))(!reserve));
maxi:= tab.(!k);
k:=((!k)-1)
done;
let t=tab.(!k) in
tab.(!k)<-(proche (tab.(!k)) lg (!reserve));
reserve:=(insert t(!reserve));
reserve:=(retire (tab.(!k)) (!reserve));
for q = (!k)+1 to (lg-1)
do (rajoute tab q (q-((!k)+1)) (!reserve))
done
;;

suivant [|0;1;2;3|] ;;

let creer n = let tab=make_vect n 0 in
for k = 1 to (n-1)
do tab.(k)<-k
done;tab
;;

let creerb n = let tab=make_vect n 0 in
for k = 0 to (n-1)
do tab.(k)<-(n-k-1)
done;tab
;;

let evaluation_barbar flux distance =

let tab=(creer (vect_length flux)) in
let fin=(creerb (vect_length flux)) in
let resultat=ref (copy_vect tab) in
let cout= ref (evaluation tab flux distance) in
suivant tab ;

while tab<>fin
do let a=(evaluation tab flux distance) in if a<(!cout)
then (resultat:=(copy_vect tab) ; cout:=a);
suivant tab;
done;if (!cout)>(evaluation fin flux distance)
then fin
else(!resultat)
;;


let make_matricecubique n = let tab=(make_vect n (make_vect n (make_vect n (-1))))in
let m= ( make_vect n (-1) ) in

for i=0 to (n-1)
do for j = 0 to (n-1)
do (tab.(i)).(j)<-(copy_vect m)
done
done;
tab;;


let statistique n max etapes = let flux=generateur_probleme n max in
let distance=generateur_probleme n max in
let delta = (evaluation (evaluation_barbar flux distance) flux distance) in
let resultat = make_matricecubique etapes in
for k=1 to etapes
do for i = 1 to etapes
do for j = 1 to etapes
do let a=euristhique k i j flux distance in resultat.(i-1).(j-1).(k-1)<-((evaluation a flux distance)-delta)
done done done; resultat;;


statistique 10 10 10 ;;

Citation : pfff c'est d'un ennui ce post

Citation : nan c'est très très drole à faire marcher ce programme

Citation : http://beatmaker-hiphop.forumactif.com/

Citation : je confirme, ça marche

Citation :

Citation : Citation :
Vivaldi (très dans l'esprit romantique selon moi),

Citation : http://www.myspace.com/aeternahystoriaband

Citation : /paca/forums/t.235451,afpero-a-nice-le-30-juin.html

Citation : http://www.jenhka.com/

Citation : Le terme fut inventé par le compositeur Hugues Dufourt dans un article de 1979. Il sert généralement à désigner des techniques de composition développées principalement par les compositeurs Tristan Murail et Gérard Grisey, même si ce dernier s'identifiait peu dans ce terme et aurait préféré le terme de « musique liminale », qui résumait mieux sa pensée du temps musical.

La musique spectrale, dans un sens restrictif, est principalement basée sur la découverte de la nature du timbre musical et la décomposition spectrale du son musical, à l'origine de la perception de ce timbre. Certaines œuvres comme Atmosphères de György Ligeti, Stimmung de Karlheinz Stockhausen, Metastasis de Iannis Xenakis, Mutations de Jean-Claude Risset et Stria de John Chowning ont directement influencé ce mouvement, par leur ambivalence harmonie-timbre.

La musique « spectrale » tente de synthétiser à l'orchestre ou avec un ensemble instrumental des évolutions temporelles de sons plus ou moins bruités. Elle utilise pour cela des techniques microtonales d'orchestration favorisant une perception fusionnée, qui est celle du timbre, et des processus continus de transformation du matériau dans le temps. Tristan Murail, Gérard Grisey, Hugues Dufourt et Michaël Levinas développeront cette recherche, en y incorporant des techniques dérivées de l'analyse-synthèse par ordinateur, qui a permis de rentrer dans les détails de la représentation du timbre. Ils appliqueront ainsi à l'écriture pour instruments traditionnels des techniques précédemment découvertes en électroacoustiques comme la modulation de fréquence, la boucle de réinjection, la compression de spectres, ou la dilatation d'un son dans le temps. Esthétiquement, cette école s'opposait à la musique sérielle et plus généralement à une musique combinatoire, préférant penser le son complexe comme un continuum, parallèle microscopique du continu formel macroscopique qu'est une œuvre de musique. Horatiu Radulescu a mis au point une autre écriture spectrale basée sur la "scordatura spectrale" comportant des intervalles inégaux, peu nombreux dans le grave et de plus en plus nombreux en montant vers l'aigu.

Il s'agit d'une école esthétique dans le sens où elle a influencé de nombreux compositeurs plus jeunes : Philippe Hurel, Philippe Leroux, Marc-André Dalbavie, Jean-Luc Hervé, Thierry Alla, Fabien Lévy, Xu Yi ou Thierry Blondeau en France ; Kaija Saariaho ou Magnus Lindberg en Finlande ; George Benjamin ou Julian Anderson au Royaume-Uni, pour n'en citer que quelques uns.

Citation : Melodyne, elle sonne

Citation :

Citation : un vrai appareil vintage analogique qui donne des couleurs chaudes!

Citation :