1 / 42

資訊科學數學 9 : Integers, Algorithms & Orders

資訊科學數學 9 : Integers, Algorithms & Orders. 陳光琦助理教授 (Kuang-Chi Chen) chichen6@mail.tcu.edu.tw. Mini Review Methods. Useful Congruence Theorems. Theorem 1: Let a , b  Z , m  Z + . Then: a  b (mod m )   k  Z a = b + km .

donagh
Download Presentation

資訊科學數學 9 : Integers, Algorithms & Orders

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 資訊科學數學9 :Integers, Algorithms & Orders 陳光琦助理教授 (Kuang-Chi Chen) chichen6@mail.tcu.edu.tw

  2. Mini Review Methods

  3. Useful Congruence Theorems Theorem 1: Let a, bZ, mZ+. Then:ab (mod m)  kZa=b+km. Theorem 2: Let a, b, c, dZ, mZ+. Then if ab (mod m) and cd (mod m), then: . a+c b+d (mod m), and . ac  bd (mod m)

  4. Integers and Algorithms

  5. Integers & Algorithms Topics: • Euclidean algorithm for finding GCD’s. • Base-b representations of integers. - Especially: binary, hexadecimal, octal. - Also: Two’s complement representation of negative numbers. • Algorithms for computer arithmetic: - Binary addition, multiplication, division.

  6. Euclid’s Algorithm for GCD • Finding GCDs by comparing prime factorizations can be difficult when the prime factors are not known! • Euclid discovered: For all ints. a, b,gcd(a, b) = gcd((a mod b), b). • Sort a, b so that a>b, and then (given b>1)(a mod b) < a, so problem is simplified. Euclid325-265 B.C.

  7. Euclid’s Algorithm Example • gcd(372,164) = gcd(372 mod 164, 164). - 372 mod 164 = 372164[372/164] = 372164·2 = 372328 = 44. • gcd(164, 44) = gcd(164 mod 44, 44). - 164 mod 44 = 16444[164/44] = 16444·3 = 164132 = 32. • gcd(44, 32) = gcd(44 mod 32, 32) = gcd(12, 32) = gcd(32 mod 12, 12) = gcd(8, 12) = gcd(12 mod 8, 8) = gcd(4, 8) = gcd(8 mod 4, 4) = gcd(0, 4) = 4.

  8. Euclid’s Algorithm Pseudocode procedure gcd(a, b: positive integers) whileb  0 begin r≔amodb; a≔b; b≔r; end return a Sorting inputs not needed b/c order will be reversed each iteration. Fast! Number of while loop iterationsturns out to be O(log(max(a,b))).

  9. The “base b expansion of n” Base-b Number Systems • Ordinarily, we write base-10 representations of numbers, using digits 0-9. • But, 10 isn’t special! Any base b>1 will work. • For any positive integers n,b, there is a unique sequence ak ak-1… a1a0of digitsai<b such that:

  10. Used only because we have 10 fingers Used internally in all modern computers Octal digits correspond to groups of 3 bits Particular Bases of Interest • Base b=10 (decimal):10 digits: 0,1,2,3,4,5,6,7,8,9. • Base b=2 (binary):2 digits: 0,1. (“Bits”=“binary digits.”) • Base b=8 (octal):8 digits: 0,1,2,3,4,5,6,7. • Base b=16 (hexadecimal):16 digits: 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F Hex digits give groups of 4 bits

  11. Converting to Base b (An algorithm, informally stated.) • To convert any integer n to any base b>1: 1. To find the value of the rightmost (lowest-order) digit, simply compute n mod b. 2. Now, replace n with the quotient [n/b]. 3. Repeat above two steps to find subsequent digits, until n is gone (=0).

  12. Orders of Growth

  13. Orders of Growth • For functions over numbers, we often need to know a rough measure of how fast a function grows. • If f(x) is faster growing than g(x), then f(x) always eventually becomes larger than g(x) in the limit (for large enough values of x). • Useful in engineering for showing that one design scalesbetter or worse than another.

  14. Orders of Growth - Motivation • Suppose you are designing a web site to process user data (e.g., financial records). • Suppose database program A takes fA(n)=30n+8 microseconds to process any n records, while program B takes fB(n)=n2+1 microseconds to process the n records. Q: Which program do you choose, knowing you’ll want to support millions of users? A

  15. fB(n)=n2+1 Visualizing Orders of Growth • On a graph, asyou go to theright, the faster-growing function always eventuallybecomes thelarger one... fA(n)=30n+8 Value of function  Increasing n 

  16. Concept of Order of Growth • We say fA(n) = 30n+8is (at most) order n, or O(n). - It is, at most, roughly proportional to n. • fB(n) = n2+1 is order n2, or O(n2). - It is (at most) roughly proportional to n2. • Any function whose exact (tightest)order is O(n2) is faster-growing than any O(n) function. - Later we’ll introduce Θ for expressing exact order. • For large numbers of user records, the exactly order n2 function will always take more time.

  17. Definition: O(g), at mostorder g Let g be any function RR. • Define “at most order g”, written O(g), to be: {f: RR | c, k: x>k: f(x)  cg(x)}. - “Beyond some point k, function f is at most a constant c times g (i.e., proportional to g).” • “f is at most order g”, or “f is O(g)”, or “f=O(g)” all just mean that fO(g). (Often the phrase “at most” is omitted.)

  18. Points about The Definition • Note that f is O(g) so long as any values of c and k exist that satisfy the definition. • But, the particular c, k, values that make the statement true are not unique: Any larger value of c and/or k will also work. • No need to find the smallest c and k values that work. (Indeed, in some cases, there may be no smallest values!) However, you should prove that the values you choose do work.

  19. “Big-O” Proof Examples • Show that 30n+8 is O(n). Show c, k: n>k:30n+8  cn. Let c=31, k=8. Assume n>k=8. Thencn = 31n = 30n + n > 30n+8, so 30n+8 < cn. • Show that n2+1 is O(n2). Show c, k: n>k: n2+1  cn2. Let c=2, k=1. Assume n>1. Then cn2 = 2n2 = n2+n2 > n2+1, or n2+1< cn2.

  20. cn =31n n>k=8  Big-O Example, Graphically • Note 30n+8 isn’tless than nanywhere (n>0). • It isn’t evenless than 31neverywhere. • But it is less than31neverywhere tothe right of n=8. 30n+8 30n+8O(n) Value of function  n Increasing n 

  21. Useful Facts about Big O • Big O, as a relation, is transitive: fO(g)  gO(h)  fO(h) • O with constant multiples, roots, and logs... f (in (1)) & constantsa, bR, with b0,af, f 1-b, and (logbf)aare all O(f). • Sums of functions:If gO(f) and hO(f), then g+hO(f).

  22. More Big-O Facts • c>0, O(cf) = O(f+c) = O(fc) = O(f) f1O(g1)  f2O(g2)  - f1 f2 O(g1g2) - f1+f2 O(g1+g2) = O(max(g1, g2)) = O(g1) if g2O(g1) (Very useful!)

  23. Orders of Growth - So Far • For any g: RR, “at most order g”,O(g)  {f: RR | c, k x>k |f(x)|  |cg(x)|}. - Often, one deals only with positive functions and can ignore absolute value symbols. • “fO(g)” often written “f is O(g)”or “f = O(g)”. - The latter form is an instance of a more general convention...

  24. Order-of-Growth Expressions • “O(f)” when used as a term in an arithmetic expression means: “some function f such that fO(f)”. E.g., “x2+O(x)” means “x2 plus some function that is O(x)”. • Formally, we can think of any such expression as denoting a set of functions: x2+O(x) : {g | fO(x): g(x) = x2+f(x)}

  25. Order of Growth Equations • Suppose E1 and E2 are order-of-growth expressions corresponding to the sets of functions S and T, respectively. Then the “equation” E1=E2 really meansfS, gT : f = gor simply ST. Example: x2 + O(x) = O(x2) means fO(x): gO(x2): x2+f(x) = g(x)

  26. Useful Facts about Big O •  f, g & constantsa, bR, with b0, - af = O(f) (e.g. 3x2 = O(x2)) - f+O(f) = O(f) (e.g. x2+x = O(x2)) • Also, if f = (1) (at least order 1), then: - |f|1-b = O(f) (e.g.x1 = O(x)) - (logb |f|)a= O(f) (e.g. log x = O(x)) - g = O(fg) (e.g.x = O(x log x)) - fg O(g) (e.g.x log x  O(x)) - a= O(f) (e.g. 3 = O(x))

  27. Definition: (g), exactly orderg • If fO(g) and gO(f), then we say “g and f are of the same order” or “f is (exactly) order g” and write f(g). • Another, equivalent definition:(g)  {f:RR | c1c2k>0 x>k: |c1g(x)||f(x)||c2g(x)| } - “Everywhere beyond some point k, f(x)lies in between two multiples of g(x).”

  28. Rules for  • Mostly like rules for O( ), except: •  f,g>0 & constantsa,bR, with b>0,af (f), but  Same as with O.f  (fg) unless g=(1)  Unlike O.|f| 1-b (f), and  Unlike with O.(logb |f|)c (f).  Unlike with O. • The functions in the latter two cases we say are strictly of lower order than (f).

  29.  Example • Determine whether: • Quick solution:

  30. Other Order-of-Growth Relations • (g) = {f | gO(f)}“The functions that are at least orderg.” • o(g) = {f | c>0 k x>k : |f(x)| < |cg(x)|}“The functions that are strictly lower order than g.” o(g)  O(g)  (g). • (g) = {f | c>0 k x>k : |cg(x)| < |f(x)|}“The functions that are strictly higher order than g.” (g)  (g)  (g).

  31. Relations Between the Relations • Subset relations between order-of-growth sets. RR ( f ) O( f ) • f o( f ) ( f ) ( f )

  32. Why o(f)  O(x)(x) • A function that is O(x), but neither o(x) nor (x):

  33. Strict Ordering of Functions • Temporarily let’s write fg to mean fo(g),f~g to mean f(g) • Note that: • Let k>1. Then the following are true:1  log log n log n ~ logkn logknn1/k n n log nnkkn n! nn …

  34. Review: Orders of Growth Definitions of order-of-growth sets, g:RR • O(g) : {f|  c>0 k x>k |f(x)| < |cg(x)|} • o(g) : {f | c>0 k x>k |f(x)| < |cg(x)|} • (g) : {f | gO(f)} • (g) : {f | go(f)} • (g) : O(g)  (g)

  35. Addition of Binary Numbers procedureadd(an−1…a0, bn−1…b0: binary representations of non-negative integers a, b) carry := 0 forbitIndex := 0 to n−1 {go through bits} bitSum := abitIndex+bbitIndex+carry {2-bit sum} sbitIndex := bitSummod 2 {low bit of sum} carry := bitSum / 2 {high bit of sum} sn := carry returnsn…s0: binary representation of integer s

  36. Two’s Complement • In binary, negative numbers can be conveniently represented using two’s complement notation. • In this scheme, a string of n bits can represent any integer i such that −2n−1 ≤ i < 2n−1. • The bit in the highest-order bit-position (#n−1) represents a coefficient multiplying −2n−1; the other positions i < n−1 just represent 2i, as before. • The negation of any n-bit two’s complement number a = an−1…a0 is given by an−1…a0 + 1. The bitwise logical complement of the n-bit string an−1…a0.

  37. Correctness of Negation Algorithm Theorem: For an integer a represented in two’s complement notation, −a = a + 1. Proof:a = −an−12n−1 + an−22n−2 + … + a020, so −a = an−12n−1 − an−22n−2 − … − a020. Note an−12n−1= (1−an−1)2n−1 = 2n−1 − an−12n−1. But 2n−1 = 2n−2 + … + 20 + 1. So we have −a = − an−12n−1 + (1−an−2)2n−2 + … + (1−a0)20 + 1 = a + 1.

  38. Subtraction of Binary Numbers proceduresubtract(an−1…a0, bn−1…b0: binary two’s complement reps. of integers a, b) returnadd(a, add(b,1)) { a + (−b) } Note that this fails if either of the adds causes a carry into or out of the n−1 position, since 2n−2+2n−2 ≠ −2n−1, and −2n−1 + (−2n−1) = −2n isn’t representable! We call this an overflow.

  39. Multiplication of Binary Numbers proceduremultiply(an−1…a0, bn−1…b0: binary representations of a,bN) product := 0 fori := 0 to n−1 ifbi = 1 then product := add(an−1…a00i, product) returnproduct i extra 0-bitsappended afterthe digits of a

  40. Binary Division with Remainder procedurediv-mod(a,d Z+) {Quotient & rem. of a/d.} n := max(length of a in bits, length of d in bits) fori := n−1downto 0 ifa ≥ d0i then {Can we subtract at this position?} qi:=1 {This bit of quotient is 1.} a := a − d0i {Subtract to get remainder.} else qi:= 0 {This bit of quotient is 0.} r := a returnq,r {q = quotient, r = remainder}

More Related