|
 Trouver une ressource
Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !
 UNE ONDELETTE POUR LE TRAITEMENT DU SIGNAL NUMÉRIQUE
 Information sur la source
 Description
Je l'ai longtemps chercher donc j'en fait profiter tout le monde
 Source
- /**************************************************
- * Fichier : FastSymmlet8.C
- * Format : ANSI C++
- *
- * (c) 1998-2002 Daniel Lemire, Ph.D.
- * http://www.ondelette.com/ - wavelet forum - forum sur les ondelettes
- *
- * Last modified on March 6th 1998
- * Dernière modification le 6 mars 1998
- *
- * Free for any use, but this copyright notice must remain.
- * Provide as is. Use at your risks.
- *
- * Gratuit pour toute utilisation, mais préservez cette mention.
- * Sans garantie aucune, utilisez à vos risques.
- *
- * C++ implementation of the Symmlet8 wavelet.
- * See end of the file for usage.
- *
- * Cette classe utilise les ondelettes Symmlet8. Son
- * utilisation est très simple (voir la fin du fichier
- * pour un exemple). Elle suppose des conditions périodiques
- * aux bords.
- *
- ***************************************************/
-
- #include <iostream.h>
-
- static const float scale[8] = {0.0322231006040782f,
- -0.0126039672622638f,
- -0.0992195435769564f,
- 0.297857795605605f,
- 0.803738751805386f,
- 0.497618667632563f,
- -0.0296355276459604f,
- -0.0757657147893567f};
-
- static const float wavelet[8] = {0.0757657147893567f,
- -0.0296355276459604f,
- -0.497618667632563f,
- 0.803738751805386f,
- -0.297857795605605f,
- -0.0992195435769564f,
- 0.0126039672622638f,
- 0.0322231006040782f};
-
- /************************************************
- * An efficient implementation of
- * the Fast Wavelet Transform using
- * Symmlet8 wavelets (FBI fingerprints standard)
- *************************************************/
- class FastSymmlet8
- {
- public:
-
- static void transform (int,float *);
-
- static void invTransform (int,float *);
- static void expand (int,float *);
-
- class NotAPowerOf2Exception{};
- class NotDivisibleBy2Exception{};
-
- static void invTransform(int,float *, int);
- static void transform(int,float *, int);
-
- private:
-
- };
-
- void FastSymmlet8::transform(int length,float * v, int last)
- {
- float * ans=new float[last];
- for(int k=0;k<last;k++) {
- ans[k]=0;
- }
- int half=last/2;
- for(int k=0;k<half-3;k++) {
- ans[k+half]=v[(2*k+0)]*wavelet[0]+v[(2*k+1)]*wavelet[1]+v[(2*k+2)]*wavelet[2]+v[(2*k+3)]*wavelet[3]+v[(2*k+4)]*wavelet[4]+v[(2*k+5)]*wavelet[5]+v[(2*k+6)]*wavelet[6]+v[(2*k+7)]*wavelet[7];
- ans[k]=v[(2*k+0)]*scale[0]+v[(2*k+1)]*scale[1]+v[(2*k+2)]*scale[2]+v[(2*k+3)]*scale[3]+v[(2*k+4)]*scale[4]+v[(2*k+5)]*scale[5]+v[(2*k+6)]*scale[6]+v[(2*k+7)]*scale[7];
- }
- ans[last-3]=v[last-6]*wavelet[0]+v[last-5]*wavelet[1]+v[last-4]*wavelet[2]+v[last-3]*wavelet[3]+v[last-2]*wavelet[4]+v[last-1]*wavelet[5]+v[0]*wavelet[6]+v[1]*wavelet[7];
- ans[half-3]=v[last-6]*scale[0]+v[last-5]*scale[1]+v[last-4]*scale[2]+v[last-3]*scale[3]+v[last-2]*scale[4]+v[last-1]*scale[5]+v[0]*scale[6]+v[1]*scale[7];
- ans[last-2]=v[last-4]*wavelet[0]+v[last-3]*wavelet[1]+v[last-2]*wavelet[2]+v[last-1]*wavelet[3]+v[0]*wavelet[4]+v[1]*wavelet[5]+v[2]*wavelet[6]+v[3]*wavelet[7];
- ans[half-2]=v[last-4]*scale[0]+v[last-3]*scale[1]+v[last-2]*scale[2]+v[last-1]*scale[3]+v[0]*scale[4]+v[1]*scale[5]+v[2]*scale[6]+v[3]*scale[7];
- ans[last-1]=v[last-2]*wavelet[0]+v[last-1]*wavelet[1]+v[0]*wavelet[2]+v[1]*wavelet[3]+v[2]*wavelet[4]+v[3]*wavelet[5]+v[4]*wavelet[6]+v[5]*wavelet[7];
- ans[half-1]=v[last-2]*scale[0]+v[last-1]*scale[1]+v[0]*scale[2]+v[1]*scale[3]+v[2]*scale[4]+v[3]*scale[5]+v[4]*scale[6]+v[5]*scale[7];
- for(int k=0;k<last;k++) {
- v[k]=ans[k];
- }
- delete[] ans;
- }
-
- void FastSymmlet8::transform (int length,float * v)
-
- {
- int last;
- for (last=length;last>8;last/=2) {
- transform(length,v,last);
- }
- if(last!=8) {
- cout<< "Attention : n'est pas une puissance de 2 : " << length << endl;
- cout<< "Careful : not a power of 2 : " << length << endl;
- throw NotAPowerOf2Exception();
- }
- }
-
- void FastSymmlet8::invTransform(int length, float * v, int last)
- {
- int ResultingLength=2*last;
- float * ans=new float[ResultingLength];
- for(int k=0;k<ResultingLength;k++) {
- ans[k]=0;
- }
- for(int k=0;2*k+7<ResultingLength;k++) {
- ans[(2*k+7)]+=scale[7]*v[k]+wavelet[7]*v[k+last] ;
- ans[(2*k+6)]+=scale[6]*v[k]+wavelet[6]*v[k+last] ;
- ans[(2*k+5)]+=scale[5]*v[k]+wavelet[5]*v[k+last] ;
- ans[(2*k+4)]+=scale[4]*v[k]+wavelet[4]*v[k+last] ;
- ans[(2*k+3)]+=scale[3]*v[k]+wavelet[3]*v[k+last] ;
- ans[(2*k+2)]+=scale[2]*v[k]+wavelet[2]*v[k+last] ;
- ans[(2*k+1)]+=scale[1]*v[k]+wavelet[1]*v[k+last] ;
- ans[(2*k+0)]+=scale[0]*v[k]+wavelet[0]*v[k+last] ;
- }
- ans[ResultingLength-6]+=scale[0]*v[last-3]+wavelet[0]*v[ResultingLength-3] ;
- ans[ResultingLength-5]+=scale[1]*v[last-3]+wavelet[1]*v[ResultingLength-3] ;
- ans[ResultingLength-4]+=scale[2]*v[last-3]+wavelet[2]*v[ResultingLength-3] ;
- ans[ResultingLength-3]+=scale[3]*v[last-3]+wavelet[3]*v[ResultingLength-3] ;
- ans[ResultingLength-2]+=scale[4]*v[last-3]+wavelet[4]*v[ResultingLength-3] ;
- ans[ResultingLength-1]+=scale[5]*v[last-3]+wavelet[5]*v[ResultingLength-3] ;
- ans[0]+=scale[6]*v[last-3]+wavelet[6]*v[ResultingLength-3] ;
- ans[1]+=scale[7]*v[last-3]+wavelet[7]*v[ResultingLength-3] ;
- ans[ResultingLength-4]+=scale[0]*v[last-2]+wavelet[0]*v[ResultingLength-2] ;
- ans[ResultingLength-3]+=scale[1]*v[last-2]+wavelet[1]*v[ResultingLength-2] ;
- ans[ResultingLength-2]+=scale[2]*v[last-2]+wavelet[2]*v[ResultingLength-2] ;
- ans[ResultingLength-1]+=scale[3]*v[last-2]+wavelet[3]*v[ResultingLength-2] ;
- ans[0]+=scale[4]*v[last-2]+wavelet[4]*v[ResultingLength-2] ;
- ans[1]+=scale[5]*v[last-2]+wavelet[5]*v[ResultingLength-2] ;
- ans[2]+=scale[6]*v[last-2]+wavelet[6]*v[ResultingLength-2] ;
- ans[3]+=scale[7]*v[last-2]+wavelet[7]*v[ResultingLength-2] ;
- ans[ResultingLength-2]+=scale[0]*v[last-1]+wavelet[0]*v[ResultingLength-1] ;
- ans[ResultingLength-1]+=scale[1]*v[last-1]+wavelet[1]*v[ResultingLength-1] ;
- ans[0]+=scale[2]*v[last-1]+wavelet[2]*v[ResultingLength-1] ;
- ans[1]+=scale[3]*v[last-1]+wavelet[3]*v[ResultingLength-1] ;
- ans[2]+=scale[4]*v[last-1]+wavelet[4]*v[ResultingLength-1] ;
- ans[3]+=scale[5]*v[last-1]+wavelet[5]*v[ResultingLength-1] ;
- ans[4]+=scale[6]*v[last-1]+wavelet[6]*v[ResultingLength-1] ;
- ans[5]+=scale[7]*v[last-1]+wavelet[7]*v[ResultingLength-1] ;
- for(int k=0;k<ResultingLength;k++) {
- v[k]=ans[k];
- }
- delete[] ans;
- }
-
- void FastSymmlet8::invTransform (int length,float * v) {
- int last;
- for (last=8;2*last<=length;last*=2) {
- invTransform(length, v,last);
- }
- if(last!=length) {
- cout << "Careful: not a power of 2 : " << length << endl;
- cout << "Attention : n'est pas une puissance de 2 : " << length << endl;
- throw NotAPowerOf2Exception();
- }
-
- }
-
- void FastSymmlet8::expand(int length, float * v) {
-
- int last=length/2;
- int ResultingLength=2*last;
- float * ans=new float[ResultingLength];
- for(int k=0;k<ResultingLength;k++) {
- ans[k]=0;
- }
- for(int k=0;2*k+7<ResultingLength;k++) {
- ans[(2*k+7)]+=scale[7]*v[k];
- ans[(2*k+6)]+=scale[6]*v[k];
- ans[(2*k+5)]+=scale[5]*v[k];
- ans[(2*k+4)]+=scale[4]*v[k];
- ans[(2*k+3)]+=scale[3]*v[k];
- ans[(2*k+2)]+=scale[2]*v[k];
- ans[(2*k+1)]+=scale[1]*v[k];
- ans[(2*k+0)]+=scale[0]*v[k];
- }
- ans[ResultingLength-6]+=scale[0]*v[last-3];
- ans[ResultingLength-5]+=scale[1]*v[last-3];
- ans[ResultingLength-4]+=scale[2]*v[last-3];
- ans[ResultingLength-3]+=scale[3]*v[last-3];
- ans[ResultingLength-2]+=scale[4]*v[last-3];
- ans[ResultingLength-1]+=scale[5]*v[last-3];
- ans[0]+=scale[6]*v[last-3];
- ans[1]+=scale[7]*v[last-3];
- ans[ResultingLength-4]+=scale[0]*v[last-2];
- ans[ResultingLength-3]+=scale[1]*v[last-2];
- ans[ResultingLength-2]+=scale[2]*v[last-2];
- ans[ResultingLength-1]+=scale[3]*v[last-2];
- ans[0]+=scale[4]*v[last-2];
- ans[1]+=scale[5]*v[last-2];
- ans[2]+=scale[6]*v[last-2];
- ans[3]+=scale[7]*v[last-2];
- ans[ResultingLength-2]+=scale[0]*v[last-1];
- ans[ResultingLength-1]+=scale[1]*v[last-1];
- ans[0]+=scale[2]*v[last-1];
- ans[1]+=scale[3]*v[last-1];
- ans[2]+=scale[4]*v[last-1];
- ans[3]+=scale[5]*v[last-1];
- ans[4]+=scale[6]*v[last-1];
- ans[5]+=scale[7]*v[last-1];
- for(int k=0;k<length;k++) {
- v[k]=ans[k];
- }
- delete[] ans;
- }
-
- /***************
- * Thanks to Peter Meerwald for pointing out a bug on the web release
- * of this code.
- ***************/
- int main () {
- int length = 32;
- float t[32]={1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f};
- FastSymmlet8::transform(length,t);
- FastSymmlet8::invTransform (length,t);
- for(int k=0;k<length;k++) {
- cout << t[k] << endl;
- }
-
- }
-
-
-
/**************************************************
* Fichier : FastSymmlet8.C
* Format : ANSI C++
*
* (c) 1998-2002 Daniel Lemire, Ph.D.
* http://www.ondelette.com/ - wavelet forum - forum sur les ondelettes
*
* Last modified on March 6th 1998
* Dernière modification le 6 mars 1998
*
* Free for any use, but this copyright notice must remain.
* Provide as is. Use at your risks.
*
* Gratuit pour toute utilisation, mais préservez cette mention.
* Sans garantie aucune, utilisez à vos risques.
*
* C++ implementation of the Symmlet8 wavelet.
* See end of the file for usage.
*
* Cette classe utilise les ondelettes Symmlet8. Son
* utilisation est très simple (voir la fin du fichier
* pour un exemple). Elle suppose des conditions périodiques
* aux bords.
*
***************************************************/
#include <iostream.h>
static const float scale[8] = {0.0322231006040782f,
-0.0126039672622638f,
-0.0992195435769564f,
0.297857795605605f,
0.803738751805386f,
0.497618667632563f,
-0.0296355276459604f,
-0.0757657147893567f};
static const float wavelet[8] = {0.0757657147893567f,
-0.0296355276459604f,
-0.497618667632563f,
0.803738751805386f,
-0.297857795605605f,
-0.0992195435769564f,
0.0126039672622638f,
0.0322231006040782f};
/************************************************
* An efficient implementation of
* the Fast Wavelet Transform using
* Symmlet8 wavelets (FBI fingerprints standard)
*************************************************/
class FastSymmlet8
{
public:
static void transform (int,float *);
static void invTransform (int,float *);
static void expand (int,float *);
class NotAPowerOf2Exception{};
class NotDivisibleBy2Exception{};
static void invTransform(int,float *, int);
static void transform(int,float *, int);
private:
};
void FastSymmlet8::transform(int length,float * v, int last)
{
float * ans=new float[last];
for(int k=0;k<last;k++) {
ans[k]=0;
}
int half=last/2;
for(int k=0;k<half-3;k++) {
ans[k+half]=v[(2*k+0)]*wavelet[0]+v[(2*k+1)]*wavelet[1]+v[(2*k+2)]*wavelet[2]+v[(2*k+3)]*wavelet[3]+v[(2*k+4)]*wavelet[4]+v[(2*k+5)]*wavelet[5]+v[(2*k+6)]*wavelet[6]+v[(2*k+7)]*wavelet[7];
ans[k]=v[(2*k+0)]*scale[0]+v[(2*k+1)]*scale[1]+v[(2*k+2)]*scale[2]+v[(2*k+3)]*scale[3]+v[(2*k+4)]*scale[4]+v[(2*k+5)]*scale[5]+v[(2*k+6)]*scale[6]+v[(2*k+7)]*scale[7];
}
ans[last-3]=v[last-6]*wavelet[0]+v[last-5]*wavelet[1]+v[last-4]*wavelet[2]+v[last-3]*wavelet[3]+v[last-2]*wavelet[4]+v[last-1]*wavelet[5]+v[0]*wavelet[6]+v[1]*wavelet[7];
ans[half-3]=v[last-6]*scale[0]+v[last-5]*scale[1]+v[last-4]*scale[2]+v[last-3]*scale[3]+v[last-2]*scale[4]+v[last-1]*scale[5]+v[0]*scale[6]+v[1]*scale[7];
ans[last-2]=v[last-4]*wavelet[0]+v[last-3]*wavelet[1]+v[last-2]*wavelet[2]+v[last-1]*wavelet[3]+v[0]*wavelet[4]+v[1]*wavelet[5]+v[2]*wavelet[6]+v[3]*wavelet[7];
ans[half-2]=v[last-4]*scale[0]+v[last-3]*scale[1]+v[last-2]*scale[2]+v[last-1]*scale[3]+v[0]*scale[4]+v[1]*scale[5]+v[2]*scale[6]+v[3]*scale[7];
ans[last-1]=v[last-2]*wavelet[0]+v[last-1]*wavelet[1]+v[0]*wavelet[2]+v[1]*wavelet[3]+v[2]*wavelet[4]+v[3]*wavelet[5]+v[4]*wavelet[6]+v[5]*wavelet[7];
ans[half-1]=v[last-2]*scale[0]+v[last-1]*scale[1]+v[0]*scale[2]+v[1]*scale[3]+v[2]*scale[4]+v[3]*scale[5]+v[4]*scale[6]+v[5]*scale[7];
for(int k=0;k<last;k++) {
v[k]=ans[k];
}
delete[] ans;
}
void FastSymmlet8::transform (int length,float * v)
{
int last;
for (last=length;last>8;last/=2) {
transform(length,v,last);
}
if(last!=8) {
cout<< "Attention : n'est pas une puissance de 2 : " << length << endl;
cout<< "Careful : not a power of 2 : " << length << endl;
throw NotAPowerOf2Exception();
}
}
void FastSymmlet8::invTransform(int length, float * v, int last)
{
int ResultingLength=2*last;
float * ans=new float[ResultingLength];
for(int k=0;k<ResultingLength;k++) {
ans[k]=0;
}
for(int k=0;2*k+7<ResultingLength;k++) {
ans[(2*k+7)]+=scale[7]*v[k]+wavelet[7]*v[k+last] ;
ans[(2*k+6)]+=scale[6]*v[k]+wavelet[6]*v[k+last] ;
ans[(2*k+5)]+=scale[5]*v[k]+wavelet[5]*v[k+last] ;
ans[(2*k+4)]+=scale[4]*v[k]+wavelet[4]*v[k+last] ;
ans[(2*k+3)]+=scale[3]*v[k]+wavelet[3]*v[k+last] ;
ans[(2*k+2)]+=scale[2]*v[k]+wavelet[2]*v[k+last] ;
ans[(2*k+1)]+=scale[1]*v[k]+wavelet[1]*v[k+last] ;
ans[(2*k+0)]+=scale[0]*v[k]+wavelet[0]*v[k+last] ;
}
ans[ResultingLength-6]+=scale[0]*v[last-3]+wavelet[0]*v[ResultingLength-3] ;
ans[ResultingLength-5]+=scale[1]*v[last-3]+wavelet[1]*v[ResultingLength-3] ;
ans[ResultingLength-4]+=scale[2]*v[last-3]+wavelet[2]*v[ResultingLength-3] ;
ans[ResultingLength-3]+=scale[3]*v[last-3]+wavelet[3]*v[ResultingLength-3] ;
ans[ResultingLength-2]+=scale[4]*v[last-3]+wavelet[4]*v[ResultingLength-3] ;
ans[ResultingLength-1]+=scale[5]*v[last-3]+wavelet[5]*v[ResultingLength-3] ;
ans[0]+=scale[6]*v[last-3]+wavelet[6]*v[ResultingLength-3] ;
ans[1]+=scale[7]*v[last-3]+wavelet[7]*v[ResultingLength-3] ;
ans[ResultingLength-4]+=scale[0]*v[last-2]+wavelet[0]*v[ResultingLength-2] ;
ans[ResultingLength-3]+=scale[1]*v[last-2]+wavelet[1]*v[ResultingLength-2] ;
ans[ResultingLength-2]+=scale[2]*v[last-2]+wavelet[2]*v[ResultingLength-2] ;
ans[ResultingLength-1]+=scale[3]*v[last-2]+wavelet[3]*v[ResultingLength-2] ;
ans[0]+=scale[4]*v[last-2]+wavelet[4]*v[ResultingLength-2] ;
ans[1]+=scale[5]*v[last-2]+wavelet[5]*v[ResultingLength-2] ;
ans[2]+=scale[6]*v[last-2]+wavelet[6]*v[ResultingLength-2] ;
ans[3]+=scale[7]*v[last-2]+wavelet[7]*v[ResultingLength-2] ;
ans[ResultingLength-2]+=scale[0]*v[last-1]+wavelet[0]*v[ResultingLength-1] ;
ans[ResultingLength-1]+=scale[1]*v[last-1]+wavelet[1]*v[ResultingLength-1] ;
ans[0]+=scale[2]*v[last-1]+wavelet[2]*v[ResultingLength-1] ;
ans[1]+=scale[3]*v[last-1]+wavelet[3]*v[ResultingLength-1] ;
ans[2]+=scale[4]*v[last-1]+wavelet[4]*v[ResultingLength-1] ;
ans[3]+=scale[5]*v[last-1]+wavelet[5]*v[ResultingLength-1] ;
ans[4]+=scale[6]*v[last-1]+wavelet[6]*v[ResultingLength-1] ;
ans[5]+=scale[7]*v[last-1]+wavelet[7]*v[ResultingLength-1] ;
for(int k=0;k<ResultingLength;k++) {
v[k]=ans[k];
}
delete[] ans;
}
void FastSymmlet8::invTransform (int length,float * v) {
int last;
for (last=8;2*last<=length;last*=2) {
invTransform(length, v,last);
}
if(last!=length) {
cout << "Careful: not a power of 2 : " << length << endl;
cout << "Attention : n'est pas une puissance de 2 : " << length << endl;
throw NotAPowerOf2Exception();
}
}
void FastSymmlet8::expand(int length, float * v) {
int last=length/2;
int ResultingLength=2*last;
float * ans=new float[ResultingLength];
for(int k=0;k<ResultingLength;k++) {
ans[k]=0;
}
for(int k=0;2*k+7<ResultingLength;k++) {
ans[(2*k+7)]+=scale[7]*v[k];
ans[(2*k+6)]+=scale[6]*v[k];
ans[(2*k+5)]+=scale[5]*v[k];
ans[(2*k+4)]+=scale[4]*v[k];
ans[(2*k+3)]+=scale[3]*v[k];
ans[(2*k+2)]+=scale[2]*v[k];
ans[(2*k+1)]+=scale[1]*v[k];
ans[(2*k+0)]+=scale[0]*v[k];
}
ans[ResultingLength-6]+=scale[0]*v[last-3];
ans[ResultingLength-5]+=scale[1]*v[last-3];
ans[ResultingLength-4]+=scale[2]*v[last-3];
ans[ResultingLength-3]+=scale[3]*v[last-3];
ans[ResultingLength-2]+=scale[4]*v[last-3];
ans[ResultingLength-1]+=scale[5]*v[last-3];
ans[0]+=scale[6]*v[last-3];
ans[1]+=scale[7]*v[last-3];
ans[ResultingLength-4]+=scale[0]*v[last-2];
ans[ResultingLength-3]+=scale[1]*v[last-2];
ans[ResultingLength-2]+=scale[2]*v[last-2];
ans[ResultingLength-1]+=scale[3]*v[last-2];
ans[0]+=scale[4]*v[last-2];
ans[1]+=scale[5]*v[last-2];
ans[2]+=scale[6]*v[last-2];
ans[3]+=scale[7]*v[last-2];
ans[ResultingLength-2]+=scale[0]*v[last-1];
ans[ResultingLength-1]+=scale[1]*v[last-1];
ans[0]+=scale[2]*v[last-1];
ans[1]+=scale[3]*v[last-1];
ans[2]+=scale[4]*v[last-1];
ans[3]+=scale[5]*v[last-1];
ans[4]+=scale[6]*v[last-1];
ans[5]+=scale[7]*v[last-1];
for(int k=0;k<length;k++) {
v[k]=ans[k];
}
delete[] ans;
}
/***************
* Thanks to Peter Meerwald for pointing out a bug on the web release
* of this code.
***************/
int main () {
int length = 32;
float t[32]={1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f};
FastSymmlet8::transform(length,t);
FastSymmlet8::invTransform (length,t);
for(int k=0;k<length;k++) {
cout << t[k] << endl;
}
}
 Conclusion
D'autres info sur : http://www.ondelette.com/
 Fichier Zip
Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !
 Télécharger le zip
 Sources du même auteur
 Sources de la même categorie
Sources en rapport avec celle ci
 Commentaires et avis
 Discussions en rapport avec ce code source dans le forum
Validation d'informations [ par olivierb ]
Bonjour,j'essaie de valider les informations d'un programme sous C++Builder.Le problème c'est que j'utilise ce test if(StrToInt(Edit1->Text) < 2
signal clavier [ par draggoon ]
Je cherche comment analyser en permanence les entree clavier. en fait je veux faire une fonction qui quitte l'application et sauvegarde des que j'appu
Qql connaît la lib signal? [ par trinitacs ]
Cette un lib qui permet de faire communiquer des objet. Mais j'ai un oeude mal pour débuter alors si qql l'a déjà utilisée.l'adresse de cette lib pour
lecture de fichier texte [ par mig73 ]
salut a tousj'ai un projet à réaliser avant la fin de la semaine alors si vous pouvez m'aider c'est COOLma tâche est la suivante:je dois pouvoir lire
Signal / Interrupt_handler sous linux [ par seblegaulois ]
Salut,Je sais bien utiliser en c la fonction signal.J'essais de faire l'equivalent en C++ pour l'appel d'une methode d'une class.Je n'y arrive pas. Je
fonction signal en C++ sous unix (g++) [ par seblegaulois ]
Bonjour,En c, j'arrive à faire :void toto(int) {...}...signal(SIGUSR2,toto);Et en C++, je n'y arrive pas, j'ai fait :class toto {...void toto(int) { .
affichage signal parole au format wav [ par patator99 ]
Bonjour, je voudrai afficher le spectre d'un signal au format .wav, c'est pour du traitement de la parole. Pourriez vous m'aider ? Quel fonctions doit
Archi-débutant en QT : Question bête... [ par nostromo2022 ]
Je débute en C++ et QT, j'essaie d'apprendre les 2 même si ce n'est pas tellement conseillé.Voilà un ptit bout de code :connect( test, SIGNAL(clicked(
[Programmation système] Comment synchroniser des signaux entre processus? [ par biglittlekiss ]
Bonjour,Voila je fait cet exercice et je bloque sur l'execution ens équence des processus.Exercice:Un processus père, construit 2 processus fils, plac
Existe-t-il un moyen de changer les fonctions des touches du pavé numérique? [ par Buzu ]
Est-il possible de faire en sorte que lorsque j'appuie sur la touche '-' du pavé numérique, ce que j'ai tapé avant s'efface comme si j'avai fair 'reto
|
 Téléchargements
Logiciels à télécharger sur le même thème :
Comparez les prix Nouvelle version
|