linux command

bc

Linux Command – bc เป็นภาษา programming ที่ใช้การคำนวณตัวเลข ด้วยสูตรทางคณิตศาสตร์

 

คำสั่ง

 

1. ทำงานผ่าน bc prompt

$ bc
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'. 
1+1
2
2*2
4
10/3
3

 

2. ป้อนข้อมูลผ่าน command line statement

$ echo '1+1' |bc
2

 

3. กำหนดจำนวนทศนิยมผ่าน scale

echo 'scale=3; (2.777 - 1.4744)/1' | bc 
1.302

 

โครงสร้างคำสั่ง

bc [ -hlwsqv ] [long-options] [  file ... ]

 

รายละเอียด

เป็นภาษา programming ที่สามารถคำนวณตัวเลขและสูตรทางคณิตศาสตร์ โดยมี syntax เช่นเดียวกับภาษา C ทำงานด้วย command line ซึ่งทาง user ต้องกำหนดค่าและวิธีการคำนวณ ก่อนเริ่มประมวลผล โดย bc จะทำการอ่านข้อมูลทั้งหมดในรูปแบบมาตราฐาน และประมวลผลแสดงออกมาเป็น output

 

Option

-h, --help
Print the usage and exit.

-i, --interactive
Force interactive mode.

-l, --mathlib
Define the standard math library.

-w, --warn
Give warnings for extensions to POSIX bc.

-s, --standard
Process exactly the POSIX bc language.

-q, --quiet
Do not print the normal GNU bc welcome.

-v, --version
Print the version number and copyright and quit.

 NUMBERS
 The most basic element in bc is the number. Numbers are arbitrary precision numbers. This precision is both in the integer part and the fractional part. All numbers are repre?
 sented internally in decimal and all computation is done in decimal. (This version truncates results from divide and multiply operations.) There are two attributes of numbers,
 the length and the scale. The length is the total number of significant decimal digits in a number and the scale is the total number of decimal digits after the decimal point.
 For example:
 .000001 has a length of 6 and scale of 6.
 1935.000 has a length of 7 and a scale of 3.

 VARIABLES
 Numbers are stored in two types of variables, simple variables and arrays. Both simple variables and array variables are named. Names begin with a letter followed by any number
 of letters, digits and underscores. All letters must be lower case. (Full alpha-numeric names are an extension. In POSIX bc all names are a single lower case letter.) The type
 of variable is clear by the context because all array variable names will be followed by brackets ([]).

 There are four special variables, scale, ibase, obase, and last. scale defines how some operations use digits after the decimal point. The default value of scale is 0. ibase and
 obase define the conversion base for input and output numbers. The default for both input and output is base 10. last (an extension) is a variable that has the value of the last
 printed number. These will be discussed in further detail where appropriate. All of these variables may have values assigned to them as well as used in expressions.

 COMMENTS
 Comments in bc start with the characters /* and end with the characters */. Comments may start anywhere and appear as a single space in the input. (This causes comments to
 delimit other input items. For example, a comment can not be found in the middle of a variable name.) Comments include any newlines (end of line) between the start and the end of
 the comment.

 To support the use of scripts for bc, a single line comment has been added as an extension. A single line comment starts at a # character and continues to the next end of the
 line. The end of line character is not part of the comment and is processed normally.

 EXPRESSIONS
 The numbers are manipulated by expressions and statements. Since the language was designed to be interactive, statements and expressions are executed as soon as possible. There
 is no "main" program. Instead, code is executed as it is encountered. (Functions, discussed in detail later, are defined when encountered.)

 A simple expression is just a constant. bc converts constants into internal decimal numbers using the current input base, specified by the variable ibase. (There is an exception in
 functions.) The legal values of ibase are 2 through 16. Assigning a value outside this range to ibase will result in a value of 2 or 16. Input numbers may contain the characters
 0–9 and A–F. (Note: They must be capitals. Lower case letters are variable names.) Single digit numbers always have the value of the digit regardless of the value of ibase. (i.e.
 A = 10.) For multi-digit numbers, bc changes all input digits greater or equal to ibase to the value of ibase-1. This makes the number FFF always be the largest 3 digit number of
 the input base.

 Full expressions are similar to many other high level languages. Since there is only one kind of number, there are no rules for mixing types. Instead, there are rules on the
 scale of expressions. Every expression has a scale. This is derived from the scale of original numbers, the operation performed and in many cases, the value of the variable
 scale. Legal values of the variable scale are 0 to the maximum number representable by a C integer.

 In the following descriptions of legal expressions, "expr" refers to a complete expression and "var" refers to a simple or an array variable. A simple variable is just a
 name
 and an array variable is specified as
 name[expr]
 Unless specifically mentioned the scale of the result is the maximum scale of the expressions involved.

 - expr The result is the negation of the expression.

 ++ var The variable is incremented by one and the new value is the result of the expression.

 -- var The variable is decremented by one and the new value is the result of the expression.

 var ++
 The result of the expression is the value of the variable and then the variable is incremented by one.

 var -- The result of the expression is the value of the variable and then the variable is decremented by one.

 expr + expr
 The result of the expression is the sum of the two expressions.

 expr - expr
 The result of the expression is the difference of the two expressions.

 expr * expr
 The result of the expression is the product of the two expressions.

 expr / expr
 The result of the expression is the quotient of the two expressions. The scale of the result is the value of the variable scale.

 expr % expr
 The result of the expression is the "remainder" and it is computed in the following way. To compute a%b, first a/b is computed to scale digits. That result is used to com?
 pute a-(a/b)*b to the scale of the maximum of scale+scale(b) and scale(a). If scale is set to zero and both expressions are integers this expression is the integer remain?
 der function.

 expr ^ expr
 The result of the expression is the value of the first raised to the second. The second expression must be an integer. (If the second expression is not an integer, a warn?
 ing is generated and the expression is truncated to get an integer value.) The scale of the result is scale if the exponent is negative. If the exponent is positive the
 scale of the result is the minimum of the scale of the first expression times the value of the exponent and the maximum of scale and the scale of the first expression.
 (e.g. scale(a^b) = min(scale(a)*b, max( scale, scale(a))).) It should be noted that expr^0 will always return the value of 1.

 ( expr )
 This alters the standard precedence to force the evaluation of the expression.

 var = expr
 The variable is assigned the value of the expression.

 var <op>= expr
 This is equivalent to "var = var <op> expr" with the exception that the "var" part is evaluated only once. This can make a difference if "var" is an array.

 Relational expressions are a special kind of expression that always evaluate to 0 or 1, 0 if the relation is false and 1 if the relation is true. These may appear in any legal
 expression. (POSIX bc requires that relational expressions are used only in if, while, and for statements and that only one relational test may be done in them.) The relational
 operators are

 expr1 < expr2
 The result is 1 if expr1 is strictly less than expr2.

 expr1 <= expr2
 The result is 1 if expr1 is less than or equal to expr2.

 expr1 > expr2
 The result is 1 if expr1 is strictly greater than expr2.

 expr1 >= expr2
 The result is 1 if expr1 is greater than or equal to expr2.

 expr1 == expr2
 The result is 1 if expr1 is equal to expr2.

 expr1 != expr2
 The result is 1 if expr1 is not equal to expr2.

 Boolean operations are also legal. (POSIX bc does NOT have boolean operations). The result of all boolean operations are 0 and 1 (for false and true) as in relational expres?
 sions. The boolean operators are:

 !expr The result is 1 if expr is 0.

 expr && expr
 The result is 1 if both expressions are non-zero.

 expr || expr
 The result is 1 if either expression is non-zero.

 The expression precedence is as follows: (lowest to highest)
 || operator, left associative
 && operator, left associative
 ! operator, nonassociative
 Relational operators, left associative
 Assignment operator, right associative
 + and - operators, left associative
 *, / and % operators, left associative
 ^ operator, right associative
 unary - operator, nonassociative
 ++ and -- operators, nonassociative

 This precedence was chosen so that POSIX compliant bc programs will run correctly. This will cause the use of the relational and logical operators to have some unusual behavior
 when used with assignment expressions. Consider the expression:
 a = 3 < 5

 Most C programmers would assume this would assign the result of "3 < 5" (the value 1) to the variable "a". What this does in bc is assign the value 3 to the variable "a" and then
 compare 3 to 5. It is best to use parenthesis when using relational and logical operators with the assignment operators.

 There are a few more special expressions that are provided in bc. These have to do with user defined functions and standard functions. They all appear as "name(parameters)". See
 the section on functions for user defined functions. The standard functions are:

 length ( expression )
 The value of the length function is the number of significant digits in the expression.

 read ( )
 The read function (an extension) will read a number from the standard input, regardless of where the function occurs. Beware, this can cause problems with the mixing of
 data and program in the standard input. The best use for this function is in a previously written program that needs input from the user, but never allows program code to
 be input from the user. The value of the read function is the number read from the standard input using the current value of the variable ibase for the conversion base.

 scale ( expression )
 The value of the scale function is the number of digits after the decimal point in the expression.

 sqrt ( expression )
 The value of the sqrt function is the square root of the expression. If the expression is negative, a run time error is generated.

 

กลุ่มคำสั่ง

let

 

Reference:

คำสั่ง Unix – Linux Command

Linux, Unix

 

Author: Suphakit Annoppornchai

Credit: https://saixiii.com

One Thought to “bc – Linux Command คำสั่งคำนวณตัวเลข ตามสูตรทางคณิตศาสตร์”

Leave a Reply