ਸਕਰਿਪਟ ਵਿਚ "ਬੀਸੀ" ਕੈਲਕੁਲੇਟਰ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ

ਲੀਨਕਸ ਪ੍ਰੋਗਰਾਮ ਬੀਸੀ ਨੂੰ ਇੱਕ ਸੁਵਿਧਾਜਨਕ ਡੈਸਕਟੌਪ ਕੈਲਕੂਲੇਟਰ ਜਾਂ ਇੱਕ ਗਣਿਤ ਸਕ੍ਰਿਪਟ ਭਾਸ਼ਾ ਦੇ ਤੌਰ ਤੇ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਇਹ ਟਰਮੀਨਲ ਰਾਹੀਂ ਬੀਸੀ ਕਮਾਂਡ ਨੂੰ ਬੁਲਾਉਣਾ ਅਸਾਨ ਹੈ.

ਬੀਸੀ ਯੂਟਿਲਿਟੀ ਦੇ ਇਲਾਵਾ, ਬਿਸ਼ ਸ਼ੈਡ ਅੰਕਗਣਿਕ ਕਾਰਵਾਈਆਂ ਕਰਨ ਲਈ ਕੁਝ ਹੋਰ ਵਿਧੀਆਂ ਮੁਹੱਈਆ ਕਰਦਾ ਹੈ.

ਨੋਟ: ਬੀ.ਸੀ. ਪ੍ਰੋਗ੍ਰਾਮ ਨੂੰ ਬੁਨਿਆਦੀ ਕੈਲਕੁਲੇਟਰ ਜਾਂ ਬੈਂਚ ਕੈਲਕੂਲੇਟਰ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ.

bc ਕਮਾਂਡ ਕੰਟੈਕਲੇਸ਼ਨ

Bc ਕਮਾਂਡ ਲਈ ਸੰਟੈਕਸ C ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਦੇ ਸਮਾਨ ਹੈ, ਅਤੇ ਕਈ ਤਰ੍ਹਾਂ ਦੇ ਆਪਰੇਟਰ ਸਮਰਥਿਤ ਹਨ, ਜਿਵੇਂ ਕਿ ਜੋੜ, ਘਟਾਉ, ਪਲੱਸ ਜਾਂ ਘਟਾਓ ਆਦਿ.

ਇਹ ਵੱਖ-ਵੱਖ ਸਵਿੱਚਾਂ ਹਨ ਜੋ bc ਕਮਾਂਡ ਨਾਲ ਉਪਲੱਬਧ ਹਨ:

• -h, --help: ਇਹ ਵਰਤੋਂ ਛਾਪਦੀ ਹੈ ਅਤੇ ਬੰਦ ਹੋ ਜਾਂਦੀ ਹੈ.
• -i, --ਨਿਰੈਕਟਿਵ: ਇੰਟਰੈਕਟਿਵ ਮੋਡ ਫੋਰਸ.
• -l, --mathlib: ਪ੍ਰੀ-ਪਰਿਭਾਸ਼ਿਤ ਗਣਿਤ ਰੁਟੀਨ ਵਰਤਦਾ ਹੈ.
• -q, --quiet: ਸ਼ੁਰੂਆਤੀ ਬੈਨਰ ਨੂੰ ਪ੍ਰਿੰਟ ਨਹੀਂ ਕਰਦਾ.
• -s, --standard: ਗੈਰ-ਮਿਆਰੀ ਬੀਸੀ constructs ਗਲਤੀਆਂ ਹਨ
• -w, --warn: ਗੈਰ-ਮਿਆਰੀ ਬੀ.ਸੀ. ਬਣਾਏ ਜਾਣ ਬਾਰੇ ਚੇਤਾਵਨੀ ਦਿੰਦੀ ਹੈ.
• -v, --ਵਰਜ਼ਨ: ਵਰਜਨ ਜਾਣਕਾਰੀ ਅਤੇ ਬਾਹਰ ਜਾਣ ਤੇ ਛਾਪੋ.

ਇਸ ਬਾਰੇ ਹੋਰ ਵੇਰਵੇ ਵੇਖੋ ਕਿ ਤੁਸੀਂ ਮੂਲ ਕੈਲਕੁਲੇਟਰ ਕਿਵੇਂ ਵਰਤ ਸਕਦੇ ਹੋ.

bc ਕਮਾਂਡ ਉਦਾਹਰਨ

ਮੂਲ ਕੈਲਕੂਲੇਟਰ ਨੂੰ ਕੇਵਲ ਬੀਸੀ ਵਿਚ ਦਾਖਲ ਕਰਕੇ ਟਰਮੀਨਲ ਵਿਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਤੋਂ ਬਾਅਦ ਤੁਸੀਂ ਇਸ ਤਰ੍ਹਾਂ ਨਿਯਮਤ ਗਣਿਤ ਸਮੀਕਰਨ ਟਾਈਪ ਕਰ ਸਕਦੇ ਹੋ:

4 + 3

... ਇਸ ਤਰ੍ਹਾਂ ਦਾ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ:

7

ਵਾਰ-ਵਾਰ ਗਿਣਤੀ ਦੀ ਗਣਨਾ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਸਕ੍ਰਿਪਟ ਦੇ ਹਿੱਸੇ ਦੇ ਰੂਪ ਵਿੱਚ ਬੀ.ਸੀ. ਕੈਲਕੁਲੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਅਰਥ ਰੱਖਦਾ ਹੈ. ਅਜਿਹੀ ਸਕਰਿਪਟ ਦਾ ਸਭ ਤੋਂ ਸਰਬੋਤਮ ਰੂਪ ਕੁਝ ਅਜਿਹਾ ਦਿਖਾਈ ਦੇਵੇਗਾ:

#! / bin / bash ਈਕੋ '6.5 / 2.7' | ਬੀਸੀ

ਪਹਿਲੀ ਲਾਈਨ ਉਹ ਰਸਤਾ ਹੈ ਜੋ ਇਸ ਸਕਰਿਪਟ ਨੂੰ ਚਲਾਉਂਦੀ ਹੈ.

ਦੂਜੀ ਲਾਈਨ ਵਿੱਚ ਦੋ ਕਮਾਂਡ ਹਨ. ਈਕੋ ਕਮਾਡ ਇੱਕ ਸਤਰ ਬਣਾਉਂਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਇਕ ਹਵਾਲੇ (6.5 ਭਾਗ 2.7, ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ) ਵਿੱਚ ਭਰਿਆ ਗਣਿਤਕ ਸਮੀਕਰਨ ਹੈ. ਪਾਈਪ ਅਪਰੇਟਰ (|) ਬੀ ਸੀ ਪ੍ਰੋਗਰਾਮ ਲਈ ਆਰਗੂਮਿੰਟ ਦੇ ਤੌਰ ਤੇ ਇਸ ਸਟ੍ਰਿੰਗ ਨੂੰ ਪਾਸ ਕਰਦਾ ਹੈ. Bc ਪ੍ਰੋਗ੍ਰਾਮ ਦੇ ਆਉਟਪੁਟ ਨੂੰ ਫਿਰ ਕਮਾਂਡ ਲਾਈਨ ਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ.

ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਉਣ ਲਈ, ਇੱਕ ਟਰਮੀਨਲ ਵਿੰਡੋ ਖੋਲੋ ਅਤੇ ਡਾਇਰੈਕਟਰੀ ਤੇ ਜਾਓ ਜਿੱਥੇ ਸਕ੍ਰਿਪਟ ਸਥਿਤ ਹੈ. ਅਸੀਂ ਮੰਨ ਲਵਾਂਗੇ ਸਕ੍ਰਿਪਟ ਫਾਇਲ ਨੂੰ bc_script.sh ਕਿਹਾ ਜਾਂਦਾ ਹੈ. ਇਹ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਫਾਇਲ chmod ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਨਾਲ ਚੱਲਣਯੋਗ ਹੈ:

chmod 755 bc_script.sh

ਫਿਰ ਤੁਸੀਂ ਦਾਖਲ ਹੋਵੋਗੇ:

./bc_script.sh

ਨਤੀਜਾ ਇਹ ਹੋਵੇਗਾ:

2

ਸੱਚਾ ਉੱਤਰ 2.407407 ਤੋਂ 3 ਦਸ਼ਮਲਵ ਸਥਾਨਾਂ ਨੂੰ ਦਿਖਾਉਣ ਲਈ ..., ਸਿੰਗਲ ਕੋਟਸ ਦੁਆਰਾ ਸੀਮਿਤ ਸਤਰ ਦੇ ਅੰਦਰ ਇੱਕ ਸਕੇਲ ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰੋ:

#! / bin / bash echo 'scale = 3; 6.5 / 2.7 '| ਬੀਸੀ

ਬਿਹਤਰ ਪੜਣਯੋਗਤਾ ਲਈ, ਗਣਨਾ ਦੇ ਨਾਲ ਲਾਈਨ ਨੂੰ ਕਈ ਲਾਈਨਾਂ ਤੇ ਮੁੜ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਆਦੇਸ਼ ਵਿੱਚ ਕਈ ਲਾਈਨਾਂ ਵਿੱਚ ਕਮਾਂਡ ਲਾਈਨ ਨੂੰ ਤੋੜਨਾ ਤੁਸੀਂ ਲਾਈਨ ਦੇ ਅਖੀਰ ਤੇ ਬੈਕਸਲਾਸ਼ ਪਾ ਸਕਦੇ ਹੋ:

echo 'scale = 3; var1 = 6.5 / 2.7; var1 '\ | ਬੀਸੀ

ਤੁਹਾਡੀ ਬੀਸੀ ਗਣਨਾ ਵਿਚ ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟ ਸ਼ਾਮਲ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਸਿੰਗਲ ਕੋਟਸ ਨੂੰ ਡਬਲ ਕੋਟਸ ਵਿਚ ਬਦਲਣਾ ਹੋਵੇਗਾ ਤਾਂ ਕਿ ਕਮਾਂਡ ਲਾਈਨ ਪੈਰਾਮੀਟਰ ਪ੍ਰਤੀਕਾਂ ਨੂੰ ਬਸ਼ ਸ਼ੈੱਲ ਦੁਆਰਾ ਸਮਝਾਇਆ ਜਾ ਸਕੇ:

echo "scale = 3; var1 = 6.5 / 2.7; var2 = 14 * var1; var2 * = $ 1; var2" \ | ਬੀਸੀ

ਪਹਿਲੀ ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟ "$ 1" ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਹੁੰਚਿਆ ਹੈ, ਦੂਜੀ ਆਰਗੂਮੈਂਟ "$ 2" ਆਦਿ ਵਰਤਦੀ ਹੈ.

ਹੁਣ ਤੁਸੀਂ ਵੱਖਰੀ ਬਾਸ਼ ਸਕਰਿਪਟ ਵਿੱਚ ਆਪਣੀ ਪਸੰਦ ਦੇ ਗਣਿਤ ਫੰਕਸ਼ਨ ਲਿਖ ਸਕਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਹੋਰ ਸਕ੍ਰਿਪਟਾਂ ਤੋਂ ਕਾਲ ਕਰ ਸਕਦੇ ਹੋ.

ਉਦਾਹਰਣ ਵਜੋਂ, ਜੇ ਸਕ੍ਰਿਪਟ 1 ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ:

#! / bin / bash echo "scale = 3; var1 = 6.5 / 2.7; var2 = 14 * var1; var2 * = $ 1; var2" \ | ਬੀਸੀ

... ਅਤੇ ਲਿਪੇਟ 2 ਵਿੱਚ ਸ਼ਾਮਿਲ ਹੈ

#! / bin / bash var0 = "100" ਐਕੋ "var0: $ var0" ਫੰਕਸ਼ਨ ਫੰਕਸ਼ਨ 1 {ਈਕੋ "ਸਕੇਲ = 3; var1 = 10; var2 = var1 * $ var0; var2" \ | bc} fres = $ (fun1) echo "fres:" $ fres var10 = $ (./ ਸਕ੍ਰਿਪਟ 1 $ ਫਰਸ); ਈਕੋ "var10:" $ var10;

... ਫਿਰ script2 ਨੂੰ ਐਕਜ਼ੀਕਿਯੂਟ ਕਰਕੇ ਸਕ੍ਰਿਪਟ 1 ਨੂੰ ਪੈਰਾਮੀਟਰ ਦੇ ਤੌਰ ਤੇ ਸਕ੍ਰਿਪਟ 2 ਵਿੱਚ ਦਰਸਾਈ ਇੱਕ ਫੇਅਰਬਲ $ ਫਰੇਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੱਦਿਆ ਜਾਵੇਗਾ.