Introduction
In this lab, you will learn how to work with floating-point arithmetic in C. You will start by declaring float and double variables, then perform various arithmetic operations on them, and finally, print the results with appropriate precision. The lab covers essential skills for working with decimal numbers and performing precise mathematical calculations in C programming.
The first step demonstrates how to declare floating-point variables using the float and double data types, and how to print the values with desired precision. The second step focuses on performing arithmetic operations, such as addition, subtraction, multiplication, and division, on floating-point numbers.
Declare Float or Double Variables
In this step, you'll learn how to declare floating-point variables in C using float and double data types. Floating-point variables are essential for storing decimal numbers and performing precise mathematical calculations.
First, let's create a new C file to demonstrate variable declarations:
cd ~/project
nano floating_variables.c
Now, add the following code to the file:
#include <stdio.h>
int main() {
// Declaring float variables
float temperature = 98.6;
float price = 19.99;
// Declaring double variables
double pi = 3.14159265359;
double large_number = 1234567890.123456789;
// Printing the variables
printf("Temperature (float): %.2f\n", temperature);
printf("Price (float): %.2f\n", price);
printf("Pi (double): %.5f\n", pi);
printf("Large Number (double): %.9f\n", large_number);
return 0;
}
Compile and run the program:
gcc floating_variables.c -o floating_variables
./floating_variables
Example output:
Temperature (float): 98.60
Price (float): 19.99
Pi (double): 3.14159
Large Number (double): 1234567890.123456789
Let's break down the code:
floatis used for single-precision floating-point numbers (typically 4 bytes)doubleis used for double-precision floating-point numbers (typically 8 bytes)- The
%.2fand%.5fformat specifiers control decimal place precision when printing
Perform Arithmetic on Floating-Point Values
In this step, you'll learn how to perform various arithmetic operations on floating-point numbers in C, including addition, subtraction, multiplication, and division.
Let's modify the previous file to demonstrate floating-point arithmetic:
cd ~/project
nano floating_arithmetic.c
Add the following code to the file:
#include <stdio.h>
int main() {
// Declare floating-point variables
float a = 10.5;
float b = 3.2;
// Addition
float sum = a + b;
printf("Addition: %.2f + %.2f = %.2f\n", a, b, sum);
// Subtraction
float difference = a - b;
printf("Subtraction: %.2f - %.2f = %.2f\n", a, b, difference);
// Multiplication
float product = a * b;
printf("Multiplication: %.2f * %.2f = %.2f\n", a, b, product);
// Division
float quotient = a / b;
printf("Division: %.2f / %.2f = %.2f\n", a, b, quotient);
// Mixed arithmetic operations
float mixed_calc = (a + b) * (a - b) / b;
printf("Mixed Calculation: (%.2f + %.2f) * (%.2f - %.2f) / %.2f = %.2f\n",
a, b, a, b, b, mixed_calc);
return 0;
}
Compile and run the program:
gcc floating_arithmetic.c -o floating_arithmetic
./floating_arithmetic
Example output:
Addition: 10.50 + 3.20 = 13.70
Subtraction: 10.50 - 3.20 = 7.30
Multiplication: 10.50 * 3.20 = 33.60
Division: 10.50 / 3.20 = 3.28
Mixed Calculation: (10.50 + 3.20) * (10.50 - 3.20) / 3.20 = 24.41
Key points about floating-point arithmetic:
- Use
%.2fformat specifier to control decimal precision - Floating-point operations follow standard mathematical rules
- Be aware of potential precision limitations with floating-point calculations
Print Results with Appropriate Precision
In this step, you'll learn how to control the precision of floating-point number output using format specifiers in C.
Create a new file to explore different precision formatting:
cd ~/project
nano floating_precision.c
Add the following code to the file:
#include <stdio.h>
int main() {
// Declare floating-point variables
double pi = 3.14159265358979323846;
double large_number = 1234567.89012345;
// Default printing (limited precision)
printf("Default printing:\n");
printf("Pi: %f\n", pi);
printf("Large Number: %f\n\n", large_number);
// Controlling decimal places
printf("Controlled Precision:\n");
printf("Pi with 2 decimal places: %.2f\n", pi);
printf("Pi with 5 decimal places: %.5f\n", pi);
printf("Pi with 10 decimal places: %.10f\n\n", pi);
// Scientific notation
printf("Scientific Notation:\n");
printf("Large Number (default): %e\n", large_number);
printf("Large Number (3 decimal places): %.3e\n\n", large_number);
// Width and precision combined
printf("Width and Precision:\n");
printf("Pi (width 10, 4 decimal places): %10.4f\n", pi);
printf("Large Number (width 15, 2 decimal places): %15.2f\n", large_number);
return 0;
}
Compile and run the program:
gcc floating_precision.c -o floating_precision
./floating_precision
Example output:
Default printing:
Pi: 3.141593
Large Number: 1234567.890123
Controlled Precision:
Pi with 2 decimal places: 3.14
Pi with 5 decimal places: 3.14159
Pi with 10 decimal places: 3.1415926536
Scientific Notation:
Large Number (default): 1.234568e+06
Large Number (3 decimal places): 1.235e+06
Width and Precision:
Pi (width 10, 4 decimal places): 3.1416
Large Number (width 15, 2 decimal places): 1234567.89
Key points about precision formatting:
%fis the default format specifier for floating-point numbers.2fmeans 2 decimal places,.5fmeans 5 decimal places%eor%Eshows scientific notation- Width specifiers help align and format output
Summary
In this lab, you learned how to declare floating-point variables using the float and double data types, and how to perform arithmetic operations on these values, including addition, subtraction, multiplication, and division. You also learned how to control the precision of decimal places when printing floating-point numbers using format specifiers. These skills are essential for working with decimal data and performing precise mathematical calculations in C programming.
