Bash bc command in Linux [with Examples]

The bc (basic calculator) command is used for mathematical calculations, including basic arithmetic operations and high-precision computations. It can handle both integer and floating-point arithmetic and is suitable for interactive use in the terminal as well as for performing calculations within scripts.

Additionally, bc supports variables, assignment operators, mathematical functions, control structures, and more. When compared with expr, bc is a more feature-rich and precise calculator.

Basic Usage

To start the bc calculator, simply type bc in your terminal:

bc

You'll enter the interactive mode, where you can perform calculations line by line. To exit, press Ctrl + D or type quit then press ENTER.

In the majority of Linux distributions, the bc package is installed by default.

If you get the 'bc: command not found' error message, then you have to proceed with the bc package installation on the server.

###Debian/Ubuntu
sudo apt install bc
###RHEL/CentOS Stream
sudo yum install bc
###Fedora
sudo dnf install bc

Performing Basic Arithmetic

You can perform basic arithmetic operations with bc using the following symbols:

• + for addition.
• - for subtraction.
• * for multiplication.
• / for division.
• % for modulus.
• ^ for exponent.

Example:

$ bc
3 + 5
8
20 * 4
80
10 / 2
5
15 % 7
1

You can also perform calculations without entering the bc interactive prompt by using command substitution and the echo command. This method is particularly useful when you want to calculate a specific expression within a script or as part of a command pipeline.

Example:

$ echo "10.5+5" | bc
5.5

Precision and Scale

By default, bc uses a scale of 0, which means it performs integer arithmetic. You can adjust the scale to specify the desired level of precision for floating-point calculations.

Default Behavior (Scale 0 - Integer Arithmetic):

$ bc
10 / 3
3

In the example above, the result is 3 because it operates with a scale of 0 by default, effectively performing integer division.

Adjusting the Scale (Floating-Point Arithmetic):

$ bc
scale=2
10 / 3
3.33

Here, we set the scale to 2, indicating that we want two decimal places in the result. As a result, bc performs floating-point division, and the result is 3.33.

Assigning Values to Variable

You can assign values to variables in bc using the = operator. Variables can hold numeric values or even expressions.

Example:

$ bc
x = 5
y = 3
x + y
8
result = x * y
result
15

Assignment operators

In bc, you can use assignment operators to assign values to variables and perform various operations on variables. Let's look into some examples:

Assignment (=) operator: Assigns a value to a variable.

$ echo "val = 10; val" | bc
10

Addition and Assignment (+=) operator: Adds a value to a variable and assigns the result back to the variable.

$ echo "val = 5; val += 2; val" | bc
7

Subtraction and Assignment (-=) operator: Subtracts a value from a variable and assigns the result back to the variable.

$ echo "val = 10; val -= 3; val" | bc
7

Division and Assignment (/=) operator: Divides a variable by a value and assigns the result back to the variable.

$ echo "val = 10; val /= 2; val" | bc
5

Exponentiation and Assignment (^=) operator: Raises a variable to a power and assigns the result back to the variable.

$ echo "val = 5; val ^= 2; val" | bc
25

Modulus and Assignment (%=) operator: Calculates the modulus of a variable and a value and assigns the result back to the variable.

$ echo "val = 10; val %= 3; val" | bc
1

Using increment (++) and decrement (--) operators like other programming languages but aren't directly supported. You typically use assignment statements to perform such operations. Let's look into a few examples.

Pre-increment equivalent in bc:

$ echo "var=6; var = var + 1; var" | bc
7

In this example, we first assign a value to var, then increment it by 1 before printing the result.

Post-increment equivalent in bc:

$ echo "var=5; result = var; var = var + 1; result" | bc
5

Here, we first assign var to result, then increment var by 1, and finally print result.

Pre-decrement equivalent in bc:

$ echo "var=15; var = var - 1; var" | bc
14

Similarly, we subtract 1 from var to achieve the pre-decrement operation.

Post-decrement equivalent in bc:

$ echo "var=15; result = var; var = var - 1; result" | bc
15

In this case, we first assign var to result, then decrement var by 1, and finally print result.

Relational Operators

In bc, you can use relational operators to compare two numbers or variables, and the result will be either 1 (true) or 0 (false). Here's how these relational operators work with examples:

Less Than (<) Operator: Returns 1 if the left operand is less than the right operand, otherwise 0.

$ echo "10 < 5" | bc
0

Less Than or Equal To (<=) Operator: Returns 1 if the left operand is less than or equal to the right operand, otherwise 0.

$ echo "10 <= 10" | bc
1

Greater Than (>) Operator: Returns 1 if the left operand is greater than the right operand, otherwise 0.

$ echo "10 > 5" | bc
1

Greater Than or Equal To (>=) Operator: Returns 1 if the left operand is greater than or equal to the right operand, otherwise 0.

$ echo "5 >= 10" | bc
0

Equality (==) Operator: Returns 1 if the left operand is equal to the right operand, otherwise 0.

$ echo "5 == 5" | bc
1

Inequality (!=) Operator: Returns 1 if the left operand is not equal to the right operand, otherwise 0.

$ echo "1 != 2" | bc
1

Logical or Boolean operators

You can use logical or boolean operators to evaluate logical expressions. Here's how these operators work with examples:

Logical AND (&&) Operator: Returns 1 if both expressions are non-zero, otherwise 0.

$ echo "26 && 8" | bc
1

In this example, both 26 and 8 are non-zero, so the result is 1.

Logical OR (||) Operator: Returns 1 if either expression is non-zero, otherwise 0.

$ echo "0 || 0" | bc
0

In this example, neither 0 nor 0 are non-zero, so the result is 0.

Logical NOT (!) Operator: Returns 1 if the expression is zero, otherwise 0.

$ echo "! 0" | bc
1

Here, 0 is zero, so the logical NOT operator ! returns 1.

Mathematical Functions

A math library is preloaded and the default scale has been configured if bc is run with the -l option. The scale set at the time of its call is used by the math functions to calculate their results.

Here are some of the commonly used mathematical functions:

• s(x): Calculates the sine of x, expressed in radians.
• c(x): Calculates the cosine of x, expressed in radians.
• l(x): Computes the natural logarithm (base 'e') of x.
• e(x): Calculates the exponential function, raising 'e' to the power of x.
• J(n,x): Computes the integer order n Bessel function of x.

Additional Functions:

• length(x): Returns the total number of significant decimal digits in the expression x.
• read(): Reads the input value.
• scale(expression): Sets the scale (number of decimal digits after the decimal point) based on the expression.
• sqrt(): Computes the square root of a number.
• ibase and obase: Specifies the number base for input and output conversion. Base 10 is the default for both input and output.

Some Examples:

Sine and Cosine Functions:

$ echo "s($pi/6)" | bc -l
0.49999999999999999999

$ echo "c($pi/4)" | bc -l
0.70710678118654752440

Length Function (length(x)):

$ echo "length($pi)" | bc -l
21

Square Root Function (sqrt()):

$ echo "sqrt(4)" | bc
2

ibase and obase (Number Bases):

$ echo "ibase=2;1111" | bc -l
15

$ echo "obase=8;10" | bc -l
12

$ echo "obase=8;ibase=2;101" | bc
5

Setting Pi Using a(1):

$ pi=`echo "h=10;4*a(1)" | bc -l`
$ echo $pi
3.14159265358979323844

File Input/Output

You can perform file input and output operations to read input from files and write results to files.

Reading Input from a File:

$ cat inputfile.txt
3 + 5
20 * 4
10 / 2
15 % 7

You can use bc to read and process these expressions from the file as follows:

$ bc < inputfile.txt
8
80
5
1

You can use the > operator to redirect the output to a file.

$ bc < inputfile.txt > outputfile.txt

To append the output to an existing file instead of overwriting it

$ bc < inputfile.txt >> existingfile.txt

Control Structures

Conditional Statements

In bc, you can use conditional statements to make decisions and execute statements based on the evaluation of a condition. The syntax for a conditional statement in bc is as follows:

Syntax:

if(condition) {statement} else {statement}

Here's an example of a conditional statement in bc:

$ echo 'a=8;b=10;if(a==b) print "a equals to b" else print "a not equals to b" ' | bc -l
a not equals to b

Loops

In bc, you can use loop statements to repeat a series of instructions or statements for a certain number of times or until a specific condition is met. The two common types of loop statements in bc are the for loop and the while loop. Here's how they work with examples:

For Loop Syntax:

for (initialization; condition; increment) { statements }

Example

$ echo "for (i = 1; i <= 5; i++) { i; }" | bc
1
2
3
4
5

Whereas the while loop syntax is:

while (condition) { statements }

Example

$ echo "i=0;while(i<5) {i; i+=1}" | bc
0
1
2
3
4

The above command executes a while loop in the bc calculator, which increments the value of the variable i from 0 to 4.