C Program for Polynomial Addition

Polynomials are fundamental mathematical expressions having a wide range of applications in various fields, including mathematics, engineering, physics, and computer science. Two polynomials are combined in a process known as polynomial addition to produce a new polynomial that represents their sum. For example, fitting curves, interpreting signals, and manipulating algebraic formulas all need this approach. This session explores polynomial addition theory and provides a comprehensive C programming implementation.

In mathematics, polynomials are a part of algebra. An equation of finite length with variables, constants, and non-zero integer exponents is called a polynomial. Its whole structure is established by the operations of addition, subtraction, and multiplication. Equations known as polynomial equations employ polynomials to address a wide range of issues.

A polynomial is a mathematical statement made up of one or more words, each of which contains a coefficient and an exponent. The general form of a polynomial is as follows:

P(x)=a_nxⁿ+a_n-1x^n-1+…+a₁x+a₀

X is the variable, the coefficients are a_n, a_n-1,...,a₀, and the polynomial's highest exponent is n. The leading term is the term with the largest n exponent in the polynomial of degree n.

Example:

Let's take an example to understand the polynomial addition in C:

#include <stdio.h>
#include <stdlib.h>
struct Term
{
    int coefficient;
    int exponent;
};
struct Polynomial
{
    int numTerms;
    struct Term *terms;
};
void createPolynomial(struct Polynomial *poly)
{
    int i;
printf("Enter the number of terms: ");
scanf("%d", &poly->numTerms);
    poly->terms = (struct Term *)malloc(poly->numTerms * sizeof(struct Term));

printf("Enter the terms:\n");
    for (i = 0; i< poly->numTerms; i++)
scanf("%d%d", &poly->terms[i].coefficient, &poly->terms[i].exponent);
printf("\n");
}
void displayPolynomial(struct Polynomial poly)
{
    int i;
    for (i = 0; i<poly.numTerms; i++)
    {
printf("%dx^%d", poly.terms[i].coefficient, poly.terms[i].exponent);
        if (i + 1 <poly.numTerms)
printf(" + ");
    }
printf("\n");
}
struct Polynomial *addPolynomials(struct Polynomial *poly1, struct Polynomial *poly2)
{
    int i, j, k;
    struct Polynomial *sum;
    sum = (struct Polynomial *)malloc(sizeof(struct Polynomial));
    sum->terms = (struct Term *)malloc((poly1->numTerms + poly2->numTerms) * sizeof(struct Term));
i = j = k = 0;
    while (i< poly1->numTerms&& j < poly2->numTerms)
    {
        if (poly1->terms[i].exponent> poly2->terms[j].exponent)
            sum->terms[k++] = poly1->terms[i++];
        else if (poly1->terms[i].exponent< poly2->terms[j].exponent)
            sum->terms[k++] = poly2->terms[j++];
        else
        {
            sum->terms[k].exponent = poly1->terms[i].exponent;
            sum->terms[k++].coefficient = poly1->terms[i++].coefficient + poly2->terms[j++].coefficient;
        }
    }
    for (; i< poly1->numTerms; i++)
        sum->terms[k++] = poly1->terms[i];
    for (; j < poly2->numTerms; j++)
        sum->terms[k++] = poly2->terms[j];
    sum->numTerms = k;
    return sum;
}
int main()
{
    struct Polynomial poly1, poly2, *polySum;
printf("Enter Polynomial 1:\n");
createPolynomial(&poly1);
printf("Enter Polynomial 2:\n");
createPolynomial(&poly2);
polySum = addPolynomials(&poly1, &poly2);
printf("\n");
printf("Polynomial 1 is: ");
displayPolynomial(poly1);
printf("\n");
printf("Polynomial 2 is: ");
displayPolynomial(poly2);
printf("\n");
printf("Sum of the polynomials is: ");
displayPolynomial(*polySum);
free(poly1.terms);
free(poly2.terms);
    free(polySum->terms);
    free(polySum);
    return 0;
}

Output:

Enter Polynomial 1:
Enter the number of terms: 3
Enter the terms:
3 2
3 1
1 3
Enter Polynomial 2:
Enter the number of terms: 3
Enter the terms:
1 2 
2 1
3 2
Polynomial 1 is: 3x^2 + 3x^1 + 1x^3
Polynomial 2 is: 1x^2 + 2x^1 + 3x^2
Sum of the polynomials is: 4x^2 + 5x^1 + 1x^3 + 3x^2

Explanation:

This C program focuses on polynomial addition using a user-defined data structure. It is structured into functions that allow the creation, display, and addition of two polynomials. The struct Term and struct Polynomial are used to encapsulate the terms and characteristics of a polynomial. The createPolynomial function prompts the user to input the number of terms, coefficients, and exponents of each term for both polynomials. The data is dynamically allocated to the terms array within each polynomial structure.

The displayPolynomial function iterates through the array of terms in a given polynomial, printing each term's coefficient and exponent. The core of the program lies in the addPolynomials function, which takes two polynomial structures as input and performs the addition operation on their terms. The main function prompts the user to input coefficients and exponents for two polynomials, and the addPolynomials function computes the sum of the two polynomials, which is stored in the polySum structure. The results are displayed using the displayPolynomial function.

The program showcases dynamic memory allocation for creating and manipulating polynomial structures, fostering an understanding of data structure manipulation and arithmetic operations. Memory allocated during program execution is properly freed using the free function to prevent memory leaks.

Next TopicC Programming Test

← prev next →