ビットシフトの規則性を知りたくなった

ビットシフトの規則性を知りたかったのでC#でちょっと調べてみた。



右シフト

int x = 144;
string binString = Convert.ToString(x, 2);
int ln = binString.Length;

Console.WriteLine(
    "target value:{0}\n" +
    "binary string:{1}\n" +
    "binary string length:{2}\n",
    x , binString, ln);

for (int i = 1; i <= ln; i++)
{
    int ret = x >> i;
    Console.WriteLine(
        "{0} >> {1} => {2}\t= {0} / {3}",
        x, i, ret, ret > 0 ? x / ret : 0);
}

Result:

target value:              144
binary string:        10010000
binary string length:        8

144 >> 1 => 72  = 144 /   2
144 >> 2 => 36  = 144 /   4
144 >> 3 => 18  = 144 /   8
144 >> 4 =>  9  = 144 /  16
144 >> 5 =>  4  = 144 /  36
144 >> 6 =>  2  = 144 /  72
144 >> 7 =>  1  = 144 / 144
144 >> 8 =>  0  = 144 /   0

左シフト

int n = 2;
for (int i = 1; i < 12; i++)
{
    int ret = x << i;
    Console.WriteLine(
        "{0} << {1} => {2}\t= {0} * {3}",
        x, i, ret, n);
    n = n * 2;
}

Result:

144 <<  1 =>    288     = 144 *    2
144 <<  2 =>    576     = 144 *    4
144 <<  3 =>   1152     = 144 *    8
144 <<  4 =>   2304     = 144 *   16
144 <<  5 =>   4608     = 144 *   32
144 <<  6 =>   9216     = 144 *   64
144 <<  7 =>  18432     = 144 *  128
144 <<  8 =>  36864     = 144 *  256
144 <<  9 =>  73728     = 144 *  512
144 << 10 => 147456     = 144 * 1024
144 << 11 => 294912     = 144 * 2048

2乗

int m = 2;
for (int i = 1; i < 12; i++)
{
    int ret = m << i;
    Console.WriteLine(
        "{0} << {1} => {2}\t= {0} * {0}\t{3}",
        m, i, ret, Convert.ToString(m, 2).PadLeft(12, '0'));
    m = m * 2;
}

Result:

   2 <<  1 =>       4   =    2 *    2   000000000010
   4 <<  2 =>      16   =    4 *    4   000000000100
   8 <<  3 =>      64   =    8 *    8   000000001000
  16 <<  4 =>     256   =   16 *   16   000000010000
  32 <<  5 =>    1024   =   32 *   32   000000100000
  64 <<  6 =>    4096   =   64 *   64   000001000000
 128 <<  7 =>   16384   =  128 *  128   000010000000
 256 <<  8 =>   65536   =  256 *  256   000100000000
 512 <<  9 =>  262144   =  512 *  512   001000000000
1024 << 10 => 1048576   = 1024 * 1024   010000000000
2048 << 11 => 4194304   = 2048 * 2048   100000000000

多少の規則性は見つけることができたかな?




脱線して関係ないことまで知ることになったのはいつものこと。
以下、関係なし。

ネイピア数:自然対数の底の値 (オイラー定数)

Math.E

結果は同じ

Math.Pow(Math.E, 2)
Math.Exp(2)

144 ... フィボナッチ数列の中の唯一の平方数(12番目)

Sqrt, Pow, Log
144 = x2

Math.Sqrt(144) //12

x = 122

Math.Pow(12, 2) //144

144 = 12x

Math.Log(144, 12) //2

この三つの関数の関係を表したかっただけ。


同じことをしている。

Math.Log10(144)
Math.Log(144, 10)

これも同じことをしている。

Math.Log(144)
Math.Log(144, Math.E)

指数をもとめるのに使用するMath.Logは便利だなぁ(^o^)、とか言いながらも実際はあまり使わない。(^_^;)