This post covers how to do basic mathematical operations (elementary arithmetic like multiplication and addition) in Bash with integers or floating-point numbers.

What are the Bash Arithmetic Operators?

Arithmetic Operator | Description |
---|---|

*, /, % | multiplication, division, remainder (modulo) |

+, – | addition, subtraction |

15 •

Contents

- 1 How do you write arithmetic expressions in shell script?
- 2 How do you write arithmetic operations?
- 3 What are arithmetic operations?
- 4 How do you evaluate an arithmetic expression in a shell script?
- 5 How do I execute a Unix script?
- 6 What are the 5 basic arithmetic operations?
- 7 What is the rule of Gemdas?
- 8 What is Bodmas rule in maths?
- 9 Which symbol is used for arithmetic operations?
- 10 Bash Arithmetic Operation
- 11 Example – 1: Using ‘expr’ Command
- 12 Example – 2: Using ‘let’ Command
- 13 Example – 3: Using Double Brackets
- 14 Example – 4: Using ‘bc’ Command for Float or Double Numbers
- 15 Example-5: Using the printf Command for Float or Double Number
- 16 Example-6: Using the awk Command for Arithmetic Operation
- 17 Example-7: Calculate the Percentage of a Value
- 18 Conclusion
- 19 Unix / Linux – Shell Arithmetic Operators Example
- 20 Example
- 21 Useful Video Courses
- 22 Performing Arithmetic Operations in Bash
- 23 Conclusion
- 24 Bash Script – Arithmetic Operators
- 25 Different ways to compute Arithmetic Operations in Bash
- 26 5.9. Math in Shell Scripts — Introduction to Unix Study Guide
- 27 5.9.1.declare¶
- 28 5.9.2.expr¶
- 29 5.9.3.let¶
- 30 5.9.4. BASH Arithmetic ¶
- 31 5.9.5.bc¶
- 32 5.9.6. Numeric Boolean expressions ¶
- 33 Arithmetic – Bash Scripting Tutorial
- 34 Introduction
- 35 Let
- 36 Expr
- 37 Double Parentheses
- 38 Length of a Variable
- 39 Activities
- 40 How to use arithmetic operations in bash
- 41 Limitation of Bash for Arithmetic Operations
- 42 Method One: Arithmetic Evaluation in Bash
- 43 Method Two: Arithmetic Expansion in Bash
- 44 Method Three: Built-inletCommand
- 45 Method Four:exprCommand
- 46 Method Five:bcCommand (for Floating Point Arithmetic)
- 47 Performing addition and subtraction in bash scripts
- 48 Performing multiplication and division in bash scripts
- 49 Using power and remainder (modulo)
- 50 Practice Time: Make a Degree Converter bash script
- 51 Shell Programming – Arithmetic Operators – Unix – DYclassroom
- 52 expr command
- 53 Addition
- 54 Subtraction
- 55 Multiplication
- 56 Division
- 57 Modulus
- 58 JavaScript Arithmetic
- 59 Arithmetic Operations
- 60 Operators and Operands
- 61 Adding
- 62 Incrementing
- 63 Operator Precedence
- 64 JavaScript Operator Precedence Values
- 65 Test Yourself With Exercises

## How do you write arithmetic expressions in shell script?

Bash Script Program

- #!/bin/bash.
- #Basic arithmetic using expr.
- echo “a=10, b=3”
- echo “c is the value of addition c=a+b”
- a=10.
- b=3.
- echo “c= `expr $a + $b`”

## How do you write arithmetic operations?

The order of operations is as follows: 1) simplify terms inside parentheses or brackets, 2) simplify exponents and roots, 3) perform multiplication and division, 4) perform addition and subtraction. Multiplication and division are given equal priority, as are addition and subtraction.

## What are arithmetic operations?

Arithmetic operations is a branch of mathematics, that involves the study of numbers, operation of numbers that are useful in all the other branches of mathematics. It basically comprises operations such as Addition, Subtraction, Multiplication and Division.

## How do you evaluate an arithmetic expression in a shell script?

2. Variables in bash

- 2.1. Declaring Variables. Let’s start by declaring a variable using the declare command without any attributes: $ declare A=2+2 $ echo $A 2+2.
- 2.2. Integer Attribute. If we want this expression to be interpreted as arithmetic, we need to state that explicitly.
- 2.3. let Command.

## How do I execute a Unix script?

How do I run. sh file shell script in Linux?

- Open the Terminal application on Linux or Unix.
- Create a new script file with.sh extension using a text editor.
- Write the script file using nano script-name-here.sh.
- Set execute permission on your script using chmod command: chmod +x script-name-here.sh.
- To run your script:

## What are the 5 basic arithmetic operations?

These operators are + (addition), – (subtraction), * (multiplication), / (division), and % (modulo).

## What is the rule of Gemdas?

GEMDAS is the rule that can be used to simplify or evaluate complicated numerical expressions with more than one binary operation. Important Notes: 1. In a particular simplification, if you have both multiplication and division, do the operations one by one in the order from left to right.

## What is Bodmas rule in maths?

The Bodmas rule follows the order of the BODMAS acronym ie B – Brackets, O – Order of powers or roots, D – Division, M – Multiplication A – Addition, and S – Subtraction. The BODMAS rule states that mathematical expressions with multiple operators need to be solved from left to right in the order of BODMAS.

## Which symbol is used for arithmetic operations?

Answer: Logo provides the usual arithmetic operations of addition, subtraction, multiplication and division, denoted by the symbols +, -, *, /. Each of these operations produces a result.

## Bash Arithmetic Operation

The way arithmetic operations are performed in bash differs from those of other conventional programming languages. In comparison to other scripting languages, bash has certain restrictions, including the inability to handle floating point or double integers. In order to resolve this issue, another command tool is employed in bash. The numerous forms of arithmetic operations are demonstrated in this lesson through the use of several examples.

## Example – 1: Using ‘expr’ Command

The command’expr’is the most ancient command in the bash language for doing arithmetic operations. This command can only be used with integer values and outputs the results immediately to the terminal when executed. When you wish to use the’expr’command to do any mathematical operations, you must separate each operand with a space. Using the following script, create a bash file named expr.bash and save it in your home directory to learn about the’expr’command. !/bin/bash It performs the same function as the stringexpr’10 + 30′ It does the same function as the stringexpr10 + 30 Experiment with the additionexpr10+30.

expr30 percent 9 is a percentage.

echo$myVal1 Using expr within the command substitutemyVal2 =$ substitutemyVal2 (expr30-10) echo$myVal2 To run the script, type the following command into your terminal.

With the backtickorcommand replacement, you can also save the results of the exprcommand in a variable and then print out the contents of the variables later.

## Example – 2: Using ‘let’ Command

‘let’ is another another built-in command in bash that allows you to do arithmetic operations. The ‘let’ command will not be able to display the output to the terminal unless the value is first stored in a variable. The ‘let’command, on the other hand, can be used to circumvent the limits of the ‘expr’command. Using the following script, create a bash file namedlet.bash and save it in your home directory to learn how to use the let command. !/bin/bash Taking 9 and multiplying it by 8letval1 gives 9*3echo$val1.

echo$val2 The result of subtracting 3 from 9letval3 is 9 – 3 echo$val3 Using the formula incrementletval4 = 7letval4++ echo$val4 Let”val5=50+$1″ be used as an argument value in an arithmetic operation.echo$val5 To run the script, type the following command into your terminal.

You may evaluate any arithmetic expression, whether or not it is included in quote marks.

The ‘let’ command can be used in conjunction with the increment or decrement operators. The last section of the example demonstrates how the arithmetic operation may be performed with the argument values by utilizing the ‘let’command and the argument values.

## Example – 3: Using Double Brackets

Bash allows you to do any mathematical operation without the need for a command. It is necessary to use double brackets to do arithmetic operations in this case, because employing double brackets for the execution of mathematical expressions is more versatile than using commands such as “expr” and “let.” Double-bracket arithmetic operations are tested in a bash file entitled dbl.bash, which should be created with the following script in it to be run in double brackets. !/bin/bash Calculate the numerical value of the mathematical expression val1 =$ ((10*5 + 15)) val2 =$ ((10*5 + 15) val3 =$ ((10*5 + 15) val4 =$ ((10*5 + 15) val5 =$ ((10*5 + 15) val6 =$ ((10*5 + 15) val7 =$ ((10*5 + 15) val8 =$ ((10*5 + 15) val9 =$ ((10 echo$val1 Using the increment/decrement operator((val1++)) in the post or pre increment/decrement position echo$val1val2 = 41((-val2)) echo$val1val2 = 41((-val2)) The shorthand operator((val2 +=60)) is used to echo$val2.

echo$val2 the product of dividing 40 by 6 ((val3 =40/6)) echo$val3 To run the script, type the following command into your terminal.

## Example – 4: Using ‘bc’ Command for Float or Double Numbers

‘ expr’or’let’ or double bracketsexpressions are not capable of producing floating-point or double numbers, which is one of the fundamental limitations of the methods described above for doing mathematical operations in bash. The results of the division operations in the preceding instances are all integer values. The’bc’command may be used to address this problem, and it acts as a rudimentary calculator for the Linux operating system, as seen in the following example. In order to learn how to utilize the ‘bac’ command in arithmetic operations, create a bash file namedbc.bash and include the following script in it.

onlyecho”55/3″|bc division by three with bc and the -l optionecho”55/3″|bc-ldivision by three with bc and the scale valueecho”scale=2; 55/3″|bc-ldivision by three with bc and the scale valueecho”scale=2; 55/3″ To run the script, type the following command into your terminal.

The’bc -l’command produces the precise result of the division, and you may restrict the fractional part of the output by using the scalevalue parameter.

As a result, the output shows two digits after the decimal point.

## Example-5: Using the printf Command for Float or Double Number

Another option for dealing with fractional data is to use the’printf’ command. Following the arithmetic operation, this command can be used to create the floating-point value more efficiently than the ‘bc’ command, which is a shortcut. This command may also be used to find out what the power of a particular integer is. It has been demonstrated in this example how to utilize the’printf’command for a number of different arithmetic operations. Create a bash file namedprn.bash and include the following script in it to test the usage of the ‘printf’ command for the fractional output of the division of two numbers when the division of two numbers is fractional.

Result: The following output demonstrates that the division value generated by the ‘bc’ and ‘printf’ commands of two integer values is the same as the value generated by the ‘printf’ command.

However, when used in conjunction with the ‘printf’ command, an error is generated.

!/bin/bash Calculate the dividend value using the userread-p function “”n1Take the divisor value from the userread-p” is the value to enter for the dividend.

Output: The output demonstrates that the ‘printf’ command combined with the ‘bc’ command produces the right output.

## Example-6: Using the awk Command for Arithmetic Operation

It is also possible to conduct the arithmetic operation in a way that generates output that is appropriate for floating-point numbers by using the ‘awk’ command. In this example, the arithmetic operations performed with the ‘awk’ command, both without and with formatting, have been demonstrated. Prepare the following script in a bash file namedawk.bash, then place it in awk.bash to test the usage of the ‘awk’ command for arithmetic operations. !/bin/bash Set the dividend valuen1 to 90 to begin with.

Print the output without formattingawk”BEGIN”Print the output with formattingawk”BEGIN”Print the output without formattingawk”BEGIN”Print the output with formattingawk”BEGIN” To run the script, type the following command into your terminal.

## Example-7: Calculate the Percentage of a Value

It is possible to conduct the arithmetic operation in a way that generates output that is appropriate for floating-point values by using the ‘awk’ command as well. It has been demonstrated in this example that the arithmetic operations may be performed using the ‘awk’ command both without and with formating. The following script should be placed in the root directory of the awk.bash bash file to test the usage of the awk function to do mathematical operations. Create an awk.bash bash file that contains the following script to test the use of the awk function for mathematical operations.

To begin, set the divisor’s valuen2 = 43 to its initial value.

Output: The result demonstrates that the ‘awk’ command is capable of producing fractional output that is acceptable for its purpose.

## Conclusion

This tutorial demonstrates the usage of several arithmetic operators in bash, as well as the many ways to conduct arithmetic operations using various commands, in order to assist bash users. A number of examples are provided to assist the bash users.

I am a web programming course instructor that specializes in web development. I like writing articles or tutorials on a variety of information technology issues. I have a YouTube channel where I post a variety of videos on various topics such as Ubuntu, Windows, Word, Excel, WordPress, Magento, Laravel, and other technologies: Help from Tutorials4u.

## Unix / Linux – Shell Arithmetic Operators Example

Bourne Shell is capable of supporting the arithmetic operators listed below. If we assume that variablea holds 10 and variableb holds 20, we have

Operator | Description | Example |
---|---|---|

+ (Addition) | Adds values on either side of the operator | `expr $a + $b` will give 30 |

– (Subtraction) | Subtracts right hand operand from left hand operand | `expr $a – $b` will give -10 |

* (Multiplication) | Multiplies values on either side of the operator | `expr $a * $b` will give 200 |

/ (Division) | Divides left hand operand by right hand operand | `expr $b / $a` will give 2 |

% (Modulus) | Divides left hand operand by right hand operand and returns remainder | `expr $b % $a` will give 0 |

= (Assignment) | Assigns right operand in left operand | a = $b would assign value of b into a |

= (Equality) | Compares two numbers, if both are same then returns true. | would return false. |

!= (Not Equality) | Compares two numbers, if both are different then returns true. | would return true. |

It is critical to understand that all conditional expressions should be enclosed in square braces with spaces between them.

For example, the conditional expression is correct whereas the conditional expression is wrong. Each and every one of the arithmetical calculations is performed using long integers.

## Example

The following code demonstrates how to utilize each arithmetic operator:!/bin/sha=10 b=20val=’expr $a + $b’ echo “a + b: $val”val=’expr $a – $b’ echo “a – b: $val”val=’expr $a * $b’ echo “a * b: $val”val=’expr $b / $a’ echo “b if an is not equal to b, then echo “a is not equal to b” According to the given script, the following result will be obtained: a + B: 30 a – B: 30 -10 a * b: 200 b / a: 2 b percent a: 0 a and b are not equal.

-10 a * b: 200 b / a: 2 b percent a: 0 a and b are not equal.

- There must be a gap between the operators and the expressions in order for them to work correctly. For example, the expression 2+2 is incorrect
- It should be expressed as 2 + 2 instead. The complete expression should be surrounded between’ ‘, which are referred to as inverted commas. If you want to multiply two numbers, you should use the on the symbol
- Otherwise, use if.then. fistatement is a decision-making statement that will be explored in further detail in the next chapter

Unix-basic-operators.htm

## Useful Video Courses

preceding vs. preceding In this section, we will learn how to use the arithmetic operators in the Bash programming language. Based on the sort of outcome we want to achieve through our scripts, we may need to use arithmetic operators at some point along the process. They are similar to variables in that they are quite simple to use. We may use the bash script to conduct mathematical operations on numeric numbers in order to obtain the desired outcome. Bash Shell supports a total of 11 arithmetic operators, all of which are listed below.

Operator | Description | Examples |
---|---|---|

+ | Addition, measures addition of numbers (operands) | $((10 + 3)), result=13 |

– | Substraction, measures subtraction of second operand from first | $((10 – 3)), result=7 |

* | Multiplication, measures the multiplication of operands. | $((10 * 3)), result=30 |

/ | Division, measures the division of first operand by second operand and and return quotient. | $((10 / 3)), result=3 |

** | Exponentiation, measures the result of second operand raised to the power of first operand. | $((10 ** 3)), result=1000 |

% | Modulo, measures remainder when the first operand is divided by second operand. | $((10 % 3)), result=1 |

+= | Increment Variable by Constant- used to increment the value of first operand by the constant provided. | x=10 let “x += 3” echo $x result=13 |

-= | Decrement Variable by Constant- used to decrement the value of first operand by the constant provided. | x=10 let “x -= 3” echo $x result=7 |

*= | Multiply Variable by Constant- used to multiply the value of the first operand by the constant provided. | x=10 let “x *= 3” echo $x result=30 |

/= | Divide Variable by Constant- used to calculate the value of (variable / constant) and store the result back to variable. | x=10 let “10 /= 3” echo $x result=3 |

%= | Remainder of Dividing Variable by Constant- used to calculate the value of (variable % constant) and store the result back to variable. | x=10 let “10 %= 3” echo $x result=1 |

## Performing Arithmetic Operations in Bash

There are a plethora of options available for doing mathematical operations within the bash shell. The following are some of the alternatives we have for doing arithmetic operations that we can choose from:

### Double Parentheses

The use of double parentheses in the Bash shell is the most straightforward method of doing fundamental arithmetic operations. This approach may be implemented by use double brackets, either with or without a leading $. Syntax In order to obtain the desired results, we might employ four alternative approaches. To further understand how the double parentheses mechanism might be utilized, consider the following examples (which assume that we wish to add the values 10 and 3): Method Methods 1 and 2 and 3 and 4 are described below.

A Bash shell script script that demonstrates the usage of double parentheses for arithmetic operations is shown below in the following example: Output from a Bash script

### Let Construction

In Bash, the command let is used to do arithmetic operations, and it is part of the standard library. It follows the following fundamental structure: Syntax A brief explanation of how to utilize the let command in a Bash script is provided in the following example: Output from a bash script

### Backticks

An arithmetic expansion may also be accomplished in bash scripting by using the backticks and expr variables (known as all-purpose expression evaluator). The ‘expr’ function is identical to the ‘let’ function, except that it does not store the result to a variable. It prints the result in its entirety. In contrast to let, we do not need to surround the expression between quotation marks. Spaces must be used between the components of the phrase, as required by the rules. Please keep in mind that we should use the ‘expr’ command substitution to store the result to a variable within the command substitution.

It is also possible to use ‘expr’ without the usage of ‘backticks’. Syntax In order to demonstrate how to utilize backticks and expr in a Bash script, the following example is provided: Program Output from a Bash Script

## Conclusion

The purpose of this topic was to discuss how to conduct arithmetic operations with the help of arithmetic operators. Next TopicBash If StatementPreviousnext TopicBash If Statement

## Bash Script – Arithmetic Operators

In this post, we will look at the arithmetic operators available in the bash scripting language. It is necessary to utilize arithmetic operators in order to conduct arithmetic operations. The arithmetic operators of the Bash script number 11 in total. All of the operators, as well as their applications, are listed below:

Operator | Name | Use | Example |
---|---|---|---|

+ | Addition | It adds two operands | result= a+b |

– | Subtraction | It subtract second operand from first one | result= a-b |

* | Multiplication | Multiply two operands | result= a*b |

/ | Division | Return the quotient after diving first operand from second operands | 16/3result = 5 |

% | Modulo | Return remainder after dividing first operand from second operand | 16/ 3result = 1 |

+= | Increment by constant | Increment value of first operand with given constant value | x= 13x+=3result = 16 |

-= | Decrement by constant | Decrement value of first operand with given constant value | x= 13x -= 3result = 10 |

*= | Multiply by constant | Multiply the given operand with the constant value | x= 10x*=3result = 30 |

/= | Divide by constant | Divide the operand with given constant value and return the quotient | x = 31x/=3result = 10 |

%= | Remainder by dividing with constant | Divide the operand with given constant value and return the remainder | x= 31x%=3result = 1 |

** | Exponentiation | The result is second operand raised to the power of first operand. | 3**2result = 9 |

Let’s have a look at some instances of how arithmetic operators are used:

### Addition

Using the following code: sum=$((10+3)) echo “sum Equals $Sum”Output:

### Subtraction

Code: difference=$((10-3)) echo “difference = $difference”Output: difference=$((10-3))

### Multiplication

Product=$((10*3)) echo “Product = $Product”Output: Product=$((10*3))

### Division

“Division = $Division” is output using the following code: division=$((10/3)) echo “Division = $Division”

### Modulo

Modulo=$((10 percent 3)) in the code. output: “Modulo = $Modulo” echo “Modulo = $Modulo”

### Exponentiation

Code_Exponent=$((10**2)) “Exponent = $Exponent” is returned by echo. Output: An example demonstrating the use of all of the operators in a single piece of code. x=10, y=20 in the code if x = 10 and y = 5, then x= ” ((x += 10)) if y = ” ((x -= 10)) if $(($x + $y)) if $(($x – $y)) echo “Addition of x and y” if $(($x + $y)) if $($x – $y) if $(($x – $y)) if echo $x echo “If x is decremented by 15, then x= ” ((x -= 15)) echo $x echo “If x is multiplied by 2, then x=” ((x *= 2)) echo $x echo “If x is divided by 5, then x=” ((x /= 5)) echo $x echo “If x is divided by 5, then x=” ((x percent = 5)) echo $xOutput:

## Different ways to compute Arithmetic Operations in Bash

Code_Exponent=$((10**2)) “Exponent equals $Exponent” is returned by echo. An example of how to include all of the operators into a single piece of code is shown in Figure 1. x=10, y=20 in the code: echo “x=10, y=5” echo “Addition of x and y” echo $(($x + $y)) echo “Subtraction of x and y” echo $(($x – $y)) echo “Multiplication of x and y” echo $(($x * $y)) echo “Division of x by y” echo $(($x ** $y)) echo “Modular Division of x,y” echo $ echo $x echo “Decrementing x by 15, then x= ” ((x -= 15)) echo $x echo “Multiplying x by 2, then x=” ((x *= 2)) echo $x echo “Dividing x by 5, then x=” ((x /= 5)) echo $x echo “Remainder of Dividing x by 5, then x=” ((x percent = 5)) echo $xOutput: “Decrement

### 1. Double Parenthesis

This might be used for mathematical expansion purposes as well as other things. Let’s have a look at an example to understand how to utilize double quotes. !/bin/bashfirst=10 second=3 is the code. $((first + second)) = $((first + second)) additional echo $((($first + $second)) adverb In addition, this is validecho $((first – second)) arithmetic subtraction echo $(((($first – $second))) This holds true as well. 13 13 7 7 is the output.

### 2. Usinglet command

When doing mathematical operations, the let command is used.

!/bin/bashx=10 y=3 is an example of code. let “z = $((x * y))”multiplication echo $z let z=$((x*y)) echo $zlet “z = $((x / y))”division echo $z let z=$((x*y)) echo $zlet “z = $((x / y))”division echo $z let z=$((x/y)) echo $zlet “z = $(( 30 30 3 3 is the output.

### 3. expr command with backticks

The use of backticks and expr might be used to do arithmetic expansion. Code: a=10, b=3, etc. There must be a gap between the operator and the next word. add $a and $b together to make a total $sumsub=’expr $a – $b’ echo $sumsub=’expr $a – $b’ echo $submul=’expr $a * $b’ echo $submul=’expr $a * $b’ $muldiv=`expr $a / $b’ echo $a / $b’ $div 13 7 30 3 is the result.

## 5.9. Math in Shell Scripts — Introduction to Unix Study Guide

Due to the fact that shell script variables are by default handled as texts rather than integers, doing math in shell script is a little more complicated. When it comes to arithmetic, scripting languages such as Perl or Python would be more suited because they adhere to the scripting paradigm and provide greater math functionality. Shell scripts, on the other hand, may be used to do mathematical operations. In reality, several capabilities for dealing with numbers have been introduced to Unix throughout the years as a result of this evolution.

## 5.9.1.declare¶

You may recall that when the declaration statement was first presented in the text book, it was stated that it was not always required. So, what exactly do you get when you declare a variable to be an integer? The following example demonstrates that an integer that has been declared is not handled as a string. $ n=6/3 $ echo $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n Declare -i n in $n 6/3 $ declare -i $ n=6/3 $ echo $n 2 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 $ n=6/3 You will not require thedeclarestatement when evaluating a math statement through the usage of a program or built-in command, for example.

## 5.9.2.expr¶

Isexpr.expr is an ancient Unix program that can evaluate math equations. It was popular during the time of the Bourne Shell, which did not support math equations. In most cases, Bash and Korn shell do not require it to function properly. Due to the fact that it is a command, command substitution is required. The variable is still being treated as if it were a string. As you can see, it very particular about where it is placed. $ z=5 z=5 z=5 “expr $z+1” = “$ z=’expr $z+1′” – There should be some space surrounding + a symbol.

## 5.9.3.let¶

For math islet, there is a built-in command in both Bash and Korn shells. According to what you can see, it is also a bit particular about space, but it prefers the exact opposite of what was desired. let also deviates from the standard guideline of placing a $ in front of variables that are to be read. $ set z to 5 echo “$ echo ” “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo “$ echo $z 5 is a monetary value.

If you want to read a variable, use $let z=z+1- look Mom, no $ to read a variable. $echo $z 7 $echo $z 7 $echo $z 7 $echo $z 7 $echo $z 7 $echo $z 7 $echo $z 7 $echo $z 7

## 5.9.4. BASH Arithmetic ¶

When using the BASH shell, it is possible to insert whole mathematical expressions within double parentheses. This form is more tolerant when it comes to empty spaces. $ ((e=5)) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e=5) $ ((e $ echo $e 5 $ ((e = e + 3)) $ ((e = e + 3)) $ echo $e 5 $ ((e = e + 3)) $ echo $e 8 $ ((e=e+4)) $ ((e=e+4)) $ ((e=e+4)) $ ((e=e+4)) $ ((e=e+4)) $ ((e=e+4)) $ ((e=e+4)) $ ((e=e+4)) $ ((e=e+4)) $ ((e=e+4)) $ ((e=e+4)) $ ((e=e+4)) – Whether there are spaces or not, it makes no difference.

echo $e 12 $e echo $e 12 $e echo $e 12 $e echo $e 12

Arithmetic Operators¶+- | Addition, subtration |

++- | Increment, decrement |

*/% | Multiplication, division, remainder |

** | Exponentiation |

Double parenthesis are also used to express numerical boolean expressions in Control Constructs.if((xy));thenecho”xy”fi;if((xy));thenecho”xy”fi

Logical and Boolean Operators¶= | Less than or equal, greater than or equal, less than, greater than |

=!= | Equal, not equal |

! | Logical NOT |

Logical AND | |

|| | Logical OR |

## 5.9.5.bc¶

If you want to conduct arithmetic using floating point numbers, or if you have some very hard math to accomplish, what should you do in such case? Neither of the let expressions is compatible with floating point numbers. It is necessary to use the bc command. However, you must consider the variables as if they were strings. When we attempt to perform floating point math using the shell, the following results are obtained: $assume r=3.5 —bash: let: syntax error in expression at r=3.5 (error token is “.5”) $((r = 3.5)) $((r = 3.5)) The following problem occurred in the phrase ((: r = 3.5: syntax error in expression): (error token is “.5 “) bc A calculator programming language with arbitrary precision.

- To quit interactive mode, press the key combination cntrl-d (EOF).
- Copyright 1991-1994, 1997, 1998, 2000 This is completely free software that comes with ABSOLUTELY NO WARRANTY.
- 3 + 2 5 obase=2 12 1100cntrl-d 3 + 2 5 obase=2 12 1100cntrl-d Remember to press the key combination cntrl-d (EOF) to leave interactive mode.
- bc’ $s=’echo “$r + 2.2” |
- bc’ $z + 1 |
- bc’ $ z=’echo “$z + 1” |
- bc’- spaces are not important when using bc.

## 5.9.6. Numeric Boolean expressions ¶

If the BASH double parentheses are not used, thetestcommand must be used to compare integer variables if they are not already. Seetest. When INTEGER1 -eq INTEGER2INTEGER1 is used, it is equivalent to INTEGER2INTEGER1 -ge. In this case, INTEGER2INTEGER1 -gt is larger than or equal to the value of INTEGER2INTEGER1 -gt. When INTEGER2INTEGER1 is more than INTEGER2INTEGER1 -le, INTEGER2INTEGER1 is less than or equal to INTEGER2INTEGER1 -lt, and when INTEGER2INTEGER1 is less than INTEGER2INTEGER1, INTEGER2INTEGER1 is less than or equal to INTEGER2INTEGER1.

The following twoifstatements are identical, which means that they are equivalent: Statements fiif; then statements if ((xy)); otherwise statements fiif Because thebccommand returns 1 for valid logical expressions and 0 for false logical expressions when dealing with floating point math, testing for a result of 1 results in the logical expression:if; then statements.

## Arithmetic – Bash Scripting Tutorial

It all adds up in the end.

## Introduction

Depending on the sort of job you want your scripts to perform, you may find yourself utilizing a lot of math or very little at all. The fact remains, though, that you will need to apply math at some time in your life. They are similar to variables in that they are quite simple to construct, and understanding how to do so is a crucial skill in mastering Bash scripting. In Bash scripting, there are a variety of approaches to performing arithmetic. We’ll go through them in detail for the sake of thoroughness, but the recommended method is arithmetic expansion (covered last).

## Let

Letis a Bash built-in function that allows us to do simple arithmetic operations. It follows the following fundamental structure: expression of letarithmetic logic The arithmetic expression may be expressed in a variety of ways, which we’ll go through in more detail below. The first portion is almost often a variable into which the result is stored, however this is not always the case. Consider the following straightforward illustration:

#### let_example.sh

- !/bin/bash
- Let a=5+4
- Echo $a
- Let “a = 5 + 4”
- Let a++
- Let “a = 4 * 5”
- Let “a = $1 + 30”
- Let “a = 5 +

Let’s take it step by step:

- Line 4: This is the most basic of the formats. It is important to note that if we do not use quotation marks around the expression, it must be written without spaces
- Line 7- We’ve utilized quotation marks this time, which allows us to break out the statement and make it more understandable
- Line 10: This is a shortcut way of saying that the value of the variable a should be increased by one. It is the same as writing “a = a + 1” in the same way. Line 16- We have the option of including more variables in the expression.

Here is a table that contains some of the most fundamental phrases that you may use. There are more, but these are the ones that are most frequently encountered.

Operator | Operation |
---|---|

+, -, *, / | addition, subtraction, multiply, divide |

var++ | Increase the variable var by 1 |

var- | Decrease the variable var by 1 |

% | Modulus (Return the remainder after division) |

These operators can also be utilized in the other processes that are detailed further down this page.

## Expr

It is identical to let, except that instead of saving the result to a variable, it instead publishes the answer to the screen. Unlikelet, there is no need to surround the expression with quotation marks. You must also include spaces between each of the things in the phrase. The use of the exprwithin command substitution to save the output in a variable is also frequent in programming. item1 operator item2 expr item1 item2 Consider the following straightforward illustration:

#### expr_example.sh

- The command:!/bin/bash
- Expr 5+4
- Expr “5+4”
- The command: the command: the command: the command: the command: the command: the command: the command: the command: the command: the command: the command: the command: the command: the command: the command:

Let’s take it step by step:

- Line 4: This is the most basic of the formats. Remember that there must be spaces between the elements and that there are no quotation marks. Line 6- If we do not place quotation marks around the expression, the phrase will not be evaluated but will instead be printed
- If we do not put quotation marks around the expression It is important to note that if we do not include any spaces between the parts of the expression, then the expression will not be evaluated, but will instead be printed. Because some characters have particular significance to Bash, we must escape them (by placing a backslash in front of them) in order to eliminate their significance
- Line 10- Line 12: This line demonstrates the operatormodulus concept. It is the remainder left after dividing the first item by the second item that is the modulus
- Using expr within command substitution to store the output to the variablea is what we’re doing here in line 14.

## Double Parentheses

The section on Variables demonstrated how to simply store the output of a command to an array of variables in a command. It turns out that, with a little tweaking of the syntax, this technique is also capable of performing fundamental arithmetic for us. This is accomplished by the use of double brackets, as follows: $((expression)) Here’s an illustration of what I mean:

#### expansion_example.sh

- #!/bin/bash
- A=$((4)+5)
- Echo $a
- A=$((3)+5))
- B=$((a + 3))
- Echo $b
- B=$((4 + 4))
- (((b++))
- ((b += 3))
- A=$((4)+5))
- A=$((3+5))
- Echo $

Let’s take it step by step:

- Line 4: This is the most basic of the formats. In this case, you can see that we can easily space it out well for reading without the need of quotations. Line 7- As you can see, it functions exactly the same way if the space is removed
- Line 10: We can include variables without using the $ symbol in front of them. Line 13- If you like, variables can be inserted after the dollar symbol ($). Line 16: This is a somewhat different variant of the previous line. In this case, the value of the variable b is increased by one (using the same mechanism illustrated underlet). When we do this, we don’t require the $ sign to precede the brackets
- Instead, we only need the brackets themselves. Unlike the last example, this one takes on a somewhat different shape in line 19. In this case, the value of the variable b is increased by three. It is a shorthand for the expression forb = b + 3
- Line 19- Unlike previous approaches, we do not need to escape the*sign while doing multiplication.

As you can see, the double parenthese allows you to be extremely creative with how you arrange your statement. This is one of the reasons why we choose to use this strategy. Due to the fact that double parentheses are built into Bash, it also runs a little more efficiently (though to be honest, with the raw computing power of machines these days the difference in performance is really insignificant).

## Length of a Variable

Although this isn’t strictly arithmetic, it may be rather beneficial in some situations. If you wish to get the length of a variable (how many characters it contains), you may use the following formula: $ Here’s an illustration:

#### length_example.sh

Allow expression to flow. Make a variable equal to an expression by using the equal sign. expr is an abbreviation for expression. the result of the expression should be printed out ‘$((expression))’ will return a value representing the outcome of the expression. $ The length of the variable var should be returned.

ArithmeticIn Bash scripts, there are a number of different ways to do arithmetic operations. The use of double parentheses is the recommended way. Formatting When doing math, the presence or absence of spaces (as well as quotation marks) is frequently critical.

## Activities

Let’s start with some basic math.

- Design and implement a small script that will accept two command-line inputs and then multiply them together using each of the methods described above
- Create a Bash script that prints the date for the following day. (Hint: use the commanddate to accomplish this.) Remember how, when we looked at variables, we learned that $RANDOM would return a randomly generated number? This number is in the range of 0 to 32767, which is not necessarily the most practical range to utilize. Now, let’s construct a script that will make use of this variable and some arithmetic (hint: experiment with modulus) to generate a random integer between zero and one hundred. Let’s have a look at the previous script again. Make it such that you may define the top limit of the random number as a command-line option instead of having to guess. Is it possible to make it such that a lower limit may also be specified? It would only produce random numbers between 10 and 45 if I ran./random.sh 10 45, for example,

## How to use arithmetic operations in bash

Dan Nanni’s blog was last modified on February 24, 2021. When building a bash script, it is possible that you may need to quickly crunch numbers within the script. Examples include converting a unit of data you are dealing with, rounding a divided value to the closest integer, incrementing a counter in a basic loop, and so forth. Almost every programming language includes built-in support for fundamental arithmetic operations against a wide range of data types. Nevertheless, because bash is not a general-purpose programming language, but rather a command-line interpreter, it has very limited support for arithmetic operations by default.

## Limitation of Bash for Arithmetic Operations

Bash variables are not strongly typed in the way that other programming languages are. In most cases, unless otherwise defined withdeclare, bash variables are character strings by default. In order to facilitate arithmetic operations on string variables, bash treats variables as integers if the execution environment specifies that they should be treated as such. Though you are using arithmetic or comparison operators to variables that contain only digits, bash will handle the variables as if they are integers without any further action on your part.

In contrast, because bash does not natively handle floating point calculations, you will have to rely on other programs such as GNU bc to do floating point operations.

## Method One: Arithmetic Evaluation in Bash

In spite of the fact that there are several ways to execute integer arithmetic in bash, it is advised that you utilize bash’s built-in mechanism rather than depending on any extra command to ensure that your script is portable. Arithmetic evaluation is the name given to Bash’s built-in support for integer arithmetic. For the most part, if you wish to execute integer arithmetic using arithmetic evaluation, all you have to do is surround an arithmetic expression with double parentheses, as seen in the following example.

((arithmetic-expression)) In this section, you will find examples of how to represent integer arithmetic using arithmetic evaluation in the bash programming language.

a=100 b=”3″((sum = a + b))(((sum = a + b)) ((sub = a – b)) is an addition formula.

((mod = a percent b)) is the division formula.

the sum is 103, the sub is 97, the mul is 300, the div is 33, the mod is 1, and the exp is 1000000 Take note that, because bash does not allow the floating point data type, division of two variables will always generate an integer result by truncating the result toward zero when done with two variables.

a=100 ((a++)) ((a++)) “a = $a” is returned by echo.

(1 + b * 100, 2 * 100 + b * 2)) (1 + b * 100, 2 + 100 + b * 2)) If you attempt to utilize floating point numbers in arithmetic evaluation, you will receive the error “syntax error: incorrect arithmetic operator.”

## Method Two: Arithmetic Expansion in Bash

Isarithmetic expansion is a built-in technique for integer arithmetic in bash that is slightly different from the previous mechanism. It is possible to assign the output of the arithmetic expression to another variable in this circumstance since it substitutes for the expression itself. $((arithmetic-expression)) a=100 the total of (a + b) is equal to the value of b=”3″ inequalities are subtracted from the sum of the two terms.

## Method Three: Built-inletCommand

Another option for performing integer arithmetic natively in bash is to make advantage of a built-in command calledlet, which can evaluate an arithmetic expression that is passed to it. a=”100″ and b=”3″ If we assume sum=a+b, there should be no space before or after the assignment. allow sub=a-b to be true Let mod=a percent b be the case. Let mod=a percent b be the case. A singleletstatement can be used to do many arithmetic operations at the same time. Both of these assertions are true. Let ‘tmp=a’ ‘a=b+1’ ‘b=tmp+1’ Let ‘tmp=a, a=b+1, b=tmp+1’ Let ‘tmp=a, a=b+1, b=tmp+1’ Let ‘tmp=a, a=b+1, b=tmp+1’ Let ‘tmp=a, a=b+1, b=tmp+1’

## Method Four:exprCommand

With the help of theexprcommand, you may conduct integer calculations in bash as well. The expris command, in contrast tolet, which is a built-in command in bash, is an external command line utility that may evaluate an integer expression. Because it is a component of the GNU Coreutils, including exprin in your script has no effect on the script’s portability. There must be a gap before and after the operator in a=100 b=”3″ sum=’expr $a + $b’ sub=’expr $a – $b’ mul=’expr $a * $b’ div=’expr $a / $b’ mod=’expr $a percent $b’ sum=’expr $a + $b’ sub=’expr $a percent $b’ Expra supports the arithmetic operations addition (+), subtraction (-), multiplication (*), division (/), and modulo ( percent ).

## Method Five:bcCommand (for Floating Point Arithmetic)

It should be noted that, as previously stated, bash does not natively support floating point arithmetic. If your bash script necessitates the use of floating point arithmetic, one method of getting past the bash’s constraint is to use an external program that is capable of dealing with floating point arithmetic. GNU bc is an example of such a tool. Because thebccommand is required by all contemporary Linux distributions unless you are working in a basic container environment, it should be pre-installed on all recent Linux distributions.

- You must useecho to send floating point numbers tobc.a=12.5 and b=5.8 are examples of such numbers.
- $a + $b |
- bc’ div=’echo “scale=2; $a / $b” |
- bc’echo “sum: $sum, mul: $mul, div: $div” Changing the value of an unique variable calledscale allows you to change the accuracy of floating point values in bc.

In the following floating point division, for example, two decimal digits will be included after the decimal point in the output. the following: div=”echo “scale=2; $a / $b” | bc” In the following example, the output of the sample script appears: sum: 18.3, multiplier: 72.5, and division: 2.15

### If you find this tutorial helpful, I recommend you check out theseries ofbashshell scripting tutorialsprovided by Xmodulo.

Let’s get to work on some Bash Math! In the course of writing your bash scripts, you will frequently find yourself needing to figure out the result of an arithmetic calculation in order to determine the amount of disk space left on your computer, file sizes, password expiration dates, the number of hosts connected to your network, and so on. Using the bash operators to carry out different arithmetic operations will be covered in this chapter of the bash beginning series, so pay attention! The following are the arithmetic operators in bash, just to refresh your memory:

Operator | Description |
---|---|

+ | Addition |

– | Substraction |

* | Multiplication |

/ | Integer division (without decimal numbers) |

% | Modulus division (gives only remainder) |

** | exponentiation (x to the power y) |

## Performing addition and subtraction in bash scripts

Consider the following example of a bash script: addition. Simply adding two file sizes (in bytes) and printing the result is all that is required. By now, you should be aware with the parameters used in bash scripts. The cut and du commands, I’m sure you’re aware of, are likewise known to you. The du command displays the size of the file while it is being processed. Both the file size and the file name are included in the result. Cutting off the first column (the file size) from the output is accomplished by using the cut command in this case.

- The script is as follows: !/bin/bashfs1= $(du -b $1 |
- cut -f1) The expression fs2=$(du -b $2 |
- The file size of $1 is $fs1.
- total=$((($fs1 + $fs2)) plus $fs1 + $fs2.
- I will use the following example to demonstrate how to run a script with the two inputs: files/etc/passwd and/etc/group as examples of arguments: ~/scripts /etc/passwd /etc/group $./addition.sh /etc/passwd /etc/group The file /etc/passwd has a size of 2795 bytes.
- The whole size is 3860 pixels.
- The shscript is as follows: total=$((($fs1 + $fs2)) Where you used the + operator to combine the two numbers $fs1 and $fs2 into a single number.
- For instance: $((arithmetic-expression)) Subtraction can also be accomplished by the use of the negative operator (-).

## Performing multiplication and division in bash scripts

As an example, consider the following bash script: giga2mega.sh, which will convert Gigabytes (GB) to Megabytes (MB). !/bin/bash The unit of measure for megabytes is gigabytes ($1 MEGA=$((($GIGA * 1024))) echo “$GIGA GB is identical to $MEGA MB” echo “$GIGA GB is equal to $MEGA MB” To find out how many Megabytes are included within four Gigabytes, let’s execute the script as follows: ~/scripts $./giga2mega.sh 4 4 GB is equal to 4096 MB in computer memory. When I needed to convert Gigabytes to Megabytes, I simply multiplied the amount of Gigabytes by 1024 using the multiplication (*) operator.

The following code may be easily modified in order to provide more functionality to this script to convert Gigabytes (GB) to Kilobytes (KB): KILO=$((($GIGA * 1024 * 1024))$(($GIGA * 1024 * 1024)$(($GIGA * 1024 * 1024)$(($GIGA * 1024 * 1024)$(($GIGA * 1024 * 1024)$(($GIGA * 1024 * 1024)$(($GIGA * 1024 * 1024)$(($GIGA * 1024 * 1024)$(( As a practice exercise, I’ll let you to convert Gigabytes to bytes for you.

In addition, you may divide two integers by utilizing the division operator (/).

Keep in mind that this is integer division, which means that any fractions are lost.

As an example, you can use thebccommand to divide 5 by 2 by using the following statement: echo “5/2” |

## Using power and remainder (modulo)

Let’s make a power calculator together! A script named power.shwill be written that will receive two numbersa and b (as parameters) and will display the result ofara raised to the power of b: the result of!/bin/bash is $((a**b)) a=$1 and $(b) result=$(a**b) echo “$1$2=$result” echo “$1$2=$result” It is important to note that I am using the exponentiation operator (**) to determine the result ofara raised to the power ofb in this example.

Let’s run the script a couple of times to make sure it produces the proper results: ~/scripts$./power.sh 2 3 2 3=8:/scripts$./power.sh 2 3 2 3 2 3=8 /scripts$./power.sh 3 2 3 2=9:/scripts$./power.sh 5 2 5 2=25:/scripts$./power.sh:/scripts$./power.sh:/scripts$./power.sh:/scripts$./power.sh:/scripts$./power.sh:/scripts$./power.sh:/scripts$./power.sh:/scripts$./power.sh:/scripts$./power.sh:/scripts$./power 4 2 4 2=16 4 2 4 2=16 When calculating integer remainders, you may also make use of the modulo operator (percent).

For example, the value of the theremvariable in the following expression will evaluate to 2 when evaluated as follows: the value of rem equals ($((17 percent of 5)) The leftover in this case is 2 since 5 is divided by 17 three times and only two remains!

## Practice Time: Make a Degree Converter bash script

Finalize this instruction by writing a script namedc2f.sh that will convert Celsius degrees to Fahrenheit degrees using the equation shown below. F is equal to C x (9/5) + 32. This will serve as an excellent exercise for you to put into practice the new skills you have gained from this bash lesson. Here’s an example of a solution (there might be multiple other approaches to get the same result): !/bin/bashC= $1 F=$(echo “scale=2; $C * (9/5) + 32” | bc -l)echo “$C degrees Celsius is equivalent to $F degrees Fahrenheit.” $C degrees Celsius is equal to $F degrees Fahrenheit.

Let’s run the script a couple of times to make sure it’s producing the desired results: ~/scripts $./c2f.sh 35.60 degrees Fahrenheit is equal to 2 degrees Celsius: ~/scripts 3 degrees Celsius is equivalent to 26.60 degrees Fahrenheit.: $./c2f.sh -3 degrees Celsius is equal to 26.60 degrees Fahrenheit.

Perfect!

Download the bash exercise set from this chapter and put what you’ve learned into practice.

Bash Beginner Series6: String Operations in BashLet’s pluck a few strings and learn how to handle strings in bash scripts in this installment of the Bash Beginner Series.

## Shell Programming – Arithmetic Operators – Unix – DYclassroom

In this article, we will go through Arithmetic Operators in Shell Programming and how to use them.

In this tutorial, we’ll go through the math operations listed below in more detail.

- The operations are as follows: addition +, subtraction -, multiplication *, division /, modulus percent to obtain the residual

## expr command

In shell script, all variables have a string value, regardless of whether they are numbers or not. As a result, theexprcommand is used to do arithmetic operations. Theexprcommand can only be used with integer values, and it is not recommended. Thebccommand is used to represent floating point numbers. For the purpose of computing the result, we encapsulate the phrase in backticks’

## Addition

In order to do addition, we employ the+symbol. This example involves accepting two integer values from the user and displaying the result once they have been added. !/bin/shtake two integers from the user echo “Enter two numbers: ” read a bperform addition result=’expr $a + $b’show result echo “Result: $result” read a bperform addition result=’expr $a + $b’show result echo “Result: $result” The expression ‘expr $a + $b’ in the above script indicates that we are adding the values contained in variablea andband evaluating the expression using theexprcommand.

- $ sh add.sh is the output.
- !/bin/sh grab two numbers from the user and echo them back “Enter two numbers: ” read a bperform addition result=’expr “$a + $b” |
- bc’show result echo ” $result is the outcome.” $ sh add2.sh is the output.
- The final score was 4.6.

## Subtraction

The-symbol is used to conduct subtraction operations. Using the following example, we will subtract two integers entered by the user and display the result. !/bin/sh two digits taken from the user’s echo “Enter the following two numbers: ” read a bcompute subtraction result result=’expr “$a – $b” | bc’print output echo “Result: $result” read a bcompute subtraction result result=’expr “$a – $b”” $ sh subtract.sh is the output. Enter the following two numbers: 9 10 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 1$ sh subtract.sh is the result.

Enter two numbers: 10.5 9.1 resulting in a result of 1.4

## Multiplication

The*symbol is used to execute multiplication operations. To demonstrate this, we shall multiply two integers in the following example. !/bin/shtakes two numbers from the user’s echo command “Enter the following two numbers: ” read a bcompute multiplication result result=’expr “$a * $b” | bc’print output echo “Result: $result” read a bcompute multiplication result result=’expr “$a * $b” | bc” $ sh multiplication.sh is the output. Enter the following two numbers: 2 3 Result: 6$ sh multiplication.sh multiplication.sh Enter the following two numbers: -2 3 Result: -6$ sh multiplication.sh sh multiplication.sh Enter the following two numbers: 6.0 as a result of 1.54

## Division

The/symbol is used to execute division operations. As an illustration, we shall split two integers in the following example. !/bin/sh two digits taken from the user’s echo “Enter the following two numbers: result=’expr “$a / $b” read a b compute division result result=’expr “$a / $b” read a b “| bc -l’print output echo | bc -l’print output echo “The outcome is $result.” $ sh division.sh is the output. Enter the following two numbers: 4 2$ sh division.sh as a result of 2$ sh division.sh Enter two digits: 5 and 6.

## Modulus

The percent sign is used to execute modulus operations on a number. In the next example, we will divide two integers in order to find the remaining fraction. !/bin/sh two digits taken from the user’s echo “Enter the following two numbers: print output echo “Result: $a percent $b” print output echo “$a percent $b” print output echo “Result: $a percent $b” print output echo “$a percent $b” print output echo ” “Results are denoted by the symbol $result.” The following is the output:$ sh modulus.sh Enter two digits: 5 and 6.

1.1 as a result of the second result

## JavaScript Arithmetic

Arithmetic operators are used to execute arithmetic operations on integers (literals or variables).

Operator | Description |
---|---|

+ | Addition |

– | Subtraction |

* | Multiplication |

** | Exponentiation (ES2016) |

/ | Division |

% | Modulus (Remainder) |

++ | Increment |

– | Decrement |

## Arithmetic Operations

A common arithmetic operation involves the manipulation of two integers. The following two numbers are literals: Alternatively, variables or expressions:

## Operators and Operands

The numbers involved in an arithmetic operation are referred to as operands. Anoperator specifies the operation (to be done between the two operands) that will be executed.

## Adding

Themodulusoperator (percent) returns the remainder of a division operation. Division of two numbers creates a quotient and a remainder in arithmetic when two integers are divided. It is the outcome of a modulo operation in mathematics that is the remainder of an arithmetic division.

## Incrementing

The exponentiationoperator (**) elevates the first operand to the power of the second operand. It is used to multiply two numbers together. the function x ** y yields the same result as Math.pow(x,y):

## Operator Precedence

The sequence in which operations are performed in an arithmetic statement is described by the concept of operator precedence. If we multiply 150 by three, do we get the same answer as if we multiply 100 by three? Is it better to start with the addition or the multiplication? For the same reason as in conventional classroom mathematics, the multiplication step is completed first. The operations of multiplication (*) and division (/) take precedence over the operations of addition (+) and subtraction (/).

Furthermore, using parenthesis, the precedence may be adjusted (just like in school mathematics): When parentheses are used, the operations included within the parenthesis are calculated first.

## JavaScript Operator Precedence Values

The presence of pale red items implies that ECMAScript 2015 (ES6) or above is being used.

Value | Operator | Description | Example |
---|---|---|---|

21 | () | Expression grouping | (3 + 4) |

20 | . | Member | person.name |

20 | Member | person | |

20 | () | Function call | myFunction() |

20 | new | Create | new Date() |

18 | ++ | Postfix Increment | i++ |

18 | – | Postfix Decrement | i- |

17 | ++ | Prefix Increment | ++i |

17 | – | Prefix Decrement | -i |

17 | ! | Logical not | !(x=y) |

17 | typeof | Type | typeof x |

16 | ** | Exponentiation (ES2016) | 10 ** 2 |

15 | * | Multiplication | 10 * 5 |

15 | / | Division | 10 / 5 |

15 | % | Division Remainder | 10 % 5 |

14 | + | Addition | 10 + 5 |

14 | – | Subtraction | 10 – 5 |

13 | Shift left | x2 | |

13 | Shift right | x2 | |

13 | Shift right (unsigned) | x2 | |

12 | Less than | xy | |

12 | = | Less than or equal | x= y |

12 | Greater than | xy | |

12 | = | Greater than or equal | x= y |

12 | in | Property in Object | “PI” in Math |

12 | instanceof | Instance of Object | instanceof Array |

11 | = | Equal | x = y |

11 | = | Strict equal | x = y |

11 | != | Unequal | x!= y |

11 | != | Strict unequal | x!= y |

10 | Bitwise AND | xy | |

9 | ^ | Bitwise XOR | x ^ y |

8 | | | Bitwise OR | x | y |

7 | Logical AND | xy | |

6 | || | Logical OR | x || y |

5 | ? | Nullish Coalescing | x? y |

4 | ?: | Condition | ? “Yes”: “No” |

3 | += | Assignment | x += y |

3 | /= | Assignment | x /= y |

3 | -= | Assignment | x -= y |

3 | *= | Assignment | x *= y |

3 | %= | Assignment | x %= y |

3 | = | Assignment | x= y |

3 | = | Assignment | x= y |

3 | = | Assignment | x= y |

3 | = | Assignment | x= y |

3 | ^= | Assignment | x ^= y |

3 | |= | Assignment | x |= y |

2 | yield | Pause Function | yield x |

1 | , | Comma | 5, 6 |

Before the value is used in the remainder of the expression, expressions in parentheses are completely calculated before they are used in the rest of the expression.