Ciao a tutti.
Sto svolgendo un esercizio:
"Si consideri il seguente sviluppo in serie di Taylor della funzione logaritmo naturale, approssimato al
termine kesimo,
con k scelto dall'utente tramite tastiera (v. sviluppo nel code):
1. scrivere una funzione “taylor_log” che implementa la serie di Taylor suindicata; la funzione
dovra' ricevere due parametri, x ed k, dove k (termine di approssimazione) si presuppone che sia inserito da tastiera;
2. scrivere una funzione che calcola l'integrale definito di “ln(x)” utilizzando la regola dei trapezi:

(v.formula nel code)

dove:
• “a” e “b” sono gli estremi di integrazione;
• “m” e' il numero di intervalli in cui suddividere [a, b];
• “h” e' la dimensione del singolo intervallo.
Si consideri che “a”, “b” ed “m” devono essere forniti da tastiera.
Calcolare tutti i valori di x e ln(x), per x appartenente all'intervallo [a, b], con incrementi di h, e inserirli in una matrice m x 2, allocata dinamicamente".
ma ho qualche difficoltà ad inserire questi valori nella matrice.

Potreste aiutarmi?

Grazie.


codice:
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <malloc.h>

/* Dichiaro le funzioni */

float power(float a, int n);
float taylor_log(float x, int k);
float integrale(float a, float b,int num_intervalli, int k);
float **valori ( float dx, float *xx, float aa, float bb, int kk);


int main (void) {
    int  k, m, i, j;
    float *x, *log,  a , b, h, **matrice; 
    
    printf (" Inserisci valore x:\n");
    scanf ("%f",&x);
    
    printf ("Inserisci valore k da tastiera: \n");
    scanf ("%d",&k);
    
    
    log = taylor_log( x , k );
    
    printf("Il logaritmo di %f e' %f\n" , x , log);
    
       
      printf("Inserisci l'estermo a:");
      scanf("%f", &a);
      
      printf("Inserisci l'estermo b:");
      scanf("%f", &b);

      printf("Inserisci il numero di intervalli:");
      scanf("%d", &m);
      
      printf("Il valore dell'integrale e' %f\n");
      integrale(a, b, m, k);
    
    
  

/* Alloco il vettore delle righe. Ogni elemento di questo vettore è un puntatore */
    matrice=(float**)malloc(m*sizeof(float*));
    /* Per ogni riga alloco le colonne */
    for (i=0; i<m; i++) {
    matrice[i]=(float*)malloc(2*sizeof(float));
}
/*Inserimento dati */

    for (i=0; i<m; i++) {
        for (j=0; j<2; j++) {
            printf("Inserisci l'elemento di riga %d e colonna %d: ", i,j);
            
    matrice[i][j]= /* qui dovrebbe esserci la chiamata a funzione */
                         }
                    }
                    printf ("La matrice matrice[%d][%d]=%f \n", i, j, matrice[i][j]);
                    
    system("pause");
}


/* Funzioni */

float power(float a, int n)
{
  float potenza;
  int esponente;

  if (n < 0) esponente = -n;
  else esponente = n;

  potenza = 1;
  while (esponente > 0) {
    potenza = potenza * a;
    esponente = esponente - 1;
  }

  if (n < 0)
    return 1.0 / potenza;
  else
    return potenza;
}


float taylor_log(float x, int k)
{
      int n;
      float risultato = 0;
      for (n = 1; n < k; n++) {
          if ( (n % 2) == 0)
             risultato = risultato + pow(x-1,n)/n;
          else
             risultato = risultato - pow(x-1,n)/n;
      }
      return risultato;
}

float integrale(float a, float b,int num_intervalli, int k)
{
      int i;
      float h, risultato;
      h = (b - a) / (float)num_intervalli;
      risultato = 0;
      for (i = 1;i <= num_intervalli-1; i++) {
          risultato = risultato + taylor_log(a+i*h,k);
      }
      return (h/2)*(taylor_log(a,k) + taylor_log(b,k) + 2*risultato);
}

float **valori ( float dx, float *xx, float aa, float bb,  int kk) {
      int i;
      float *logxx;
      
      xx= (float *)malloc(dx*sizeof(float));
      logxx=(float*)malloc(dx*sizeof(float));
      
      for (i=0; i<(int)dx; i++) {
          if ( (xx[i]>=aa)&&(xx[i]<=bb)) { 
               xx[i]= xx[i]+i*dx;
               logxx[i]=taylor_log(xx,kk) + i*dx;
          }
          }
          printf(" I valori incrementati di x sono x[%d]=%f \n", i, xx[i]);
          printf ("I valori incrementati di logx sono log[%d]=%f \n", i, logxx[i]);
          
      }