Thread: Trapezoidal Rule

  1. #1
    Registered User
    Join Date
    Sep 2017
    Posts
    41

    Trapezoidal Rule

    Hi , so i have to make a function that will compute the area using the trapezoidal rule , i have gotten most of it but i have 2 functions that I do not know how to do at all.The computeFa and calculateAreaTrapazoid.

    The point of the program is to calculate the area by analysis and by the trapezoidal , ignore the plot function , it is correct just help with those 2.

    The function is :

    integral from -a to a (a^2 - x^2)e^(-x/a)


    also , if possible please avoid useless comments that talk about indenting the code and do not help solve the problem at all

    Code:
    /*------------------------------------------------- File: TrapezoidShapeArea.c
     Description: Calculates the area of a shape
                  using Trapazoidal rule for integration.
    -------------------------------------------------*/
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    #include "gng1106plplot.h"
    #include "plplot.h"
    // Define symbolic constant
    #define MAX_SIZE 500  // maximum size of arrays
    // Structure definitions
    typedef struct
    {
        // INPUT from the user
        double aStart;  // Initial value of dimension a for plotting
        double aEnd;    // Final value of dimension a for plotting
        double inc;     // incrementation for value of a
        int num_steps;  //  number of steps to determine h (Trapezoidal Rule)
        // Calculated values
        int n;       // number of points a/fA(a) to compute must
        // be less than MAX_SIZE
        double a[MAX_SIZE];  // values  of dimension a
        double area[MAX_SIZE];  // area using analytical equation
        double areaTrap[MAX_SIZE]; // area using Trapezoidal Rule
    }  SHAPE;
    
    
    // function prototypes
    void getUserInput(SHAPE *);
    double getPositiveValue(char *);
    void calculateAreaAnalytical(SHAPE *);
    void calculateAreaTrapazoid(SHAPE *);
    double computeFa(double, int , double);
    void plot(SHAPE *);
    double getMin(double *, int);
    double getMax(double *, int);
    
    
    /*--------------------------------------------
    Function: main
    Description:  Overall control of the program.
    Gets the input from the user, calculates areas
    using analytical solution and using Trapazoidal rule,
    and plot the 2 curves.
    ----------------------------------------------*/
    void main()
    {
        SHAPE shape;  // Input and output data
    
    
        // Get the user input
        getUserInput(&shape);
        // Calculations
        calculateAreaAnalytical(&shape);
        calculateAreaTrapazoid(&shape);
        // Plotting
        plot(&shape);
        printf("All done.");
    }
    
    
    /*----------------------------------------------------------
    Function: getUserInput
    Parameters:
        pPtr - reference to SHAPE structure variable.  Members used
                num_steps - number of steps for determining h
                aStart - starting value for a
                aEnd - end value for a
                inc - incrementation value for dimension a
                n - number of elements used in time/area arrays
    Description: Gets from the user values for range of values for
                 a, an incremetation value for and the number of steps
                 to be used with the Trapezoidal rune (determines h)
                 and stores in appropriate variables.
                 Ensures that aStart is less than aEnd. Computes n
                 and ensures that it is less than MAX_SIZE.
    -------------------------------------------------------------*/
    void getUserInput(SHAPE *pPtr)
    {
        // Get input
        pPtr->num_steps = getPositiveValue("number of steps for defining h");
        do
        {
            pPtr->aStart = getPositiveValue("the start value for a");
            pPtr->aEnd = getPositiveValue("the end value for a");
            pPtr->inc = getPositiveValue("incrementation of a");
            pPtr->n = 1+(pPtr->aEnd - pPtr->aStart)/pPtr->inc;
            if(pPtr->n > MAX_SIZE)
                printf("Incrementation too small for range of dimension a (%d)\n", pPtr->n);
            if(pPtr->n < 0)
                printf("The end value for a must be larger than its start value\n");
        }
        while(pPtr->n > MAX_SIZE || pPtr->n <= 0);
    }
    
    
    /*----------------------------------------------------------
    Function: getPositiveValue
    Parameters:
        prompt - reference to string to include in the user prompt
    Returns
        value: positive value obtained from the user.
    Description: Prompt the user for a value (using the prompt string)
        and checks that the value is positive.
    -------------------------------------------------------------*/
    double getPositiveValue(char *prompt)
    {
        double value; // Value entered by the user.
        do
        {
            printf("Please enter a value for %s: ", prompt);
            scanf("%lf",&value);
            if(value <= 0.0)
                printf("The value must be greater than zero.\n");
        }
        while(value <= 0.0);
        return(value);
    }
    
    
    /*----------------------------------------------------------
    Function: calculateAreaAnalytical
    Parameters:
        sPtr - reference to SHAPE structure variable.  Members used
                aStart - starting value for a
                inc - incrementation value for dimension a
                n - number of elements used in time/area arrays
                a - array for saving values of a
                area - array for saving area values
    Description: Fills in the arrays with n points of
        a/fA(a) values using the analytical solution for the
        area fA(a).
    -------------------------------------------------------------*/
    void calculateAreaAnalytical(SHAPE *sPtr)
    {
        double aValue;
        int ix;
        aValue = sPtr->aStart;
        for(ix = 0; ix < sPtr->n; ix = ix + 1)
        {
    
    
            sPtr->a[ix] = aValue;
            sPtr->area[ix] = 4.0*pow(aValue,3)/exp(1);
            aValue = aValue + sPtr->inc;
        }
    }
    
    
    /*----------------------------------------------------------
    Function: calculateAreaTrapazoid
    Parameters:
        sPtr - reference to SHAPE structure variable.  Members used
                num_steps - number of steps for determining h
                aStart - starting value for a
                inc - incrementation value for dimension a
                n - number of elements used in time/area arrays
                a - array for saving values of a
                areaTrap - array for saving area values
    Description: Fills in the arrays with n points of
        a/area values using the Trapezoidal rule for the
        distance.
    -------------------------------------------------------------*/
    void calculateAreaTrapazoid(SHAPE *sPtr)
    {
    
    
    }
    
    
    /*----------------------------------------------------------
    Function: computeFa
    Parameters:
        a - Dimension a of the scrapper
        num_steps - number of steps for determining h
    Description: Computes the value of fA(a) for the dimension a
                 by applying the Trapezoidal rule for integrating
                 f(x) from -a to +a.
    -------------------------------------------------------------*/
    double computeFa(double a, int num_steps)
    {
    
    
    
    
    }
    
    
    /*----------------------------------------------------------
    Function: plot
    Parameters:
        sPtr - reference to SHAPE structure variable.  Members used
                aStart - starting value for dimension a
                aEnd - end value for dimension a
                n - number of elements used in time/area arrays
                a - array for saving values of a
                areaTrap - array for saving area values
    Description: Initilialises the plot device, pen width,
                 and plots both cuvers for the analytical and the
                 Euler method.
    ----------------------------------------------------------------*/
    void plot(SHAPE *sPtr)
    {
        double maxArea;   // maximum area
        double temp;
        char plotLabel[100];
    
    
        // Find the maximum distance to scale the distance axis
        maxArea = getMax(sPtr->area, sPtr->n);
        temp = getMax(sPtr->areaTrap, sPtr->n);
        if(temp > maxArea) maxArea = temp;
        maxArea = 1.1*maxArea;
        // Initiliaise the PLplot page
        plsdev("wingcc");  // Sets device to wingcc - CodeBlocks compiler
        // Initialise the plot
        plinit();
        plwidth(2);    // pen width
        plenv(sPtr->aStart, sPtr->aEnd, 0, maxArea, 0, 0);
        plcol0(GREEN);           // Select color for labels
        sprintf(plotLabel, "Part area (num steps = %d)",
                sPtr->num_steps);
        pllab("Dimension a", "Area fA(a)", plotLabel);
        // Plot the analytical curve
        plcol0(RED);
        pllsty(SOLID);
        plline(sPtr->n, sPtr->a, sPtr->area);
        plptex(0.1*(sPtr->aEnd - sPtr->aStart) + sPtr->aStart, 0.9*maxArea,
               0, 0, 0, "Analytical");
        // Plot the Trapezoidal curve
        plcol0(BLUE);
        pllsty(LNGDASH_LNGGAP);
        plline(sPtr->n, sPtr->a, sPtr->areaTrap);
        plptex(0.3*(sPtr->aEnd - sPtr->aStart) + sPtr->aStart, 0.9*maxArea,
               0, 0, 0, "Trapazoid");
        plend();
    }
    
    
    
    
    /*----------------------------------------------------------
    Function: getMin
    Parameters:
        array - reference to an array with double values
        n - number of elements in the array
    Returns
        min:  the minimum value found in the array
    Description: Traverses the array to find its minimum value.
    ----------------------------------------------------------------*/
    double getMin(double *array, int n)
    {
        int ix;
        double min = array[0];
        for(ix = 1; ix < n; ix = ix +1)
            if(min > array[ix]) min = array[ix];
        return(min);
    }
    
    
    /*----------------------------------------------------------
    Function: getMax
    Parameters:
        array - reference to an array with double values
        n - number of elements in the array
    Returns
        max:  the maximum value found in the array
    Description: Traverses the array to find its maximum value.
    ----------------------------------------------------------------*/
    double getMax(double *array, int n)
    {
        int ix;
        double max = array[0];
        for(ix = 1; ix < n; ix = ix +1)
            if(max < array[ix]) max = array[ix];
        return(max);
    }

  2. #2
    misoturbutc Hodor's Avatar
    Join Date
    Nov 2013
    Posts
    1,743
    You haven't even tried?

  3. #3
    Registered User
    Join Date
    Sep 2017
    Posts
    41
    Yes I did , this is what I have until now , but I am stuck.

    Code:
    void calculateAreaTrapazoid(SHAPE *sPtr){
      double time;  // time value
        int i;        // increment number
        double i_ti;   // for computing i(ti)
        double fti, ftiM1; // compute f(ti), f(ti-1)
        // Initialise values at time 0
        time = sPtr->aStart;
        sPtr->a[0] = time;
        i_ti = 0.0;
        sPtr->areaTrap[0] = 0;
        for(i = 1; i < sPtr->n; i = i +1)
        {
            sPtr->a[i] = time;
            ftiM1 = computeFa(sPtr->a[i-1], sPtr->num_steps);
            fti = computeFa(sPtr->a[i],sPtr->num_steps);
            i_ti = i_ti + (sPtr->num_steps/2)*(ftiM1 + fti);  // note that in the expression, i_ti is I(ti-1)
            sPtr->areaTrap[i] = i_ti;
            time = time + sPtr->inc; 
        }
          
          
      
    }
    
    
    /*----------------------------------------------------------
    Function: computeFa
    Parameters:
        a - Dimension a of the scrapper
        num_steps - number of steps for determining h
    Description: Computes the value of fA(a) for the dimension a
                 by applying the Trapezoidal rule for integrating
                 f(x) from -a to +a.
    -------------------------------------------------------------*/
    double computeFa(double a, int num_steps)
    {
      int i;
      
        for(i=-a ; i < num_steps ; i = i+a)
        {
            
            
            
        }
            
          
          
      }
    
    
    
    
    
    
    }

    I do not know whether to increase a in computeFa or in the other and where to use num_steps , so it is kind of hard to go from here , I am trying but i need help
    Last edited by Kamal Joub; 11-18-2017 at 12:33 AM.

  4. #4
    Registered User
    Join Date
    Sep 2017
    Posts
    41
    This is what I got so far and it's wrong

    Code:
    void calculateAreaTrapazoid(SHAPE *sPtr)
    {
        double time;  // time value
        int i;        // increment number
        double i_ti;   // for computing i(ti)
        double fti, ftiM1; // compute f(ti), f(ti-1)
        // Initialise values at time 0
        time = sPtr->aStart;
        sPtr->a[0] = time;
        i_ti = 0.0;
        sPtr->areaTrap[0] = 0;
        for(i = 1; i < sPtr->n; i = i +1)
        {
            sPtr->a[i] = time;
            ftiM1 = computeFa(sPtr->a[i-1], sPtr->num_steps);
            fti = computeFa(sPtr->a[i] , sPtr->num_steps);
            i_ti = i_ti + (sPtr->num_steps/2)*(ftiM1 + fti);  // note that in the expression, i_ti is I(ti-1)
            sPtr->areaTrap[i] = i_ti;
            time = time + sPtr->inc;
        }
    
    
    
    
    
    
    }
    
    
    /*----------------------------------------------------------
    Function: computeFa
    Parameters:
        a - Dimension a of the scrapper
        num_steps - number of steps for determining h
    Description: Computes the value of fA(a) for the dimension a
                 by applying the Trapezoidal rule for integrating
                 f(x) from -a to +a.
    -------------------------------------------------------------*/
    double computeFa(double a, int num_steps)
    {
      int i;
      double fx = 0;
    
    
        for(i=-a ; i < num_steps ; i = i+a)
        {
            fx = fx + (a*a - i*i)*exp(-i/a);
    
    
        }
    
    
    return(fx);
    
    
    
    
    
    
    
    
    
    
    }

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. trapezoidal rule
    By gameover6005 in forum C Programming
    Replies: 2
    Last Post: 03-22-2013, 12:55 PM
  2. trapezoidal rule
    By howlin in forum C Programming
    Replies: 8
    Last Post: 03-06-2012, 12:02 PM
  3. Simpson's rule and Trapezoidal rule from fixed array
    By timwonderer in forum C++ Programming
    Replies: 1
    Last Post: 12-02-2010, 03:14 PM
  4. composite trapezoidal rule
    By Sam Robinson in forum C Programming
    Replies: 0
    Last Post: 05-19-2003, 10:01 AM
  5. Arrays and the trapezoidal rule
    By ChemistryStar4 in forum C++ Programming
    Replies: 1
    Last Post: 04-05-2003, 09:16 PM

Tags for this Thread