C program infinite unary operation not working - c

Question

I have three c programs double.c to double the integer, root.c to take square root of integer and square to take square of a integer
./root 9
output:3
./square 9
81
./double 3
ouput:6
I want to chain these operation like pattern will be of left to right
./square root square double 8
pattern = double(square(root(square(8))))
or it can be somthing like
./root square 8
pattern = square(root(8))
What i tried is
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <math.h>
double operate(char * operation, double operand) {
if (strcmp(operation, "square") == 0) {
return pow(operand, 2);
} else if (strcmp(operation, "root") == 0) {
return sqrt(operand);
} else if (strcmp(operation, "double") == 0) {
return 2 * operand;
}
return 0;
}
int main(int argc, char *argv[]) {
if (argc < 3) {
printf("Usage: %s <operand> <operation1> <operation2> ...\n", argv[0]);
return 1;
}
double operand = atof(argv[1]);
for (int i = 2; i < argc; i++) {
operand = operate(argv[i], operand);
}
printf("Result: %.2f\n", operand);
return 0;
}
Which work something like
gcc main.c -o main
./main 8 square root double
output = Works fine
But it is somehow different way to do it and there were some constraints before to implement this before
Following were constraints
• If your implementation results in parent-child relationship between
processes, then parent process must wait for its child process to exit
System calls and library functions
You must only use the below mentioned APIs to implement this question
- fork
- exec* family
- str* family
- ato* family
- printf, sprintf
- round
But i am unable to grasp this how it is related to process and how it will be done Please guide me some right direction so i can do complete this.

Answer 1

I want to chain these operation like pattern will be of left to right
./square root square double 8
pattern = double(square(root(square(8))))
Presumably, such a chain can start with any of the three operations, so each of your programs needs to know how to do such chaining. Also, as you seem to recognize, the code you present doesn't meet the requirements because it uses a separate command to run the chain.
Let's consider the constraints for a moment. The requirement (both practical and explicit) that parent processes must wait for their children, combined with omission from the allowed list of any function that would allow parent processes to do so, implies that fork() is a red herring. You must not fork() because you are not permitted to wait.
Also, neither pow() nor sqrt() is on your list of allowed functions. x * x is a better method of squaring than pow() anyway, but if you want to avoid sqrt() then you'll need to implement a numerical method to compute square roots. For example, you might perform a binary search for the root, or apply Newton's method.
As for the chaining, I see two main implementation approaches available:
All the programs are the same program, which identifies the first operation in the sequence based on the name by which it is launched (argv[0]). It reads the numeric argument, then just applies each operation in turn, starting at argument 0. It prints the result when there are no more operations to perform.
OR
The three programs are each specific to a single operation. When run, they pick the numeric operand from their last argument and perform their particular operation on it. Then,
if there are no other arguments (argc == 2), they print the result;
otherwise, they format the result as a string, and use, say, execve() (without forking) to run the tail of the chain of operations on the intermediate result.
Details are left as the exercise they are meant to be.

Answer 2

You can do it like this, instead:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <math.h>
double operate(char * operation, double operand) {
if (strcmp(operation, "square") == 0) {
return operand * operand;
} else if (strcmp(operation, "root") == 0) {
return sqrt(operand);
} else if (strcmp(operation, "double") == 0) {
return 2 * operand;
}
return 0;
}
int main(int argc, char *argv[]) {
if (argc < 3) {
printf("Usage: %s <operand> <operation1> <operation2> ...\n", argv[0]);
return 1;
}
double operand = atof(argv[argc - 1]);
for (int i = argc - 2; i > 1; i--) {
operand = operate(argv[i], operand);
}
printf("Result: %.2f\n", operand);
return 0;
}
Like said in the comments, you need to start from the last arguments. So you start from argc - 2, which will be the 2nd last.
Also, you don't seem to be allowed to use pow, so just do operand * operand, instead. sqrt isn't in your list either, but I would guess that's a mistake. If not, you could use some approximation.
The simplest way to calculate the square root without the sqrt function would be to use Newton's method to find the positive root of the function
#define EPSILON 0.001
double simple_abs(double x)
{
return x > 0 ? x : -x;
}
double simple_sqrt(double x)
{
double previous = 0;
double guess = x;
while (simple_abs(guess - previous) > EPSILON)
{
previous = guess;
guess = previous - (previous * previous - x) / (2 * previous);
}
return guess;
}
This is not the most optimal solution, but is the one I find the most simple.