## bc and its ibase/obase options:

bc base
bc linux
bc hex to decimal
base conversion in bash
bash convert base 2 to base 10
any base to any base conversion in shell script
base conversion tricks
convert binary to decimal in shell script

I stumbled over a curious bug, I think:

I tried to read "512" as a number to base 6, and output it as base 16:

```echo "ibase=6;obase=16;512" | bc
161
```

As you can see, the output is 161, but it should be `bc`(sic!). I tried with base 10:

```echo "ibase=6;obase=10;512" | bc
512
```

The value is unchanged. Curious! Default obase is 10. If I omit it:

```echo "ibase=6;512" | bc
188
```

Well, that seems right. In a two step process, it works:

```echo "obase=16;"\$(echo "ibase=6;512" | bc) | bc
BC
```

So I made a script for different bases, but it keeps me puzzled:

```for ib in {6,8,10,16}; do echo \$ib; for ob in {10,16}; do echo -en \$ib \$ob"     \t => " ; echo "ibase=\$ib;obase=\$ob;333" | bc ; done; done;
6
6 10         => 333
6 16         => 108
8
8 10         => 333
8 16         => 119
10
10 10        => 333
10 16        => 14D
16
16 10        => 333
16 16        =>  01 15 05
```

Shall I file a bugreport, or do I miss the obvious? I can't really believe that such a basic tool is broken.

Not a bug.

As soon as `ibase=6` is interpreted, numbers are read in base 6. So `ibase=6;obase=16` makes obase's value to be 16base 6 which is invalid, and is interpreted as 11decimal.

From the man page:

For multi-digit numbers, bc changes all input digits greater or equal to ibase to the value of ibase-1.

So 16 is interpreted as 15base 6 which is 11decimal. And the conversion is correct.

Set `obase` before `ibase`, or make sure to specify your obase in base `ibase`.

```\$ echo "obase=16;ibase=6;512" | bc
BC
```

Understand "ibase" and "obase" in case of conversions with bc , and obase for any conversion involving decimal numbers, since these settings default to 10. echo "ibase=2; obase=10000; 11000000" | bc C0 That's right, the output isn't in hex as you were assuming, it's in base 15! \$ echo "obase=16; ibase=2; 11000000" | bc C0 If you give ibase first instead, it changes the interpretation of the following obase setting, so that the command has to be: \$ echo "ibase=2; obase=10000; 11000000" | bc C0 This is because in this order, the obase value is interpreted as a binary number, so you need to give 10000₂=16 to get output in hex. That's clumsy.

When you set `ibase` or `obase`, it's expressed with the current base of `ibase`. So set `obase` before you set `ibase` if you want to express `obase` in decimal.

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.

So for `obase=16` in `ibase=6`, the `6` becomes a `5`, and it is equivalent to an output base of decimal `6 * 1 + 1 * 5 == 11`, thus:

```\$ echo "obase=11;ibase=6;512" | bc
161
```

Base conversions with bc Using bc, echo, echo \"obase=2; 27\" | bc -l - (Base conversions with bc Easily convert numbers to their representations in different bases. Passing \"ibase=16  The ibase and obase registers are the input and output number radix, respectively. The value of ibase is limited to 2 <= ibase <= 16. The value of obase is limited to 2 <= obase = {BC_BASE_MAX} When either the ibase or obase registers are assigned a single-digit value from the list described in "Lexical Conventions", the value is assumed in hexadecimal. For example:

Slightly modify the code (two ways) and your expected results appear:

```for ib in {6,8,10,16}; do
echo \$ib; for ob in {10,16}; do
echo -en \$ib \$ob"     \t => " ;
ob=`echo "obase=\$ib;\$ob" | bc`
echo "ibase=\$ib;obase=\$ob;333" | bc ;
done;
done;

for ib in {6,8,10,16}; do
echo \$ib; for ob in {10,16}; do
echo -en \$ib \$ob"     \t => " ;
echo "obase=\$ob;ibase=\$ib;333" | bc ;
done;
done;
```

execute in bash sandbox

results for both ways are:

```6
6 10         => 129
6 16         => 81
8
8 10         => 219
8 16         => DB
10
10 10        => 333
10 16        => 14D
16
16 10        => 819
16 16        => 333
```

bc and its ibase/obase options: - base - html, I stumbled over a curious bug, I think: I tried to read "512" as a number to base 6, and output it as base 16: echo "ibase=6;obase=16;512" | bc 161 As you can  Obviously, bc uses your ibase when it reads obase: that's why obase=10 always means "the same as ibase". In the latest example, you don't give obase=10 (which would set the value to decimal 16), that's why obase remains the default (decimal 10).

bc Command Manual, bc takes the following options from the command line: The default value of scale is 0. ibase and obase define the conversion base for input and output  The ibase and obase registers are the input and output number radix, respectively. The value of ibase shall be limited to: 2 ≤ ibase ≤ 16 The value of obase shall be limited to: 2 ≤ obase ≤ {BC_BASE_MAX} When either ibase or obase is assigned a single digit value from the list in Lexical Conventions in bc , the value shall be assumed in hexadecimal.

EZ conversions on Unix, One such option is bc -- the arbitrary precision calculator. Using ibase, we set the base of the number provided (in this case, 101) to 2. The legal values for obase are 2 through BC_BASE_MAX (see section Environment Variables ). For bases 2 through 16, the usual method of writing numbers is used. For bases greater than 16, bc uses a multi-character digit method of printing the numbers where each higher base digit is printed as a base 10 number.

bc, OPTIONS. The bc utility shall conform to XBD Utility Syntax Guidelines . The ibase and obase registers are the input and output number radix, respectively. The legal values for obase are 2 through BC_BASE_MAX. (See the section LIMITS.) For bases 2 through 16, the usual method of writing numbers is used. For bases greater than 16, bc uses a multi-character digit method of printing the numbers where each higher base digit is printed as a base 10 number.