Corde Vibrante en langage C
abd200
-
dirac -
dirac -
nous avons un problème dont nous avons la solution :il suffit de trouver des équations de courbes afin de modéliser par exemple la position et la vitesse initiale de la corde vibrante mais le plus gros du travail est de trouver une solution optimale afin de stocker les points (correspondants à la position de chaque point de la corde vibrante après une perturbation) dans une structure tableau et le tout doit être stocké dans un fichier. Auriez vous la possibilité de m'envoyer toutes informations sur ce sujet 'la corde vibrante', dans la mesure de vos possibilités bien sûr, sur une façon de faire?
des sources en langage C ?
Merci
des sources en langage C ?
Merci
A voir également:
- Corde Vibrante en langage C
- Langage ascii - Guide
- Langage binaire - Guide
- Que veut dire pdf en langage sms ✓ - Forum Programmation
- Langage visual basic - Télécharger - Langages
- Pascal langage - Télécharger - Édition & Programmation
1 réponse
ta corde elle est comment dans l'espace ? attachee par deux extremités à 2 points de même altitude avec un peu de mou, c'est ca ?
est-ce qu'elle est elastique ?
quelle est sa masse ? nulle ou pas ?
etc...
a part ca ce que tu veux c'est prendre un "instantanné" de l'état de ta corde à un instant donné si j'ai bien compris, comme une photo en quelque sorte.
enfin si le plus gros de ton travail reside dans l'optimisation du stockage, donc la compression, c'est que tu as résolu tous les problèmes physiques j'imagine. ca m'a tout l'air de ressembler a un problème de compression du son, a savoir d'une onde. tu choisis une fréquence d'echantillonage, donc une distance entre tes points de mesure (ex: 5 cm pour une corde d'un mètre), ensuite tu choisis une résolution pour l'axe vertical avec un code de correspondance:
ex: résolution 1 cm si ta corde varie entre -3 et +3 cm, ca fait 7 possiblités donc 3 bits de ton fichier peuvent représenter un point de ta corde.
au total dans l'exemple que je t'ai donné, ta corde d'un mètre tient dans un fichier de 3*21 = 63 bits = 8 octets.
a toi de voir, j'imagine que tu veux de meilleures résolutions.
je te conseille toutefois de te renseigner sur les techniques de traitement numérique du son, c'est tout à fait le même genre de problème (stockage d'une onde)
en gros tu as 2 constantes à choisir: fréquence d'échantillonnage et qualité des échantillons.
est-ce qu'elle est elastique ?
quelle est sa masse ? nulle ou pas ?
etc...
a part ca ce que tu veux c'est prendre un "instantanné" de l'état de ta corde à un instant donné si j'ai bien compris, comme une photo en quelque sorte.
enfin si le plus gros de ton travail reside dans l'optimisation du stockage, donc la compression, c'est que tu as résolu tous les problèmes physiques j'imagine. ca m'a tout l'air de ressembler a un problème de compression du son, a savoir d'une onde. tu choisis une fréquence d'echantillonage, donc une distance entre tes points de mesure (ex: 5 cm pour une corde d'un mètre), ensuite tu choisis une résolution pour l'axe vertical avec un code de correspondance:
ex: résolution 1 cm si ta corde varie entre -3 et +3 cm, ca fait 7 possiblités donc 3 bits de ton fichier peuvent représenter un point de ta corde.
au total dans l'exemple que je t'ai donné, ta corde d'un mètre tient dans un fichier de 3*21 = 63 bits = 8 octets.
a toi de voir, j'imagine que tu veux de meilleures résolutions.
je te conseille toutefois de te renseigner sur les techniques de traitement numérique du son, c'est tout à fait le même genre de problème (stockage d'une onde)
en gros tu as 2 constantes à choisir: fréquence d'échantillonnage et qualité des échantillons.
On a un problème, et le prof impose que l'utilisateur peut choisir parmi 3
fonctions différentes transcrivant la position initiale et 2 fonctions différentes paramétrant la vitesse initiale
ensuite l'utilisateur doit pouvoir appliquer la force qu'il désire à la
corde et notre logiciel doit calculer la position de la corde au point x et
à l'instant t
Mais on a toutes les équations donnant les solutions mais ce que je veux
c'est créer un fichier dans lequel je stocke les valeurs calculées dans un
tableau dynamique de mémoire afin de générer des écrans graphiques
représentant la solution pour différentes valeurs du temps de façon à
simuler le mouvement de la corde.
le problème je lai résolue physiquement , il reste plus qu'a taper le code source, voila mon code mais cest juste le debut ca me donne des resultat aberrant:
(la corde est fixée au deux extremité)
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
FILE *fichier;
char *nom = "profil.dat";
int j,J,N/*,n*/;
double x,dt,dx,A,B,T;
double Ya[100],Yb[100],Yc[100];
printf("donner A\n");
scanf("%lf",&A);
printf("donner le temps finale\n");
scanf("%lf",&T);
printf("donner J\n");
scanf("%d",&J);
printf("donner N\n");
scanf("%d",&N);
dx=1.0/J;
/*printf(" dx=%lf\n ", dx);*/
dt=T/N;
/*printf(" dt=%f\n ", dt);*/
/*n=2;*/
B=(dt*dt)/(dx*dx);
/*printf(" B=%f\n ", B);*/
Ya[0]=0;
/*Ya[J]=0;*/
Yb[0]=0;
/*while(n<=N)
{
t=n*dt;*/
fichier = fopen(nom,"wt");
for(j=1;j<=J-1;j++)
{
/*printf(" j=%d dx=%lf\n ", j , dx);*/
x=j*dx;
/*printf(" x=%lf\n ", x);*/
/*fichier=fopen(nom,"wt");*/
if(x>0 && x<=0.5)
{
Ya[j]=(2.0*A*(j/J));
Yb[j]=(2.0*A*(j/J));
/*Yb[j+1]=(2*A*((j+1)/J));*/
/*printf(" Ya[%d]=%lf\n",j,Ya[j]);
printf(" Yb[%d]=%lf\n",j,Yb[j]);
printf(" Yb[%d]=%lf\n",j+1,Yb[j+1]);*/
/*Yc[j]=2*Yb[j]-Ya[j]+B*((2*A*((j+1)/J))+Yb[j-1]-2*Yb[j]);*/
Yc[j]=2.0*(2.0*A*(j/J))-(2.0*A*(j/J))+B*((2.0*A*((j+1)/J))+(2.0*A*((j-1)/J))-2.0*(2.0*A*(j/J)));
printf(" x=%lf , Yc[%d]=%lf\n ", x ,j , Yc[j]);
fprintf(fichier,"%lf , %lf\n",x,Yc[j]);
}
else
{
Ya[j]=(2.0*A*(1.0-(j/J)));
Yb[j]=(2.0*A*(1.0-(j/J)));
/*Yb[j+1]=(2*A*(1-((j+1)/J)));*/
/*printf(" Ya[%d]=%lf\n",j,Ya[j]);
printf(" Yb[%d]=%lf\n",j,Yb[j]);
printf(" Yb[%d]=%lf\n",j+1,Yb[j+1]);*/
/*Yc[j]=2*Yb[j]-Ya[j]+B*((2*A*((j+1)/J))+Yb[j-1]-2*Yb[j]);*/
Yc[j]=2.0*(2.0*A*(1.0-(j/J)))-(2.0*A*(1.0-(j/J)))+B*((2.0*A*(1.0-((j+1)/J)))+(2.0*A*(1.0-((j-1)/J)))-2.0*(2.0*A*(1.0-(j/J))));
printf(" x=%lf , Yc[%d]=%lf\n ", x , j , Yc[j]);
fprintf(fichier,"%lf , %lf\n", x ,Yc[j] );
}
/*fclose(fichier);*/
}
fclose(fichier);
/*Yc[j]=2*Yb[j]-Ya[j]+B*(Yb[j+1]+Yb[j-1]-2*Yb[j]);
printf(" Y[%d]=%lf ", t , x , Yc[j]);
Yb[j]=Yc[j];
Ya[j]=Yb[j];
n=n+1;
}*/
return 0;
}
attention ce que jai mis entre les slashs cest pas compris dans le programme, jai essayé plusieur possibilité ,
Ya[j] cest la position de la corde à l'instant n-1
Yb[j] cest la position de la corde à l'instant n
Yc[j] c'est la position de la corde à l'instant n+1
jai choisi à linstant n=0 de pincer la corde en x=0.5
et jai choisi d'avoir le meme profil (en forme de triangle) en n=1 (cest a dire Yb[j])
pour 0<x<0.5
Ya[j]=(2.0*A*(j/J));
Yb[j]=(2.0*A*(j/J));
pour 0.5<x<1
Ya[j]=(2.0*A*(1.0-(j/J)));
Yb[j]=(2.0*A*(1.0-(j/J)));
et à partir de la formule Yc[j]=2*Yb[j]-Ya[j]+B*(Yb[j+1]+Yb[j-1]-2*Yb[j])
jen deduis le profil de la ligne n=2 ( ou linstant t=2*dt)
là je fais que le test de la formule je cherche pas à calculer le profil aux instant ultérieur.
voila les résultats quil me donnes:
donner A
1.0
donner le temps finale
19.0 /* ca cest les parametre que que jai fixer*/
donner J
15
donner N
15
et cest les valeurs quil donne
x=0.066667 , Yc[1]=0.000000
x=0.133333 , Yc[2]=0.000000
x=0.200000 , Yc[3]=0.000000
x=0.266667 , Yc[4]=0.000000
x=0.333333 , Yc[5]=0.000000
x=0.400000 , Yc[6]=0.000000
x=0.466667 , Yc[7]=0.000000
x=0.533333 , Yc[8]=2.000000
x=0.600000 , Yc[9]=2.000000
x=0.666667 , Yc[10]=2.000000
x=0.733333 , Yc[11]=2.000000
x=0.800000 , Yc[12]=2.000000
x=0.866667 , Yc[13]=2.000000
x=0.933333 , Yc[14]=-720.000000
impossible!!!
si je pince la cordes au milieu à l'instant zero et que je la lache elle doit vibrer vers le bas ou quelquechose d'autre mais la forme donner par ces valeur
aide moi sil te plait jarrive pas à men sortir et jai un examen le vendredi 11 mai
est ce que cest possible que tu menvoi un programme modele apres jessayerai de comprendre son fonctionnement
je demande cette aide à tout les informaticiens aussi