(A)Explain any five mathematical functions in detail.
Ans :-
Maths function can be access by using Header file like <math.h>
The 5 mathmetical function are :-
(i)sqrt(): Square Root Function
->Purpose: Calculates the square root of a given number.
->Function Prototype:
double sqrt(double x);
Example :-
#include <stdio.h>
#include <math.h>

int main() {
double num = 25.0;
double result = sqrt(num);
printf(“Square root of %.2f is %.2f\n”, num, result);
return 0;
}
(ii) pow(): Power Function :-
-> Purpose: Calculates the value of a number raised to the power of another number.
Function Prototype:
double pow(double x, double y);
Example :-
#include <stdio.h>
#include <math.h>

int main() {
double base = 2.0;
double exponent = 3.0;
double result = pow(base, exponent);
printf(“%.2f raised to the power %.2f is %.2f\n”, base, exponent, result);
return 0;
}
(iii) sin(): Sine Function:-
->Purpose: Calculates the sine of an angle in radians.
->Function Prototype:
double sin(double x);
->Example :
#include <stdio.h>
#include <math.h>

int main() {
double angle = 1.0; // Angle in radians
double result = sin(angle);
printf(“The sine of %.2f radians is %.2f\n”, angle, result);
return 0;
}
(iv) log(): Natural Logarithm Function
->Purpose: Calculates the natural logarithm (base e) of a given number.
->Function Prototype:
double log(double x);
Example:
#include <stdio.h>
#include <math.h>

int main() {
double num = 10.0;
double result = log(num);
printf(“Natural logarithm of %.2f is %.2f\n”, num, result);
return 0;
}

(v) fabs(): Absolute Value Function for Floating-Point Numbers
->Purpose: Calculates the absolute value of a floating-point number.
->Function Prototype:
double fabs(double x);
#include <stdio.h>
#include <math.h>

int main() {
double num = -7.5;
double result = fabs(num);
printf(“The absolute value of %.2f is %.2f\n”, num, result);
return 0;
}

(B)Explain switch….case statement in detail.
Ans :-
->The switch…case statement in C is a control flow statement used for decision-making. It allows you to select a choice from multiple options based on the value of an expression

->The switch statement in C is an alternate to if-else-if ladder statement which allows us to execute multiple operations for the different possibles values of a single variable called switch variable.

->This structure is particularly useful when you have a variable that can take different values, and you want to execute different code for each possible value. Here’s the detailed explanation of the switch…case statement:

Syntax:-
switch (expression) {
case constant1:
// Code to be executed if expression equals constant1
break;

case constant2:
// Code to be executed if expression equals constant2
break;

// Additional cases as needed

default:
// Code to be executed if expression doesn’t match any constant
}

Components:

(i)switch keyword:

->Indicates the beginning of the switch statement.
expression:
->A variable or expression whose value is tested against various case constants.
The result of this expression determines which case is executed.

(ii)case labels:

->Constants or literal values against which the expression is compared.
->If the expression matches a case constant, the corresponding block of code is executed.

(iii)break statement:

->Terminates the switch statement and prevents fall-through to subsequent case statements.
->Without break, the control will “fall through” to the next case, potentially executing unintended code.

(iv)default case:

->Optional and used for handling the situation where the expression doesn’t match any of the specified case constants.
->Similar to an else statement in an if…else construct.

Example :-
#include <stdio.h>

int main() {
int day = 3;

switch(day) {
case 1:
printf(“Monday\n”);
break;

case 2:
printf(“Tuesday\n”);
break;

case 3:
printf(“Wednesday\n”);
break;

case 4:
printf(“Thursday\n”);
break;

case 5:
printf(“Friday\n”);
break;

default:
printf(“Weekend\n”);
}

return 0;
}

(C)Explain exit control loop in detail.
Ans :-
Exit control loop in C to examine the termination condition for an exit. Control would leave the main body of the loop if the evaluation for the termination condition yielded a true result. Otherwise, the control makes another entry inside the loop.

This kind of loop often deals with the loop’s exit control statement.

DO WHILE LOOP
->The most applicable illustration of an exit control loop is the do-while loop.
->The while loop has been modified to become the do-while loop.
->The do-while loop is the most appropriate loop when it is necessary to run the program and do certain activities at least once.
Syntax :-
do
{
// main body of the do-while loop
}
while (termination condition/ test expression);
while (termination condition/ test expression);
->Do-while loop:
(i)An exit control loop is the do-while loop.
(ii)The termination condition/test expression is assessed at exit in the do-while loop.
(iii)The usage of the semicolon, which designates the end of the do-while loop, at the conclusion of the termination condition in the do-while loop is a requirement.
Example :-
do
{
printf(“\n%d”,i);
i++;
} while(i<=6) ;

(ii)While loop:
->An entrance control loop is the while loop.
->The while loop evaluates the test expression and termination condition as soon as it enters the loop.
->The while loop does not require anything to be executed after the termination condition.
Syntax:
while(condition)
{
// loop body
}
Example:
#include <stdio.h> // standard program line for input and output
#include <conio.h> // libraries
void main()
{
float x, y, answer; // declaration of float datatype variables
int choice; // naming variables with the int datatype
do
{
printf(“\n 1.Addition \n 2.Subtraction \n 3.Multiplication \n 4.Division \n 5.Exit”);
// by giving the user an increasing number of options
printf(“\n Enter Your Choice: “); // using the user’s input
scanf(“%d”, &choice); // putting a user-entered value into a variable
if(choice!= 5)
{
printf(“\n Enter X : ” ); // using the user’s input
scanf(“%f”, &x); // putting a user-entered value into a variable
printf(“\n Enter Y : ” ); // using the user’s input
scanf(“%f”, &y); // putting a user-entered value into a variable
}
switch(choice)
{
case 1: // addition case
answer = x + y; // basic operations in addition
printf(“\n the addition of %f and %f is : %f”, x, y, answer);
//answer will be in float datatype
break;
case 2: // subtraction case
answer = x – y; // basic operations in substraction
printf(“\n the subtraction of %f and %f is : %f”, x, y, answer);
//answer will be in float datatype
break;
case 3: // multiplication case
answer = x * y; // basic operations in multiplication
printf(“\n the multiplication of %f and %f is : %f”, x, y, answer);
//answer will be in float datatype
break;
case 4: // division case
answer = x / y; // basic operations in division
printf(“\n the division of %f and %f is : %f”, x, y, answer);
//answer will be in float datatype
break;
case 5:
exit(0); // exit operation
default: // program line to handle user-input errors
printf(“\n sorry, you have entered the invalid input!!!”);
}
getch();
} while(choice!= 5);
}

(D)Write a short note on one dimensional array.
Ans :-
-> A one-dimensional array in programming is a collection of elements of the same data type arranged in a linear sequence.

->It is one of the simplest and most fundamental data structures, providing a way to store and access a fixed-size collection of elements using a single identifier (array name) and an index or subscript

->One-dimensional arrays are the building blocks of more complex data structures and algorithms.

-> They provide a simple and efficient way to organize and manipulate collections of data in a program.

Here are some key points about one-dimensional arrays:

(1)Declaration:
In C, the declaration of a one-dimensional array involves specifying the data type of its elements and the array’s name followed by its size in square brackets [].

->int numbers[5]; // Declaration of an integer array with size 5

(2) Initialization:
You can initialize the elements of an array during declaration or later in the program.

->int numbers[5] = {1, 2, 3, 4, 5}; // Initialization during declaration

(3) Indexing:
Array elements are accessed using an index or subscript, starting from 0 for the first element.

int thirdElement = numbers[2]; // Accessing the third element (index 2)

(4) Size:
The size of a one-dimensional array is fixed during declaration and cannot be changed during the program’s execution.

int numbers[5]; // Array size is 5

(5)Traversal:
You can traverse through the elements of an array using loops, such as ‘for’ or ‘while’.

for (int i = 0; i < 5; i++) {
printf(“%d “, numbers[i]);
}

(6) Common Operations:

One-dimensional arrays are commonly used for tasks like storing lists of items, representing vectors, and performing mathematical operations on sets of data.

// Summing the elements of an array
int sum = 0;
for (int i = 0; i < 5; i++) {
sum += numbers[i];
}

(7)Memory Representation:

In memory, the elements of a one-dimensional array are stored in contiguous locations.

(8)Limitations:

One-dimensional arrays have a fixed size, which can be a limitation when the number of elements is not known at compile time.