分形/数学/数字

        "Many questions concerning (discrete) dynamical systems are of a number theoretic or combinatorial nature." Christian Krattenthaler

实数集

简介

• 每个程序员都应该知道的初级数论...由 CodeChef 提供
• Quora : 每个程序员都应该了解哪些重要的数论主题？
• science4all : 数字与可构造性
• 数论
• 计算机如何使用数字，由 Mabi19 提供

数字类型

数字可以用作 

• 数值计算中使用的数值
• 符号计算中使用的符号

数字（例如 角度以圈数表示）可以是：

• 十进制数（基数 = 10）
  • 整数
  • 实数
    • 比率 = 分数（有限 连分数） = 有理数（任何有理数的无理度为 1）
      • 最简形式（不可约形式） : ${\tfrac {1}{21}}$
      • 可约形式
        • 显式规范化形式（仅当分母为奇数时）： ${\tfrac {3}{63}}={\tfrac {3}{2^{6}-1}}$
    • 无理数 = 无限连分数（如果数字不能表示为比率，则它就是无理数）
      • 代数数（无理度 = 2）
      • 超越数（无理度 > 2）
  • 十进制浮点数 $0.{\overline {047619}}$
    • 有限展开
    • 无限（无穷）展开
      • 无限地继续下去而不重复（在这种情况下，该数字称为无理数 = 非重复非终止小数）
      • 循环或重复
        • （严格）周期性（前缀 = 0，周期 > 0）
        • 混合 = 终结周期性（前缀 > 0，周期 > 0）
• 二进制数（基数 = 2）
  • 二进制有理数（比率） ${\tfrac {1}{10101}}$
  • 二进制实数
    • 二进制浮点数（科学记数法）
    • 原始二进制（原始 IEEE 格式）
    • 二进制定点数（记号）
      • 具有重复序列 : $0.{\overline {000011}}$
      • 具有无穷展开 $0.000011000011000011000011...$

维度

• 1D: 实数
• 2D
  • 双数
  • 复数
• 4D
  • 四元数

使用有限数量的位表示实数的方法

• IEEE 浮点数
• 定点数
• John Gustafson 提出的通用数（unums）
  • Posits 是 unums 的硬件友好版本

展开/表示

• 有限 = 终止
• 无限 = 非终止
  • 周期性 = 无限循环
  • 前周期性 = 最终周期性
  • 非周期性: 既不终止也不循环的二进制数字表示无理数

基数

位值记数制中的基数或底数

• 2 (二进制数)
• 8 (八进制数)
• 10 (十进制数)
• 16 (十六进制数)

形式/记号

记号

• 数字和基数的序列
  • 无限序列
    • 一般形式用省略号 ( = 3 个点) 表示: $r=d_{0}.d_{1}d_{2}d_{3}\dots$
    • 无限循环部分用
      • 圆括号表示: $0.10(00101010)=0.10001010100010101000101010001010100010101000101010\dots$.
      • 上划线: $0.10{\overline {00101010}}=0.10001010100010101000101010001010100010101000101010\dots$
  • 有限序列
    • 1.23
      • 带尾随零: 1.2300，用于指示有效数字的位数，例如在测量中。
    • 带绝对测量误差: 均值 ± 范围 ，例如: 72.20 ± 0.02
• 整数的比率 $r={\frac {m}{n}}$
  • 最简形式（不可约形式） : ${\tfrac {1}{21}}$
  • 可约形式
    • 显式规范形式 (仅当分母为奇数时):${\frac {n}{2^{p}-1}}$，例如: ${\tfrac {3}{63}}={\tfrac {3}{2^{6}-1}}$
    • 角度分母公式的显式规范形式: ${\frac {n}{(2^{p}-1)*2^{k}}}$
• 连分数: $[a_{0};a_{1},a_{2},a_{3}]$
• 科学 (指数) 形式或记号:

$6.022e23=6.022*10^{23}$

$1.2345e-3=1.2345+10^{-3}$

${\tfrac {3}{63}}={\tfrac {3}{2^{6}-1}}={\tfrac {1}{21}}=0.04761904761904762$

计算机数字格式（存储形式）

• 浮点形式（扩展）：数字的小数点可以“浮动”到数字的有效数字的左侧、右侧或之间。
• 定点格式

圆括号

带指数的括号（上标）表示该序列重复的次数

$0.11(11101010)=0.11(11(10)^{3})$

尾随零

小数点右侧的尾随零，如 12.3400，不会影响数字的值，如果只关心数字的值，可以省略。即使零无限重复，也是如此。例如，在药学中，剂量值会省略尾随零，以防止误读。但是，尾随零可能有助于指示有效数字的数量，例如在测量中。在这种情况下，通过删除尾随零来“简化”数字将是不正确的。

非零 b 进制整数 n 中尾随零的数量等于 b 的最高次幂的指数，该次幂能整除 n。例如，14000 有三个尾随零，因此可被 1000 = 103 整除，但不能被 104 整除。此属性在寻找整数分解中的小因子时非常有用。一些计算机架构在它们的指令集中具有计数尾随零操作，可以高效地确定机器字中的尾随零位的数量。

二进制展开示例

首先检查比率是否是最简分数（可约）

二进制展开可以是

• 有限的
• 无限的
  • 周期性的：前周期 = 0，周期 > 0
  • 前周期性（= 终周期性）：前周期 > 0，周期 > 0
  • 非周期性：前周期 = 0，周期 = 0

转换

转换之间

• 进制（从二进制到十进制，...）
• 形式（有理数到展开式，...）
  • 从十进制展开式识别有理数： “计算近似的简单连分数，并在较大的部分商 a_n 之前截断它，然后计算截断的连分数的值。”
  • 转换循环小数为分数
  • 分数转换为循环小数
    • 使用弗洛伊德循环检测算法查找第一个重复余数
    • 递归除法和余数的收集（与十进制分数的片段相关联）
  • 转换循环分数为不同进制

使用

• 在线计算器
• 代码

算法

• 寻找
  • 二进制字符串/序列中严格重复的模式（事先不知道） “如果有模式=>它的长度必须能整除字符串长度”AnotherGeek
    • 使用正则表达式
    • javascript
  • 二进制字符串/序列中非重复和严格重复的模式（事先不知道）
• 转换具有循环小数部分的数字

将分数约化为最简分数

可约分数可以通过将分子和分母除以公因子来约分。如果分子和分母都除以它们的最大公约数，则可以将其完全约化为最简分数

寻找最大公约数的算法

• 欧几里得算法
• 质因数分解

欧几里得算法通常是首选，因为它允许约分分子和分母过大而难以因式分解的分数

示例

• desmos：分数约分图形化

将十进制分数转换为二进制

“...我们反复将十进制分数乘以 2。如果结果大于或等于 1，我们将 1 添加到答案中。如果结果小于 1，我们将 0 添加到答案中。”（来自弗吉尼亚理工大学在线 CS 模块）

算法：

• 将输入的十进制分数乘以二
• 从以上结果
  • 取整数部分作为二进制数字
  • 取小数部分作为下一步的起点
• 重复，直到得到 0 或周期性数字
• 从上往下读取数字——第一个二进制数字是小数点后的第一个数字

将 0.1 十进制分数转换为二进制分数的示例

   0.1 * 2 = 0.2 -> 0
   0.2 * 2 = 0.4 -> 0
   0.4 * 2 = 0.8 -> 0
   0.8 * 2 = 1.6 -> 1
   0.6 * 2 = 1.2 -> 1
   0.2 * 2 = 0.4 -> 0
   0.4 * 2 = 0.8 -> 0
   0.8 * 2 = 1.6 -> 1
   0.6 * 2 = 1.2 -> 1
   0.2 * 2 = 0.4 -> 0
   0.4 * 2 = 0.8 -> 0
   0.8 * 2 = 1.6 -> 1
   0.6 * 2 = 1.2 -> 1
   0.2 * 2 = 0.4 -> 0

结果

$0.1_{10}=0.0(0011)_{2}$

循环分数：

0.(567) = 567/999 = 189/333 = 63/111
0.(0011) = 0011 / 1111 =(in decimal) 3/15 = 1/5

图形转换

代码

• geeksforgeeks：convert-decimal-fraction-binary-number
• primary-bulb by Claude Heiland-Allen

将二进制分数转换为十进制比率

几何级数

(前)周期性二进制小数可以拆分为两个小数

• 有限的
• 无限：周期性，前周期部分为空或全部为零

$0.\overbrace {b...b} ^{t}(\overbrace {b...b} ^{p})=0.\overbrace {b...b} ^{t}+0.\overbrace {0...0} ^{t}(\overbrace {b...b} ^{p})$

当 |r|<1 时，等比数列的公式：

$a+ar+ar^{2}+ar^{3}+ar^{4}+\cdots =\sum _{k=0}^{\infty }ar^{k}={\frac {a}{1-r}}$

对于前周期部分为空或全部为零的无限周期二进制小数，该公式为

$0.\overbrace {0...0} ^{t}(\overbrace {b...b} ^{p})={\frac {a}{1-r}}$

其中 

• b 是二进制数字 : 0 或 1
• t 是前周期块的长度
• p 是周期块的长度
• a 的值只是重复块第一次出现的数值 $a=0.\overbrace {0...0} ^{t}\overbrace {b...b} ^{p}$
• $r={\frac {1}{2^{p}}}$ 因此 $1-r={\frac {2^{p}-1}{2^{p}}}$

$0.\overbrace {b...b} ^{t}(\overbrace {b...b} ^{p})=0.\overbrace {b...b} ^{t}+{\frac {a}{1-r}}=0.\overbrace {b...b} ^{t}+{\frac {0.\overbrace {0...0} ^{t}\overbrace {b...b} ^{p}}{\frac {2^{p}-1}{2^{p}}}}$

完整公式 现在为

          $0.\overbrace {b...b} ^{t}(\overbrace {b...b} ^{p})=0.\overbrace {b...b} ^{t}+{\frac {0.\overbrace {0...0} ^{t}\overbrace {b...b} ^{p}}{\frac {2^{p}-1}{2^{p}}}}$

示例 

• $0.(0011)={\frac {0.0011}{\frac {2^{4}-1}{2^{4}}}}={\frac {3/16}{15/16}}={\frac {1}{5}}$
• $0.00(0011)={\frac {0.000011}{\frac {2^{4}-1}{2^{4}}}}={\frac {3/64}{15/16}}={\frac {1}{20}}$
• $0.01(1100)=0.01+{\frac {0.0011}{\frac {2^{4}-1}{2^{4}}}}={\frac {1}{4}}+{\frac {3/16}{15/16}}={\frac {1}{4}}+{\frac {1}{5}}={\frac {9}{20}}$

$0.0101(11001)=0.0101+{\frac {0.000011001}{\frac {2^{5}-1}{2^{5}}}}={\frac {5}{16}}+{\frac {25/512}{31/32}}={\frac {5}{16}}+{\frac {25}{496}}={\frac {45}{124}}$

代码示例

bc

使用 bc – arbitrary–precision arithmetic language 将十进制比率转换为二进制

bc 1.06
Copyright 1991-1994, 1997, 1998, 2000 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'. 
obase=2
3/14
.0011011011011011011011011011011011011011011011011011011011011011010
1/5
.0011001100110011001100110011001100110011001100110011001100110011001

C

• itoa
• snprintf
• 二进制整数常量
• 宏 BOOST_BINARY
• gmp
• Claude Heiland-Allen 的 mandelbrot-symbolics 库
  • Fractals/mandelbrot-symbolics#m-binangle-from-rational binangle-from-rational
• Wojciech Muła 的数字转换为二进制表示

itoa

itoa 函数

/* 
 itoa example 
 http://www.cplusplus.com/reference/cstdlib/itoa/
*/
#include <stdio.h>
#include <stdlib.h>

int main ()
{
  int i;
  char buffer [33];
  printf ("Enter a number: ");

  scanf ("%d",&i);
  itoa (i,buffer,10);
  printf ("decimal: %s\n",buffer);

  itoa (i,buffer,16);
  printf ("hexadecimal: %s\n",buffer);

  itoa (i,buffer,2);
  printf ("binary: %s\n",buffer);

  return 0;
}

二进制整数常量

二进制整数常量

"整数常量可以写成二进制常量，由 '0' 和 '1' 数字序列组成，以 '0b' 或 '0B' 为前缀。这在对位级操作（如微控制器）进行大量操作的环境中特别有用。

以下语句是相同的

     i =       42;
     i =     0x2a;
     i =      052;
     i = 0b101010;

这些常量的类型遵循与八进制或十六进制整数常量相同的规则，因此可以应用像 'L' 或 'UL' 这样的后缀。"

gmp

GMP 库

/*

C programme using gmp

gcc r.c -lgmp -Wall

http://gmplib.org/manual/Rational-Number-Functions.html#Rational-Number-Functions

*/

#include <stdio.h>
#include <gmp.h>

int main ()
{
        
        // input = binary fraction as a string 
        char  *sbr = "01001010010010100101001001010010010100101001001010010100100101001001010010100100101001010/11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
        
        mpq_t q;   // rational number; 
        int b =2 ; // base of numeral system
        mpz_t  n ;
        mpz_t  d ;
        mpf_t f;

        // init and set variables 
        mpq_init (q); // Initialize r and set it to 0/1.
        mpq_set_str (q, sbr ,  b);
        mpq_canonicalize (q); // It is the responsibility of the user to canonicalize the assigned variable before any arithmetic operations are performed on that variable. 
        mpq_canonicalize (q); // It is the responsibility of the user to canonicalize the assigned variable before any arithmetic operations are performed on that variable.

        // n , d
        mpz_inits(n,d,NULL); 
        mpq_get_num(n,q);
        mpq_get_den(d, q);

        //
        mpf_init2(f, 100); // http://stackoverflow.com/questions/12804362/gmp-division-precision-or-printing-issue
        mpf_set_q(f,q); // There is no rounding, this conversion is exact.

        // print 
        gmp_printf ("decimal fraction =  %Zd / %Zd \ndecimal canonical form =  %Qd\n",n,d, q); // 
        gmp_printf ("binary fraction  = %s \n", sbr); // 
        gmp_printf ("decimal floating point number : %.30Ff \n", f); // 
        
        
        
        // clear memory
        mpq_clear (q);
        mpz_clear (n);
        mpz_clear (d);
        mpf_clear (f);
        
        return 0;
}

输出

decimal fraction =  179622968672387565806504266 / 618970019642690137449562111 
decimal canonical form =  179622968672387565806504266/618970019642690137449562111
binary fraction  = 01001010010010100101001001010010010100101001001010010100100101001001010010100100101001010/11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 
decimal floating point number : 0.290196557138708685358212602171 

Haskell

Claude Heiland-Allen 的代码：

--  http://mathr.co.uk/blog/2014-10-13_converting_fractions_to_strings_of_digits.html

 import Data.Fixed (mod')
 import Data.List (nub)
 import Data.Ratio ((%), denominator)
 import Data.Numbers.Primes (primeFactors)
 import System.Environment (getArgs)

 data Digits = Digits
  { dNegative :: Bool
  , dInteger
  , dPreperiodic
  , dPeriodic :: [Int]
  } deriving Show

preperiod :: Digits -> Int
preperiod = length . dPreperiodic

period :: Digits -> Int
period = length . dPeriodic

digitsAtBase :: Int -> Rational -> Digits
digitsAtBase base rational
  = Digits
  { dNegative = rational < 0
  , dInteger = int
  , dPreperiodic = pre
  , dPeriodic = per
  }
  where
    integer :: Integer
    fraction :: Rational
    (integer, fraction) = properFraction (abs rational)
    int | integer == 0 = [0]
        | otherwise = goInt integer []
    goInt i ds
      | i == 0 = ds
      | otherwise = goInt i' (fromInteger d : ds)
      where
        (i', d) = i `divMod` baseZ
    factors :: [Integer]
    factors = map fromIntegral . nub . primeFactors $ base
    isPreperiodic :: Rational -> Bool
    isPreperiodic x = any (`divides` denominator x) factors
    baseZ :: Integer
    baseZ = fromIntegral base
    baseQ :: Rational
    baseQ = fromIntegral base
    (pre, per) = goPre fraction
      where
        goPre :: Rational -> ([Int], [Int])
        goPre x
          | isPreperiodic x = first (d:) (goPre x')
          | otherwise = ([], d : goPer x x')
          where (d, x') = properFraction (baseQ * x)
        goPer :: Rational -> Rational -> [Int]
        goPer x0 x
          | x0 == x = []
          | otherwise = d : goPer x0 x'
          where (d, x') = properFraction (baseQ * x)
    first :: (a -> c) -> (a, b) -> (c, b)
    first f (a, b) = (f a, b)
    divides :: Integer -> Integer -> Bool
    factor `divides` number = number `mod` factor == 0

digitsToString :: [String] -> Digits -> String
digitsToString digits Digits
  { dNegative = sign
  , dInteger = int
  , dPreperiodic = pre
  , dPeriodic = per
  }
  = (if sign then "-" else "")
  ++ d int ++ "." ++ d pre ++ "(" ++ d per ++ ")"
  where
    d = concatMap (digits !!)

atBase :: Int -> Rational -> String
atBase base rational = digitsToString ds (digitsAtBase base rational)
  where
    ds | base <= 62 = map (:[]) $ ['0'..'9'] ++ ['A'..'Z'] ++ ['a'..'z']
       | otherwise = [ "<" ++ show d ++ ">" | d <- [0 .. base - 1] ]

main :: IO ()
main = do
  [sbase, sfraction] <- getArgs
  let (snum, _:sden) = break ('/' ==) sfraction
      base = read sbase
      num = read snum
      den = read sden
      rational = num % den
  putStrLn (atBase base rational)

Python

# https://wiki.python.org/moin/BitManipulation
# binary string to integer 
>>> int('00100001', 2)
33
# conversion from binary string to  hex string
>>> print "0x%x" % int('11111111', 2)
0xff
>>> print "0x%x" % int('0110110110', 2)
0x1b6
>>> print "0x%x" % int('0010101110101100111010101101010111110101010101', 2)
0xaeb3ab57d55

其他方法

如何在计算机程序中使用数字？

首先阅读

• 文章 “What Every Computer Scientist Should Know About Floating-Point Arithmetic” 由 DAVID GOLDBERG 撰写：
• Josh HabermanFloating Point Demystified, Part 1 由
• floating-point-demystified-part2

整数

• 类型
• 限制和溢出

限制

/*

gcc l.c -lm -Wall
./a.out

http://stackoverflow.com/questions/29592898/do-long-long-and-long-have-same-range-in-c-in-64-bit-machine
*/
#include <stdio.h>
#include <math.h> // M_PI; needs -lm also 
#include <limits.h> // INT_MAX, http://pubs.opengroup.org/onlinepubs/009695399/basedefs/limits.h.html

int main(){

double lMax;

 lMax = log2(INT_MAX);
 printf("INT_MAX \t= %25d ; lMax = log2(INT_MAX) \t= %.0f \n",INT_MAX,  lMax);

 lMax = log2(UINT_MAX);
 printf("UINT_MAX \t= %25u ; lMax = log2(UINT_MAX) \t= %.0f \n", UINT_MAX,  lMax);

 lMax = log2(LONG_MAX);
 printf("LONG_MAX \t= %25ld ; lMax = log2(LONG_MAX) \t= %.0f \n",LONG_MAX,  lMax);

 lMax = log2(ULONG_MAX);
 printf("ULONG_MAX \t= %25lu ; lMax = log2(ULONG_MAX) \t= %.0f \n",ULONG_MAX,  lMax);

 lMax = log2(LLONG_MAX);
 printf("LLONG_MAX \t= %25lld ; lMax = log2(LLONG_MAX) \t= %.0f \n",LLONG_MAX, lMax);

 lMax = log2(ULLONG_MAX);
 printf("ULLONG_MAX \t= %25llu ; lMax = log2(ULLONG_MAX) \t= %.0f \n",ULLONG_MAX, lMax);

return 0;
}

结果

INT_MAX 	=                2147483647 ; lMax = log2(INT_MAX) 	= 31 
UINT_MAX 	=                4294967295 ; lMax = log2(UINT_MAX) 	= 32 
LONG_MAX 	=       9223372036854775807 ; lMax = log2(LONG_MAX) 	= 63 
ULONG_MAX 	=      18446744073709551615 ; lMax = log2(ULONG_MAX) 	= 64 
LLONG_MAX 	=       9223372036854775807 ; lMax = log2(LLONG_MAX) 	= 63 
ULLONG_MAX 	=      18446744073709551615 ; lMax = log2(ULLONG_MAX) 	= 64 

例如，Wolf Jung 在 程序 Mandel 中进行了一个静默边界检查：

// mndynamo.h  by Wolf Jung (C) 2007-2014
typedef  unsigned long long int  qulonglong;

// mndcombi.cpp  by Wolf Jung (C) 2007-2014
 qulonglong mndAngle::wake(int k, int r, qulonglong &n)
{  if (k <= 0 || k >= r || r > 64) return 0LL;

如果 r 对无符号长长整型太大，则返回 0 以防止整数溢出。

GMP 库具有任意精度的有理数。

浮点数

精度

精度

• GMP：每个浮点数的尾数具有用户可选择的精度（变量 prec 类型 mp_bitcnt_t）。多精度数字的位数在 C 类型 mp_bitcnt_t 中表示。目前这始终是一个无符号长整型
• MPFR：精度是用于表示浮点数尾数（尾数）的位数；相应的 C 数据类型是 mpfr_prec_t。

有理数

圆上的有理点在立体投影下对应于直线上的有理点。

"任何具有有限小数展开式的数字都是有理数。"换句话说："任何浮点数都可以转换为有理数。"

因此，在数值计算中，人们可以使用整数或浮点数（有理数）。

二进制

• 使用 PARI/GP 计算器探索二进制数，作者：Rick Regan
• Wolfram Alpha

数字

在 C 中，可以使用 

• 位运算符

在 Maxima CAS 中，可以使用 

(%i1) ibase;
(%o1) 10
(%i2) obase;
(%o2) 10
(%i3) ibase:2;
(%o3) 2
(%i4) x=1001110;
(%o4) x=78

字符串

使用 **Haskell**（ghci）计算二进制数，并将二进制数表示为包含重复部分的字符串。

-- by Claude Heiland-Allen
-- http://mathr.co.uk/blog/haskell.html
Prelude> let rep n s = concat (replicate n s)
Prelude> putStrLn $ ".(" ++ rep 88 "001" ++ "010)"
.(001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001010)

putStrLn $ ".(" ++ rep 87 "001" ++ "010001)"
.(001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001010001)

Prelude> putStrLn $ ".(" ++ rep 88 "001" ++ "0001)"
.(0010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010001)

Prelude> putStrLn $ ".(" ++ rep 88 "001" ++ "0010)"
.(0010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010010)

在 **Python** 中 

>>> bin(173)
'0b10101101'
>>> int('01010101111',2)
687

字面量

在 Python 中，可以使用二进制字面量：

python
Python 2.7.5+ (default, Feb 27 2014, 19:37:08) 
[GCC 4.8.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 0b101111
47

无理数 = 非有理数

无理数

            The problem is that we are exploring environments based upon irrational numbers through computer machinery which works with finite rationals ! ( Alessandro Rosa )

展开式不终止且不循环

类型

• 代数数 = 代数方程的根。例如：sqrt(2)，
• 超越数 = 非代数数

如果要使用无理数，则应检查 

• 符号计算 
  • 精确数可以作为符号使用，但“无法打印整个无理数”。
  • 无限连分数
• 数值计算：无理数的近似有理数 （丢番图逼近 ）
  • 整数的比率
  • 浮点数
  • 有限连分数

黄金分割的倒数

最无理的数字 在连分数中，所有数字都为 1，表示所有无理数中最慢的收敛速度。

使用 Maxima CAS 

(%i10) print(float(%phi-1));
(%o10).6180339887498949
(%i11) rationalize(float(%phi-1));
(%o11) 347922205179541/562949953421312

和  

(%i14) print(float(1/%phi));
(%o14) .6180339887498948
(%i15) rationalize(float(1/%phi));
(%o15) 5566755282872655/9007199254740992

其中分母 

$562949953421312=1+2^{49}$

复数

• 复数幂的多值性会导致很大的问题（分支切割的人为产物，arg 的任意主值）。
• 域着色

示例

• VBA
• Maxima CAS

如何查找数字类型

请注意，在具有有限精度的数值计算中（在计算机上） 

• 如果数字表示为比率（整数），则它是有理数。
• 如果数字具有浮点表示形式，那么它也是有理数，因为有限的精度等于有限的展开式。

/*

Maxima CAS batch file

*/

remvalue(all);
kill(all);

/*
input = ratio, which automatically changed to lowest terms by Maxima CAS
output = string describing a type of decimal expansion

---------------------------------------------------------------------------------
" The rules that determine whether a fraction has recurring decimals or 
not are really quite simple.

1. First represent the fraction in its simplest form, by dividing both 
numerator and denominator by common factors.

2. Now, look at the denominator.

3.
3.1 If the prime factorization of the denominator contains only the 
factors 2 and 5, then the decimal fraction of that fraction will not 
have recurring digits. In other words : Terminating decimals represent 
rational numbers of the form k/(2^n*5^m)

3.2
  A fraction in lowest terms with a prime denominator other than 2 or 5 
(i.e. coprime to 10) always produces a repeating decimal.

3.2.1
  If the prime factorization yields factors like 3, 7, 11 or other 
primes (other than 2 and 5), then that fraction will have a decimal 
representation that includes recurring digits.

3.2.2
   Moreover, if the denominator's prime factors include 2 and/or 5 in 
addition to other prime factors like 3, 7, etc., the decimal 
representation of the fraction will start with a few non-recurring 
decimals before the recurring part."

http://blogannath.blogspot.com/2010/04/vedic-mathematics-lesson-49-recurring.html

check :
http://www.knowledgedoor.com/2/calculators/convert_a_ratio_of_integers.html

wikipedia: Repeating_decimal
" A fraction in lowest terms with a prime denominator other than 2 or 5 (i.e. coprime to 10) always produces a repeating decimal.
The length of the repetend (period of the repeating decimal) of 1/p is equal to the order of 10 modulo p. 
If 10 is a primitive root modulo p, the repetend length is equal to p − 1; if not, 
the repetend length is a factor of p − 1. 
This result can be deduced from Fermat's little theorem, which states that 10p−1 = 1 (mod p)."

---------------------------------------------------------------------------------------

*/

GiveRatioType(ratio):=
block
(
   [denominator:denom(ratio),
    FactorsList ,
    Factor,
    Has25:false,
    HasAlsoOtherPrimes:false,
    type ], /* type of decimal expansion of the ratio of integers */

   /* compute list of prime factors ofd denominator */
   FactorsList:ifactors(denominator),
   FactorsList:map(first,FactorsList),
   print(denominator, FactorsList),
   /* check factors type :
          only 2 or 5
          also other primes then 2 or 5
  */
   if (member(2,FactorsList) or member(5,FactorsList)) then Has25:true,

   for Factor in FactorsList do
    if (not member(Factor,[2,5])) then
          HasAlsoOtherPrimes:true,
   print(Has25, HasAlsoOtherPrimes),

   /* find type of decimal expansion */
   if (not Has25 and HasAlsoOtherPrimes)     then type:"periodic",
   if (Has25 and HasAlsoOtherPrimes)     then type:"preperiodic",
   if (Has25 and not HasAlsoOtherPrimes) then type:"finite",

   return(type)
)$

compile(all)$

/* input numbers*/
a:1 $
b:3 $

r:a/b$

type :  GiveRatioType(r);

工具

• dumpfp：一个用于检查浮点数的工具，作者：Joshua Haberman
• float.exposed - 和 Bartosz Ciechanowski 的博客

更多

• 序列
  • 轨道
    • 周期
• 级数
• 基数
• 划分
• 随机数

基数

在数学（理论）中 

• "... 有理数是可数集，而无理数是不可数集。换句话说，无理数比有理数更多。"
• "... 在实数集中，存在无理数的连续统和只有 aleph-zero 有理数。因此，任何随机数是无理数的概率为 1;"（Bartek Ogryczak） "为了精确起见，你应该说几乎肯定为 1。"– David Hammen

以最简形式表示的有理数的高度

托马斯函数 = 1/q

  "a “height function” is some real-valued function that defines the “arithmetic complexity” of a point ... " Brian Lawrence

在有理数集上定义的高度函数的类型 $\mathbb {Q}$

• $H(p/q)=\max\{|p|,|q|\}$ 对于有理数的（乘法）高度 也称为 朴素高度
• $h(p/q)=\log H(p/q)$ 对数高度或加性

其中

• p/q 是最简形式的有理数

  "How complicated is a rational number? Its size is not a very good indicator for this. For instance, 1987985792837/1987985792836 is approximately 1, but so much more complicated than 1. We'll explain how to measure the complexity of a rational number using various notions of height. We'll  then see how heights are used to prove some basic finiteness theorems in number theory. One example will be the Mordell-Weil theorem: that on any rational elliptic curve, the group of rational points is finitely generated. " Alina Bucur (UCSD): Size Doesn't Matter: Heights in Number Theory

关键词

• 数域
• 数论中的高度函数

划分

• 划分函数 : "划分数的行为类似于分形，具有无限重复的结构"

随机数

任何随机数的概率 

• 是无理数几乎为 1（理论上，因为基数）
• 是有理数为 1（数值计算中，因为精度有限）

字段

• 概括 : 标量 / 向量 / 张量
• 字段 : 标量 , 向量, 张量

参考文献

• 数字的图解理论，作者 Martin H. Weissman

另请参阅

• 除数图：探索合数模式
• 单位球上的有理点：逼近复杂度和实际构造，作者 Daniel Bahrdt、Martin P. Seybold
• 离散数学：数字表示
• A-level_Computing：二进制小数
• 大象谷中的分数序列
• 分形：复平面中的迭代，尾流