Newsgroup: it.comp.lang.c
Titolo: Funzione sinusoidale

Salve a tutto il NG.
Volevo sapere come sia possibile, tramite la semplice funzione
putpixel(), riuscire a tracciare l'andamento sinusoidale tipico di
un'onda, con frequenza e ampiezza modificabili.
Non saprei proprio dove mettere le mani, perchè purtroppo non
basta scrivere una funzione (es. y = sen x) per vedersela tracciare.
Thanks.
--
Sparviere
spar...@ngi.it
http://sparviere.tsx.org

 ha scritto nel messaggio
news:OcuM6.5885$pa3.6...@news.infostrada.it...


 ha scritto nel messaggio
news:PLvM6.2669$f56....@news2.tin.it...


 ha scritto nel messaggio
news:PLvM6.2669$f56....@news2.tin.it...


 esclusivamente int come parametri.
allora e' li' il problema hai dichiarato y come int.
y deve essere per forza minimo un float, poi glielo passi a putpixel e il
compilatore fara' la conversione automatica.
ciao
donCiccio

 ha scritto nel messaggio
news:9dudsk$u90$1...@nreadA.inwind.it...


sono tardo :)
Dichiara i come float.
for(i=0; i<MAX_X; i++) {
    putpixel(i+x0, y0-100 * sin(i/10), .....);
}
-- 
Saluti,
    Mardy

 >     x=i+x0;
[VARIAZIONE]
     y=sen(i*scala_x)*scala_y;
------------^-----------^
ovviamente scala_x e scala_y devono essere float.....
[END VARIAZIONE]


Okay, ecco il codice:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
float i,x,y,x0,y0,scala_y,scala_x;
int RISOLUZIONE_Y,MAX_FUNZIONE,MIN_FUNZIONE;
int RISOLUZIONE_X,STRAT_INTERVALLO,END_INTERVALLO;
int main(void)
{
   int gdriver = DETECT, gmode, errorcode;
   initgraph(&gdriver, &gmode, "");
   errorcode = graphresult();
   if (errorcode != grOk)  /* an error occurred */
   {
      printf("Graphics error: %s\n", grapherrormsg(errorcode));
      printf("Press any key to halt:");
      getch();
      exit(1);             /* return with error code */
   }
   delay(2000);
   //Inizializzazione variabili
   RISOLUZIONE_Y=320;
   MAX_FUNZIONE=500;
   MIN_FUNZIONE=1;
   RISOLUZIONE_X=240;
   STRAT_INTERVALLO=200;
   END_INTERVALLO=1;
   // Scala Y
   scala_y=RISOLUZIONE_Y / ((MAX_FUNZIONE-MIN_FUNZIONE)*1.1);
   y0=RISOLUZIONE_Y/2;
   // Scala X
   scala_x=RISOLUZIONE_X/2/ ((STRAT_INTERVALLO-END_INTERVALLO)*1.1);
   x0=RISOLUZIONE_X/2;
   // Ciclo Funzione
     for(i=0;i<300;i++)
     {
 x=i+x0;
 y=sin(i);
 if(y<0) y=y-y0;
 else y=y+y0;
 if(y<0 || y>RISOLUZIONE_Y)
 {
    y=0;
 }
 printf("X: %d - Y= %d ", y, x);
 putpixel(x,y,15);
 delay(10);
     }
   /* clean up */
   getch();
   closegraph();
   return 0;


 sono tardo :)
ecco il mio contributo, ovviamente compilabile solo con BorlandC
ciao
donCiccio
----
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <graphics.h>
/* prototipo per chiamata a funzione di x
 */
typedef double fun_x ( double x );
/* Configurazione del grafico
 */
typedef struct
{
  double from_x;     // unita' x di inizio grafico
  double to_x;       // unita' x di fine grafico
  double lower_y;    // unita' y di limite inferiore del grafico
  double upper_y;    // unita' y di limite superiore del grafico
  double origin_x;   // coordinata x dell'origine degli assi cartesiani
  double origin_y;   // coordinata y dell'origine degli assi cartesiani
} cfg_draw;
/* macro per passare da unita' di y a pixel
 */
#define scale_y( y,cfg,sfy )  ( sfy*(y-cfg->lower_y) )
/* macro per passare da unita' di x a pixel
 */
#define scale_x( x,cfg,sfx )  ( sfx*(x-cfg->from_x) )
/* macro per passare da pixel a unita' di x
 */
#define scale_px( px,cfg,sfx )  ( px/sfx+cfg->from_x )
/* disegna il grafico nella finestra corrente, cha va impostata dal
 * chiamante con setviewport.
 * anche il colore del grafico va impostato dal chiamante
 */
void draw_fun ( fun_x * fun,const cfg_draw * cfg )
{
  struct viewporttype vp;  // finestra in cui disegnare
  double scalefactor_x;    // fattore di scala per x
  double scalefactor_y;    // fattore di scala per y
  int    px;               // coordinata x in pixel del punto
  int    py;               // coordinata y in pixel del punto
  int    dx;               // dimensione orizzontale in pixel del grafico
  int    dy;               // dimensione verticale in pixel del grafico
/* determina ampiezza del grafico e calcola i fattori di scala
 */
  getviewsettings( &vp );
  dx=vp.right-vp.left+1;
  dy=vp.bottom-vp.top+1;
  scalefactor_y=dy/(cfg->upper_y-cfg->lower_y);
  scalefactor_x=dx/(cfg->to_x-cfg->from_x);
/* il primo punto del grafico non viene disegnato
 */
  py=dy-scale_y( fun( cfg->from_x ),cfg,scalefactor_y );
  moveto( 0,py );
/* disegna il grafico
 */
  for( px=1 ; px<dx ; px++ )
  {
    py=dy-scale_y( fun( scale_px(
px,cfg,scalefactor_x ) ),cfg,scalefactor_y );
    lineto( px,py );
  }
/* disegna gli assi cartesiani
 */
  px=scale_x( cfg->origin_x,cfg,scalefactor_x );
  py=dy-scale_y( cfg->origin_y,cfg,scalefactor_y );
  setcolor( LIGHTGRAY );
  line( 0,py,dx,py );
  line( px,0,px,dy );
}
/* una funzione generica di test
 */
fun_x user
{
  return x*x +x -10;
}
int main ( void )
{
  int gdriver = DETECT, gmode, errorcode;
  int maxx,maxy;
  initgraph( &gdriver,&gmode,NULL );
  errorcode = graphresult();
  if( errorcode!=grOk )  /* an error occurred */
  {
    printf("Graphics error: %s\n", grapherrormsg(errorcode));
    printf("Press any key to halt:");
    getch();
    return 1;             /* return with error code */
  }
  maxx=getmaxx();
  maxy=getmaxy();
/* disegna funzione seno
 */
  setviewport( 0,0,maxx/2,maxy/2,1 );
  setcolor( LIGHTBLUE );
  outtext( "Funzione sin(x) da 0 a 2*PI" );
  setviewport( 0,8,maxx/2,maxy/2,1 );
  {
    cfg_draw cfg={ 0,2*M_PI,-1,+1,0,0 };
    draw_fun( sin,&cfg );
  }
/* disegna funzione coseno
 */
  setviewport( 0,maxy/2+1,maxx/2,maxy,1 );
  setcolor( LIGHTRED );
  outtext( "Funzione cos(x) da 0 a 2*PI" );
  setviewport( 0,maxy/2+8,maxx/2,maxy,1 );
  {
    cfg_draw cfg={ 0,2*M_PI,-1,+1,0,0 };
    draw_fun( cos,&cfg );
  }
/* disegna funzione tangente
 */
  setviewport( maxx/2+1,0,maxx,maxy/2,1 );
  setcolor( LIGHTGREEN );
  outtext( "Funzione tan(x) da 0 a 2*PI" );
  setviewport( maxx/2+1,8,maxx,maxy/2,1 );
  {
    cfg_draw cfg_sin={ 0,2*M_PI,-1,+1,0,0 };
    draw_fun( tan,&cfg_sin );
  }
/* disegna funzione utente
 */
  setviewport( maxx/2+1,maxy/2+1,maxx,maxy,1 );
  setcolor( YELLOW );
  outtext( "Funzione user(x) da -10 a +10" );
  setviewport( maxx/2+1,maxy/2+8,maxx,maxy,1 );
  {
    cfg_draw cfg={ -10,+10,-10,+100,0,0 };
    draw_fun( user,&cfg );
  }
  getch();
  closegraph();
  return 0;
}


ok spero di essere stato + utile di prima...
                            Andrea

Wow... grazie a tutti :)
