QP School - C 18 Tutorials

Large range and precision in C

Wed, 26 Jul 2023 20:05:12 +0200

Description:

The double data type is commonly used when higher precision is required for real-number calculations. However, it's essential to note that even with double precision, floating-point arithmetic has limitations due to the nature of binary representation. Therefore, it's crucial to be aware of potential rounding errors and inaccuracies when performing calculations with floating-point numbers. In scenarios where precision is of utmost importance, specialized libraries, such as the GNU Multiple Precision Arithmetic Library (GMP), can be utilized to achieve arbitrary precision arithmetic in C.

Example:

double largeNumber = 1.234567890123456e+100;double largeNumber = 1.234567890123456e+100;

Explanation:

In this example, we declare a double variable largeNumber and initialize it with a large value.
The value 1.234567890123456e+100 is expressed using scientific notation, where e+100 means 10 raised to the power of 100.
The double data type allows for a significant range of values, making it suitable for calculations involving very large or very small numbers.

User input and output with double in C

Wed, 26 Jul 2023 20:03:15 +0200

Example:

double radius;
printf("Enter the radius of a circle: ");
scanf("%lf", &radius);
double area = 3.14159265359 * radius * radius;
printf("The area of the circle is: %.2lf\n", area);

Explanation:

In this example, we declare a double variable radius to store the user's input.
We prompt the user to enter the radius of a circle using printf().
We use the %lf format specifier in scanf() to read a double-precision value from the user and store it in the radius variable.
We calculate the area of the circle using the formula area = π * r^2, where π is approximated as 3.14159265359.
Finally, we print the calculated area using printf(). The .2 in the format specifier %.2lf ensures that the area is displayed with two decimal places.

Basic arithmetic operations with the double datatype in C

Wed, 26 Jul 2023 20:01:52 +0200

Example:

double x = 5.5;
double y = 2.5;
double sum = x + y;
double difference = x - y;
double product = x * y;
double quotient = x / y;

Explanation:

In this example, we declare several double variables (x, y, sum, difference, product, and quotient).
We perform basic arithmetic operations using these variables.
sum stores the result of adding x and y.
difference stores the result of subtracting y from x.
product stores the result of multiplying x and y.
quotient stores the result of dividing x by y.

Double datatype in C

Wed, 26 Jul 2023 20:00:33 +0200

Description:

The double data type in C is used to store double-precision floating-point numbers. It typically occupies 8 bytes of memory and offers higher precision compared to the float data type. Double-precision floating-point numbers can represent a broader range of real numbers with greater accuracy.

Example:

double pi = 3.14159265359;

Explanation:

In this example, we declare a variable pi of type double.
We initialize it with the value 3.14159265359.
The double data type provides higher precision than float and can represent real numbers with a range of approximately ±1.8E+308 and typically has 15 to 17 significant decimal digits of precision.

Comparisons with short int in C

Wed, 26 Jul 2023 17:51:59 +0200

Description:

Remember that the short int data type is useful when you need to save memory and the range of values is within its limitations. If you need a broader range or more precision, you may want to use a regular int or other data types like long int or long long int.

Example:

#include

int main() {
short int a = 10;
short int b = 20;

if (a == b) {
printf("a and b are equal.\n");
} else if (a < b) {
printf("a is less than b.\n");
} else {
printf("a is greater than b.\n");
}

return 0;
}

Explanation:

In this example, we compare two short int values a and b. The program checks whether a is equal to b, less than b, or greater than b, and prints the corresponding message.

Type casting with short int in C

Wed, 26 Jul 2023 17:50:34 +0200

Example:

#include

int main() {
int num1 = 200;
int num2 = 100;

// Type cast integers to short int before addition
short int result = (short int)(num1 + num2);
printf("Result: %d\n", result);

return 0;
}

Explanation:

In this example, we have two integers num1 and num2. Before performing the addition, we type-cast the result of num1 + num2 to a short int using (short int) to fit the result within the range of a short int.

User input and short int conversion in C

Wed, 26 Jul 2023 17:49:40 +0200

Example:

#include

int main() {
short int userInput;

// Prompt the user to enter a short int value
printf("Enter a short int value: ");
scanf("%hd", &userInput);

// Perform a simple calculation and display the result
short int result = userInput * 2;
printf("Result: %d\n", result);

return 0;
}

Explanation:

In this example, the user is prompted to enter a short int value. The scanf function is used to read the user input as a short int, and it is stored in the userInput variable. Then, we perform a simple calculation (multiplication by 2) using the short int value and display the result using printf.

Overflow and underflow with short int in C

Wed, 26 Jul 2023 17:48:09 +0200

Example:

#include

int main() {
short int max = 32767;
short int min = -32768;

// Overflow example
short int overflowed = max + 1;
printf("Overflowed value: %d\n", overflowed);

// Underflow example
short int underflowed = min - 1;
printf("Underflowed value: %d\n", underflowed);

return 0;
}

Explanation:

In this example, we demonstrate what happens when a short int variable encounters overflow and underflow. The max value for a short int is 32767, and adding 1 to it causes an overflow, resulting in a value of -32768, which is the min value for a short int. Similarly, subtracting 1 from the min value causes an underflow, resulting in 32767, which is the max value for a short int.

Arithmetic operations with short int in C

Wed, 26 Jul 2023 17:46:56 +0200

Example:

#include

int main() {
short int a = 1000;
short int b = 200;

// Addition
short int sum = a + b;
printf("Sum: %d\n", sum);

// Subtraction
short int difference = a - b;
printf("Difference: %d\n", difference);

// Multiplication
short int product = a * b;
printf("Product: %d\n", product);

// Division
short int quotient = a / b;
printf("Quotient: %d\n", quotient);

return 0;
}

Explanation:

Explanation: In this example, we perform basic arithmetic operations (addition, subtraction, multiplication, and division) using short int variables. The result of each operation is stored in a short int variable and then printed using the %d format specifier in printf.

Storing short integers in C

Wed, 26 Jul 2023 17:45:33 +0200

Description:

In C, the short int data type is used to represent integer values with a smaller range than regular int. It is a signed integer type that typically occupies 2 bytes in memory, which means it has a smaller range of representable values compared to a regular int.

Example:

#include

int main() {
// Declare and initialize a short int variable
short int myShortInt = 32767;

// Print the value of the short int variable
printf("Value of myShortInt: %d\n", myShortInt);
return 0;
}

Explanation:

Explanation: In this example, we declare a short int variable called myShortInt and initialize it with the value 32767. The %d format specifier is used in printf to print the value of the short int variable.

Implicit and explicit type conversion in C

Wed, 26 Jul 2023 10:25:30 +0200

Description:

The float data type is useful for representing real numbers with moderate precision. However, it's important to be cautious when comparing float values for equality due to the limited precision. In some cases, you may need to use double data type, which offers higher precision, when working with very small or very large real numbers.

Example:

int intValue = 10;
float floatValue = 2.5;

// Implicit type conversion (promotion)
float result1 = intValue + floatValue; // Result is 12.5

// Explicit type conversion (type casting)
int result2 = (int)(intValue + floatValue); // Result is 12

Explanation:

In this example, we have an int variable intValue with the value 10 and a float variable floatValue with the value 2.5.
In the first expression, intValue is implicitly converted to float during the addition with floatValue. This is called promotion, where the int is promoted to a float to ensure consistent types during the operation.
In the second expression, we use explicit type casting (type conversion) to convert the result of the addition back to an int. The (int) before the expression indicates the type casting operation.

Working with floats from user input in C

Wed, 26 Jul 2023 10:23:56 +0200

Example:

float radius;
printf("Enter the radius of a circle: ");
scanf("%f", &radius);
float area = 3.14159 * radius * radius;
printf("The area of the circle is: %.2f\n", area);

Explanation:

In this example, we declare a float variable radius to store the user's input.
We prompt the user to enter the radius of a circle using printf().
We use the %f format specifier in scanf() to read a floating-point value from the user and store it in the radius variable.
We calculate the area of the circle using the formula area = π * r^2, where π is approximated as 3.14159.
Finally, we print the calculated area using printf(). The .2 in the format specifier %.2f ensures that the area is displayed with two decimal places.

Storing a floating-point number in C

Wed, 26 Jul 2023 10:22:48 +0200

Description:

The float data type in C is used to store single-precision floating-point numbers. It typically occupies 4 bytes of memory and can represent a wide range of real numbers. However, it has limited precision, so it may not be suitable for applications requiring high accuracy.

Example:

float pi = 3.14159;

Explanation:

In this example, we declare a variable pi of type float.
We initialize it with the value 3.14159.
The float data type can represent real numbers with a range of approximately ±3.4E+38 and typically has 6 to 9 significant decimal digits of precision.

Calculating the area of a rectangle in C

Wed, 26 Jul 2023 10:20:30 +0200

Description:

The int data type is one of the most commonly used data types in C programming for representing and manipulating whole numbers. It is suitable for a wide range of applications, from basic arithmetic calculations to handling user input and data processing. When working with integers, it's essential to be mindful of potential overflow or underflow issues if the values exceed the allowed range for int. In such cases, you may need to consider using a larger data type, such as long int or long long int, which can hold larger integer values.

Example:

int length = 5;
int width = 3;
int area = length * width;

Explanation:

In this example, we declare int variables length, width, and area.
We assign the values 5 and 3 to length and width, respectively.
We calculate the area of a rectangle by multiplying length and width, and store the result in the area variable.

Working with integers from user input in C

Wed, 26 Jul 2023 10:19:32 +0200

Example:

int age;
printf("Enter your age: ");
scanf("%d", &age);
printf("Your age is: %d\n", age);

Explanation:

In this example, we declare an int variable age to store the user's age.
We prompt the user to enter their age using printf().
We use the %d format specifier in scanf() to read an integer value from the user and store it in the age variable.
Finally, we print the user's age using printf().