Experiment: Interprocess Communication Using Pipes
Title:
Using Pipe IPC to Evaluate the Expression √(b² – 4ac)
The first process computes b².
The second process computes 4ac and sends it to the first process using a pipe.
The first process then evaluates √(b² – 4ac) and displays the final value.

Aim:
To write a program using Interprocess Communication (IPC) with pipes where two processes cooperate to evaluate the mathematical expression:

sqrt(b^2−4ac)​
Process–1 computes b²

Process–2 computes 4ac and sends it to Process–1 through a pipe

Process–1 computes the final value and prints it

Theory:
Interprocess Communication using Pipes
A pipe is a unidirectional communication channel that allows data to pass from one process to another.
In Linux, the system call:

int pipe(int fd[2]);
creates two file descriptors:

fd[0] – read end

fd[1] – write end

Pipes are commonly used between a parent and child process created using fork().
In this experiment, two related processes communicate through a pipe:

The child process computes 4ac and sends it to the parent through the pipe.

The parent computes b², receives 4ac, and calculates the final expression.

This demonstrates synchronization, cooperation, and data exchange between processes.

Algorithm:
Start the program.

Declare variables a, b, c and one integer fd[2] for the pipe.

Create a pipe using pipe(fd).

Call fork() to create a child process.

If fork() returns 0, it is the child process:

Close the read end of the pipe.

Compute 4ac.

Write the value to the pipe.

Close the write end.

If fork() returns a positive value, it is the parent process:

Close the write end of the pipe.

Compute b².

Read the value 4ac from the pipe.

Compute the final expression:

b
2
−
4
a
c

Display the result.

Close the read end.

End the program.

Program
#include <stdio.h>
#include <unistd.h>
#include <math.h>
#include <sys/types.h>

int main() {
    int fd[2];
    pid_t pid;
    double a, b, c;
    double four_ac, b2, result, discriminant;

    printf("Enter values of a, b, c: ");
    scanf("%lf %lf %lf", &a, &b, &c);

    // Create pipe
    if (pipe(fd) == -1) {
        perror("Pipe failed");
        return 1;
    }

    pid = fork();

    if (pid < 0) {
        perror("Fork failed");
        return 1;
    }

    else if (pid == 0) {
        // Child process: compute 4ac
        close(fd[0]); // Close read end

        four_ac = 4 * a * c;
        write(fd[1], &four_ac, sizeof(four_ac));

        close(fd[1]); // Close write end
    }

    else {
        // Parent process: compute b^2 and final expression
        close(fd[1]); // Close write end

        b2 = b * b;
        read(fd[0], &four_ac, sizeof(four_ac));

        close(fd[0]); // Close read end

        discriminant = b2 - four_ac;

        if (discriminant < 0) {
            printf("Discriminant (b^2 - 4ac) = %lf is NEGATIVE.\n", discriminant);
            printf("Square root of a negative number is imaginary. Cannot compute real value.\n");
        } else {
            result = sqrt(discriminant);
            printf("Value of sqrt(b^2 - 4ac) = %lf\n", result);
        }
    }

    return 0;
}
Sample Outputs
Case 1: Positive discriminant
Enter values of a, b, c: 1 5 6
Value of sqrt(b^2 - 4ac) = 1.000000
Case 2: Negative discriminant
Enter values of a, b, c: 1 2 5
Discriminant (b^2 - 4ac) = -16.000000 is NEGATIVE.
Square root of a negative number is imaginary. Cannot compute real value.
Result:
The program successfully demonstrates Interprocess Communication using pipes.
The child process computed 4ac, sent it to the parent, and the parent computed b² and evaluated √(b² – 4ac) correctly.
