Commit 8eaa98807b9525cb7f022e14cc8cff36f9ee7a06
2004-08-09T22:15:59
added libtommath-0.31
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384 6385 6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498 6499 6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595 6596 6597 6598 6599 6600 6601 6602 6603 6604 6605 6606 6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623 6624 6625 6626 6627 6628 6629 6630 6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792 6793 6794 6795 6796 6797 6798 6799 6800 6801 6802 6803 6804 6805 6806 6807 6808 6809 6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883 6884 6885 6886 6887 6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957 6958 6959 6960 6961 6962 6963 6964 6965 6966 6967 6968 6969 6970 6971 6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982 6983 6984 6985 6986 6987 6988 6989 6990 6991 6992 6993 6994 6995 6996 6997 6998 6999 7000 7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183 7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253 7254 7255 7256 7257 7258 7259 7260 7261 7262 7263 7264 7265 7266 7267 7268 7269 7270 7271 7272 7273 7274 7275 7276 7277 7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302 7303 7304 7305 7306 7307 7308 7309 7310 7311 7312 7313 7314 7315 7316 7317 7318 7319 7320 7321 7322 7323 7324 7325 7326 7327 7328 7329 7330 7331 7332 7333 7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344 7345 7346 7347 7348 7349 7350 7351 7352 7353 7354 7355 7356 7357 7358 7359 7360 7361 7362 7363 7364 7365 7366 7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379 7380 7381 7382 7383 7384 7385 7386 7387 7388 7389 7390 7391 7392 7393 7394 7395 7396 7397 7398 7399 7400 7401 7402 7403 7404 7405 7406 7407 7408 7409 7410 7411 7412 7413 7414 7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446 7447 7448 7449 7450 7451 7452 7453 7454 7455 7456 7457 7458 7459 7460 7461 7462 7463 7464 7465 7466 7467 7468 7469 7470 7471 7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516 7517 7518 7519 7520 7521 7522 7523 7524 7525 7526 7527 7528 7529 7530 7531 7532 7533 7534 7535 7536 7537 7538 7539 7540 7541 7542 7543 7544 7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555 7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567 7568 7569 7570 7571 7572 7573 7574 7575 7576 7577 7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588 7589 7590 7591 7592 7593 7594 7595 7596 7597 7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612 7613 7614 7615 7616 7617 7618 7619 7620 7621 7622 7623 7624 7625 7626 7627 7628 7629 7630 7631 7632 7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643 7644 7645 7646 7647 7648 7649 7650 7651 7652 7653 7654 7655 7656 7657 7658 7659 7660 7661 7662 7663 7664 7665 7666 7667 7668 7669 7670 7671 7672 7673 7674 7675 7676 7677 7678 7679 7680 7681 7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695 7696 7697 7698 7699 7700 7701 7702 7703 7704 7705 7706 7707 7708 7709 7710 7711 7712 7713 7714 7715 7716 7717 7718 7719 7720 7721 7722 7723 7724 7725 7726 7727 7728 7729 7730 7731 7732 7733 7734 7735 7736 7737 7738 7739 7740 7741 7742 7743 7744 7745 7746 7747 7748 7749 7750 7751 7752 7753 7754 7755 7756 7757 7758 7759 7760 7761 7762 7763 7764 7765 7766 7767 7768 7769 7770 7771 7772 7773 7774 7775 7776 7777 7778 7779 7780 7781 7782 7783 7784 7785 7786 7787 7788 7789 7790 7791 7792 7793 7794 7795 7796 7797 7798 7799 7800 7801 7802 7803 7804 7805 7806 7807 7808 7809 7810 7811 7812 7813 7814 7815 7816 7817 7818 7819 7820 7821 7822 7823 7824 7825 7826 7827 7828 7829 7830 7831 7832 7833 7834 7835 7836 7837 7838 7839 7840 7841 7842 7843 7844 7845 7846 7847 7848 7849 7850 7851 7852 7853 7854 7855 7856 7857 7858 7859 7860 7861 7862 7863 7864 7865 7866 7867 7868 7869 7870 7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886 7887 7888 7889 7890 7891 7892 7893 7894 7895 7896 7897 7898 7899 7900 7901 7902 7903 7904 7905 7906 7907 7908 7909 7910 7911 7912 7913 7914 7915 7916 7917 7918 7919 7920 7921 7922 7923 7924 7925 7926 7927 7928 7929 7930 7931 7932 7933 7934 7935 7936 7937 7938 7939 7940 7941 7942 7943 7944 7945 7946 7947 7948 7949 7950 7951 7952 7953 7954 7955 7956 7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985 7986 7987 7988 7989 7990 7991 7992 7993 7994 7995 7996 7997 7998 7999 8000 8001 8002 8003 8004 8005 8006 8007 8008 8009 8010 8011 8012 8013 8014 8015 8016 8017 8018 8019 8020 8021 8022 8023 8024 8025 8026 8027 8028 8029 8030 8031 8032 8033 8034 8035 8036 8037 8038 8039 8040 8041 8042 8043 8044 8045 8046 8047 8048 8049 8050 8051 8052 8053 8054 8055 8056 8057 8058 8059 8060 8061 8062 8063 8064 8065 8066 8067 8068 8069 8070 8071 8072 8073 8074 8075 8076 8077 8078 8079 8080 8081 8082 8083 8084 8085 8086 8087 8088 8089 8090 8091 8092 8093 8094 8095 8096 8097 8098 8099 8100 8101 8102 8103 8104 8105 8106 8107 8108 8109 8110 8111 8112 8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123 8124 8125 8126 8127 8128 8129 8130 8131 8132 8133 8134 8135 8136 8137 8138 8139 8140 8141 8142 8143 8144 8145 8146 8147 8148 8149 8150 8151 8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162 8163 8164 8165 8166 8167 8168 8169 8170 8171 8172 8173 8174 8175 8176 8177 8178 8179 8180 8181 8182 8183 8184 8185 8186 8187 8188 8189 8190 8191 8192 8193 8194 8195 8196 8197 8198 8199 8200 8201 8202 8203 8204 8205 8206 8207 8208 8209 8210 8211 8212 8213 8214 8215 8216 8217 8218 8219 8220 8221 8222 8223 8224 8225 8226 8227 8228 8229 8230 8231 8232 8233 8234 8235 8236 8237 8238 8239 8240 8241 8242 8243 8244 8245 8246 8247 8248 8249 8250 8251 8252 8253 8254 8255 8256 8257 8258 8259 8260 8261 8262 8263 8264 8265 8266 8267 8268 8269 8270 8271 8272 8273 8274 8275 8276 8277 8278 8279 8280 8281 8282 8283 8284 8285 8286 8287 8288 8289 8290 8291 8292 8293 8294 8295 8296 8297 8298 8299 8300 8301 8302 8303 8304 8305 8306 8307 8308 8309 8310 8311 8312 8313 8314 8315 8316 8317 8318 8319 8320 8321 8322 8323 8324 8325 8326 8327 8328 8329 8330 8331 8332 8333 8334 8335 8336 8337 8338 8339 8340 8341 8342 8343 8344 8345 8346 8347 8348 8349 8350 8351 8352 8353 8354 8355 8356 8357 8358 8359 8360 8361 8362 8363 8364 8365 8366 8367 8368 8369 8370 8371 8372 8373 8374 8375 8376 8377 8378 8379 8380 8381 8382 8383 8384 8385 8386 8387 8388 8389 8390 8391 8392 8393 8394 8395 8396 8397 8398 8399 8400 8401 8402 8403 8404 8405 8406 8407 8408 8409 8410 8411 8412 8413 8414 8415 8416 8417 8418 8419 8420 8421 8422 8423 8424 8425 8426 8427 8428 8429 8430 8431 8432 8433 8434 8435 8436 8437 8438 8439 8440 8441 8442 8443 8444 8445 8446 8447 8448 8449 8450 8451 8452 8453 8454 8455 8456 8457 8458 8459 8460 8461 8462 8463 8464 8465 8466 8467 8468 8469 8470 8471 8472 8473 8474 8475 8476 8477 8478 8479 8480 8481 8482 8483 8484 8485 8486 8487 8488 8489 8490 8491 8492 8493 8494 8495 8496 8497 8498 8499 8500 8501 8502 8503 8504 8505 8506 8507 8508 8509 8510 8511 8512 8513 8514 8515 8516 8517 8518 8519 8520 8521 8522 8523 8524 8525 8526 8527 8528 8529 8530 8531 8532 8533 8534 8535 8536 8537 8538 8539 8540 8541 8542 8543 8544 8545 8546 8547 8548 8549 8550 8551 8552 8553 8554 8555 8556 8557 8558 8559 8560 8561 8562 8563 8564 8565 8566 8567 8568 8569 8570 8571 8572 8573 8574 8575 8576 8577 8578 8579 8580 8581 8582 8583 8584 8585 8586 8587 8588 8589 8590 8591 8592 8593 8594 8595 8596 8597 8598 8599 8600 8601 8602 8603 8604 8605 8606 8607 8608 8609 8610 8611 8612 8613 8614 8615 8616 8617 8618 8619 8620 8621 8622 8623 8624 8625 8626 8627 8628 8629 8630 8631 8632 8633 8634 8635 8636 8637 8638 8639 8640 8641 8642 8643 8644 8645 8646 8647 8648 8649 8650 8651 8652 8653 8654 8655 8656 8657 8658 8659 8660 8661 8662 8663 8664 8665 8666 8667 8668 8669 8670 8671 8672 8673 8674 8675 8676 8677 8678 8679 8680 8681 8682 8683 8684 8685 8686 8687 8688 8689 8690 8691 8692 8693 8694 8695 8696 8697 8698 8699 8700 8701 8702 8703 8704 8705 8706 8707 8708 8709 8710 8711 8712 8713 8714 8715 8716 8717 8718 8719 8720 8721 8722 8723 8724 8725 8726 8727 8728 8729 8730 8731 8732 8733 8734 8735 8736 8737 8738 8739 8740 8741 8742 8743 8744 8745 8746 8747 8748 8749 8750 8751 8752 8753 8754 8755 8756 8757 8758 8759 8760 8761 8762 8763 8764 8765 8766 8767 8768 8769 8770 8771 8772 8773 8774 8775 8776 8777 8778 8779 8780 8781 8782 8783 8784 8785 8786 8787 8788 8789 8790 8791 8792 8793 8794 8795 8796 8797 8798 8799 8800 8801 8802 8803 8804 8805 8806 8807 8808 8809 8810 8811 8812 8813 8814 8815 8816 8817 8818 8819 8820 8821 8822 8823 8824 8825 8826 8827 8828 8829 8830 8831 8832 8833 8834 8835 8836 8837 8838 8839 8840 8841 8842 8843 8844 8845 8846 8847 8848 8849 8850 8851 8852 8853 8854 8855 8856 8857 8858 8859 8860 8861 8862 8863 8864 8865 8866 8867 8868 8869 8870 8871 8872 8873 8874 8875 8876 8877 8878 8879 8880 8881 8882 8883 8884 8885 8886 8887 8888 8889 8890 8891 8892 8893 8894 8895 8896 8897 8898 8899 8900 8901 8902 8903 8904 8905 8906 8907 8908 8909 8910 8911 8912 8913 8914 8915 8916 8917 8918 8919 8920 8921 8922 8923 8924 8925 8926 8927 8928 8929 8930 8931 8932 8933 8934 8935 8936 8937 8938 8939 8940 8941 8942 8943 8944 8945 8946 8947 8948 8949 8950 8951 8952 8953 8954 8955 8956 8957 8958 8959 8960 8961 8962 8963 8964 8965 8966 8967 8968 8969 8970 8971 8972 8973 8974 8975 8976 8977 8978 8979 8980 8981 8982 8983 8984 8985 8986 8987 8988 8989 8990 8991 8992 8993 8994 8995 8996 8997 8998 8999 9000 9001 9002 9003 9004 9005 9006 9007 9008 9009 9010 9011 9012 9013 9014 9015 9016 9017 9018 9019 9020 9021 9022 9023 9024 9025 9026 9027 9028 9029 9030 9031 9032 9033 9034 9035 9036 9037 9038 9039 9040 9041 9042 9043 9044 9045 9046 9047 9048 9049 9050 9051 9052 9053 9054 9055 9056 9057 9058 9059 9060 9061 9062 9063 9064 9065 9066 9067 9068 9069 9070 9071 9072 9073 9074 9075 9076 9077 9078 9079 9080 9081 9082 9083 9084 9085 9086 9087 9088 9089 9090 9091 9092 9093 9094 9095 9096 9097 9098 9099 9100 9101 9102 9103 9104 9105 9106 9107 9108 9109 9110 9111 9112 9113 9114 9115 9116 9117 9118 9119 9120 9121 9122 9123 9124 9125 9126 9127 9128 9129 9130 9131 9132 9133 9134 9135 9136 9137 9138 9139 9140 9141 9142 9143 9144 9145 9146 9147 9148 9149 9150 9151 9152 9153 9154 9155 9156 9157 9158 9159 9160 9161 9162 9163 9164 9165 9166 9167 9168 9169 9170 9171 9172 9173 9174 9175 9176 9177 9178 9179 9180 9181 9182 9183 9184 9185 9186 9187 9188 9189 9190 9191 9192 9193 9194 9195 9196 9197 9198 9199 9200 9201 9202 9203 9204 9205 9206 9207 9208 9209 9210 9211 9212 9213 9214 9215 9216 9217 9218 9219 9220 9221 9222 9223 9224 9225 9226 9227 9228 9229 9230 9231 9232 9233 9234 9235 9236 9237 9238 9239 9240 9241 9242 9243 9244 9245 9246 9247 9248 9249 9250 9251 9252 9253 9254 9255 9256 9257 9258 9259 9260 9261 9262 9263 9264 9265 9266 9267 9268 9269 9270 9271 9272 9273 9274 9275 9276 9277 9278 9279 9280 9281 9282 9283 9284 9285 9286 9287 9288 9289 9290 9291 9292 9293 9294 9295 9296 9297 9298 9299 9300 9301 9302 9303 9304 9305 9306 9307 9308 9309 9310 9311 9312 9313 9314 9315 9316 9317 9318 9319 9320 9321 9322 9323 9324 9325 9326 9327 9328 9329 9330 9331 9332 9333 9334 9335 9336 9337 9338 9339 9340 9341 9342 9343 9344 9345 9346 9347 9348 9349 9350 9351 9352 9353 9354 9355 9356 9357 9358 9359 9360 9361 9362 9363 9364 9365 9366 9367 9368 9369 9370 9371 9372 9373 9374 9375 9376 9377 9378 9379 9380 9381 9382 9383 9384 9385 9386 9387 9388 9389 9390 9391 9392 9393 9394 9395 9396 9397 9398 9399 9400 9401 9402 9403 9404 9405 9406 9407 9408 9409 9410 9411 9412 9413 9414 9415 9416 9417 9418 9419 9420 9421 9422 9423 9424 9425 9426 9427 9428 9429 9430 9431 9432 9433 9434 9435 9436 9437 9438 9439 9440 9441 9442 9443 9444 9445 9446 9447 9448 9449 9450 9451 9452 9453 9454 9455 9456 9457 9458 9459 9460 9461 9462 9463 9464 9465 9466 9467 9468 9469 9470 9471 9472 9473 9474 9475 9476 9477 9478 9479 9480 9481 9482 9483 9484 9485 9486 9487 9488 9489 9490 9491 9492 9493 9494 9495 9496 9497 9498 9499 9500 9501 9502 9503 9504 9505 9506 9507 9508 9509 9510 9511 9512 9513 9514 9515 9516 9517 9518 9519 9520 9521 9522 9523 9524 9525 9526 9527 9528 9529 9530 9531 9532 9533 9534 9535 9536 9537 9538 9539 9540 9541 9542 9543 9544 9545 9546 9547 9548 9549 9550 9551 9552 9553 9554 9555 9556 9557 9558 9559 9560 9561 9562 9563 9564 9565 9566 9567 9568 9569 9570 9571 9572 9573 9574 9575 9576 9577 9578 9579 9580 9581 9582 9583 9584 9585 9586 9587 9588 9589 9590 9591 9592 9593 9594 9595 9596 9597 9598 9599 9600 9601 9602 9603 9604 9605 9606 9607 9608 9609 9610 9611 9612 9613 9614 9615 9616 9617 9618 9619 9620 9621 9622 9623 9624 9625 9626 9627 9628 9629 9630 9631 9632 9633 9634 9635 9636 9637 9638 9639 9640 9641 9642 9643 9644 9645 9646 9647 9648 9649 9650 9651 9652 9653 9654 9655 9656 9657 9658 9659 9660 9661 9662 9663 9664 9665 9666 9667 9668 9669 9670 9671 9672 9673 9674 9675 9676 9677 9678 9679 9680 9681 9682 9683 9684 9685 9686 9687 9688 9689 9690 9691 9692 9693 9694 9695 9696 9697 9698 9699 9700 9701 9702 9703 9704 9705 9706 9707 9708 9709 9710 9711 9712 9713 9714 9715 9716 9717 9718 9719 9720 9721 9722 9723 9724 9725 9726 9727 9728 9729 9730 9731 9732 9733 9734 9735 9736 9737 9738 9739 9740 9741 9742 9743 9744 9745 9746 9747 9748 9749 9750 9751 9752 9753 9754 9755 9756 9757 9758 9759 9760 9761 9762 9763 9764 9765 9766 9767 9768 9769 9770 9771 9772 9773 9774 9775 9776 9777 9778 9779 9780 9781 9782 9783 9784 9785 9786 9787 9788 9789 9790 9791 9792 9793 9794 9795 9796 9797 9798 9799 9800 9801 9802 9803 9804 9805 9806 9807 9808 9809 9810 9811 9812 9813 9814 9815 9816 9817 9818 9819 9820 9821 9822 9823 9824 9825 9826 9827 9828 9829 9830 9831 9832 9833 9834 9835 9836 9837 9838 9839 9840 9841 9842 9843 9844 9845 9846 9847 9848 9849 9850 9851 9852 9853 9854 9855 9856 9857 9858 9859 9860 9861 9862 9863 9864 9865 9866 9867 9868 9869 9870 9871 9872 9873 9874 9875 9876 9877 9878 9879 9880 9881 9882 9883 9884 9885 9886 9887 9888 9889 9890 9891 9892 9893 9894 9895 9896 9897 9898 9899 9900 9901 9902 9903 9904 9905 9906 9907 9908 9909 9910 9911 9912 9913 9914 9915 9916 9917 9918 9919 9920 9921 9922 9923 9924 9925 9926 9927 9928 9929 9930 9931 9932 9933 9934 9935 9936 9937 9938 9939 9940 9941 9942 9943 9944 9945 9946 9947 9948 9949 9950 9951 9952 9953 9954 9955 9956 9957 9958 9959 9960 9961 9962 9963 9964 9965 9966 9967 9968 9969 9970 9971 9972 9973 9974 9975 9976 9977 9978 9979 9980 9981 9982 9983 9984 9985 9986 9987 9988 9989 9990 9991 9992 9993 9994 9995 9996 9997 9998 9999 10000 10001 10002 10003 10004 10005 10006 10007 10008 10009 10010 10011 10012 10013 10014 10015 10016 10017 10018 10019 10020 10021 10022 10023 10024 10025 10026 10027 10028 10029 10030 10031 10032 10033 10034 10035 10036 10037 10038 10039 10040 10041 10042 10043 10044 10045 10046 10047 10048 10049 10050 10051 10052 10053 10054 10055 10056 10057 10058 10059 10060 10061 10062 10063 10064 10065 10066 10067 10068 10069 10070 10071 10072 10073 10074 10075 10076 10077 10078 10079 10080 10081 10082 10083 10084 10085 10086 10087 10088 10089 10090 10091 10092 10093 10094 10095 10096 10097 10098 10099 10100 10101 10102 10103 10104 10105 10106 10107 10108 10109 10110 10111 10112 10113 10114 10115 10116 10117 10118 10119 10120 10121 10122 10123 10124 10125 10126 10127 10128 10129 10130 10131 10132 10133 10134 10135 10136 10137 10138 10139 10140 10141 10142 10143 10144 10145 10146 10147 10148 10149 10150 10151 10152 10153 10154 10155 10156 10157 10158 10159 10160 10161 10162 10163 10164 10165 10166 10167 10168 10169 10170 10171 10172 10173 10174 10175 10176 10177 10178 10179 10180 10181 10182 10183 10184 10185 10186 10187 10188 10189 10190 10191 10192 10193 10194 10195 10196 10197 10198 10199 10200 10201 10202 10203 10204 10205 10206 10207 10208 10209 10210 10211 10212 10213 10214 10215 10216 10217 10218 10219 10220 10221 10222 10223 10224 10225 10226 10227 10228 10229 10230 10231 10232 10233 10234 10235 10236 10237 10238 10239 10240 10241 10242 10243 10244 10245 10246 10247 10248 10249 10250 10251 10252 10253 10254 10255 10256 10257 10258 10259 10260 10261 10262 10263 10264 10265 10266 10267 10268 10269 10270 10271 10272 10273 10274 10275 10276 10277 10278 10279 10280 10281 10282 10283 10284 10285 10286 10287 10288 10289 10290 10291 10292 10293 10294 10295 10296 10297 10298 10299 10300 10301 10302 10303 10304 10305 10306 10307 10308 10309 10310 10311 10312 10313 10314 10315 10316 10317 10318 10319 10320 10321 10322 10323 10324 10325 10326 10327 10328 10329 10330 10331 10332 10333 10334 10335 10336 10337 10338 10339 10340 10341 10342 10343 10344 10345 10346 10347 10348 10349 10350 10351 10352 10353 10354 10355 10356 10357 10358 10359 10360 10361 10362 10363 10364 10365 10366 10367 10368 10369 10370 10371 10372 10373 10374 10375 10376 10377 10378 10379 10380 10381 10382 10383 10384 10385 10386 10387 10388 10389 10390 10391 10392 10393 10394 10395 10396 10397 10398 10399 10400 10401 10402 10403 10404 10405 10406 10407 10408 10409 10410 10411 10412 10413 10414 10415 10416 10417 10418 10419 10420 10421 10422 10423 10424 10425 10426 10427 10428 10429 10430 10431 10432 10433 10434 10435 10436 10437 10438 10439 10440 10441 10442 10443 10444 10445 10446 10447 10448 10449 10450 10451 10452 10453 10454 10455 10456 10457 10458 10459 10460 10461 10462 10463 10464 10465 10466 10467 10468 10469 10470 10471 10472 10473 10474 10475 10476 10477 10478 10479 10480 10481 10482 10483 10484 10485 10486 10487 10488 10489 10490 10491 10492 10493 10494 10495 10496 10497 10498 10499 10500 10501 10502 10503 10504 10505 10506 10507 10508 10509 10510 10511 10512 10513 10514 10515 10516 10517 10518 10519 10520 10521 10522 10523 10524 10525 10526 10527 10528 10529 10530 10531 10532 10533 10534 10535 10536 10537 10538 10539 10540 10541 10542 10543 10544 10545 10546 10547 10548 10549 10550 10551 10552 10553 10554 10555 10556 10557 10558 10559 10560 10561 10562 10563 10564 10565 10566 10567 10568 10569 10570 10571 10572 10573 10574 10575 10576 10577 10578 10579 10580 10581 10582 10583 10584 10585 10586 10587 10588 10589 10590 10591 10592 10593 10594 10595 10596 10597 10598 10599 10600 10601 10602 10603 10604 10605 10606 10607 10608 10609 10610 10611 10612 10613 10614 10615 10616 10617 10618 10619 10620 10621 10622 10623 10624 10625 10626 10627 10628 10629 10630 10631 10632 10633 10634 10635 10636 10637 10638 10639 10640 10641 10642 10643 10644 10645 10646 10647 10648 10649 10650 10651 10652 10653 10654 10655 10656 10657 10658 10659 10660 10661 10662 10663 10664 10665 10666 10667 10668 10669 10670 10671 10672 10673 10674 10675 10676 10677 10678 10679 10680 10681 10682 10683 10684 10685 10686 10687 10688 10689 10690 10691 10692 10693 10694 10695 10696 10697 10698 10699 10700 10701 10702 10703 10704 10705 10706 10707 10708 10709 10710 10711 10712 10713 10714 10715 10716 10717 10718 10719 10720 10721 10722 10723 10724 10725 10726 10727 10728 10729 10730 10731 10732 10733 10734 10735 10736 10737 10738 10739 10740 10741 10742 10743 10744 10745 10746 10747 10748 10749 10750 10751 10752 10753 10754 10755 10756 10757 10758 10759 10760 10761 10762 10763 10764 10765 10766 10767 10768 10769 10770 10771 10772 10773 10774 10775 10776 10777 10778 10779 10780 10781 10782 10783 10784 10785 10786 10787 10788 10789 10790 10791 10792 10793 10794 10795 10796 10797 10798 10799 10800 10801 10802 10803 10804 10805 10806 10807 10808 10809 10810 10811 10812 10813 10814 10815 10816 10817 10818 10819 10820 10821 10822 10823 10824 10825 10826 10827 10828 10829 10830 10831 10832 10833 10834 10835 10836 10837 10838 10839 10840 10841 10842 10843 10844 10845 10846 10847 10848 10849 10850 10851 10852 10853 10854 10855 10856 10857 10858 10859 10860 10861 10862 10863 10864 10865 10866 10867 10868 10869 10870 10871 10872 10873 10874 10875 10876 10877 10878 10879 10880 10881 10882 10883 10884 10885 10886 10887 10888 10889 10890 10891 10892 10893 10894 10895 10896 10897 10898 10899 10900 10901 10902 10903 10904 10905 10906 10907 10908 10909 10910 10911 10912 10913 10914 10915 10916 10917 10918 10919 10920 10921 10922 10923 10924 10925 10926 10927 10928 10929 10930 10931 10932 10933 10934 10935 10936 10937 10938 10939 10940 10941 10942 10943 10944 10945 10946 10947 10948 10949 10950 10951 10952 10953 10954 10955 10956 10957 10958 10959 10960 10961 10962 10963 10964 10965 10966 10967 10968 10969 10970 10971 10972 10973 10974 10975 10976 10977 10978 10979 10980 10981 10982 10983 10984 10985 10986 10987 10988 10989 10990 10991 10992 10993 10994 10995 10996 10997 10998 10999 11000 11001 11002 11003 11004 11005 11006 11007 11008 11009 11010 11011 11012 11013 11014 11015 11016 11017 11018 11019 11020 11021 11022 11023 11024 11025 11026 11027 11028 11029 11030 11031 11032 11033 11034 11035 11036 11037 11038 11039 11040 11041 11042 11043 11044 11045 11046 11047 11048 11049 11050 11051 11052 11053 11054 11055 11056 11057 11058 11059 11060 11061 11062 11063 11064 11065 11066 11067 11068 11069 11070 11071 11072 11073 11074 11075 11076 11077 11078 11079 11080 11081 11082 11083 11084 11085 11086 11087 11088 11089 11090 11091 11092 11093 11094 11095 11096 11097 11098 11099 11100 11101 11102 11103 11104 11105 11106 11107 11108 11109 11110 11111 11112 11113 11114 11115 11116 11117 11118 11119 11120 11121 11122 11123 11124 11125 11126 11127 11128 11129 11130 11131 11132 11133 11134 11135 11136 11137 11138 11139 11140 11141 11142 11143 11144 11145 11146 11147 11148 11149 11150 11151 11152 11153 11154 11155 11156 11157 11158 11159 11160 11161 11162 11163 11164 11165 11166 11167 11168 11169 11170 11171 11172 11173 11174 11175 11176 11177 11178 11179 11180 11181 11182 11183 11184 11185 11186 11187 11188 11189 11190 11191 11192 11193 11194 11195 11196 11197 11198 11199 11200 11201 11202 11203 11204 11205 11206 11207 11208 11209 11210 11211 11212 11213 11214 11215 11216 11217 11218 11219 11220 11221 11222 11223 11224 11225 11226 11227 11228 11229 11230 11231 11232 11233 11234 11235 11236 11237 11238 11239 11240 11241 11242 11243 11244 11245 11246 11247 11248 11249 11250 11251 11252 11253 11254 11255 11256 11257 11258 11259 11260 11261 11262 11263 11264 11265 11266 11267 11268 11269 11270 11271 11272 11273 11274 11275 11276 11277 11278 11279 11280 11281 11282 11283 11284 11285 11286 11287 11288 11289 11290 11291 11292 11293 11294 11295 11296 11297 11298 11299 11300 11301 11302 11303 11304 11305 11306 11307 11308 11309 11310 11311 11312 11313 11314 11315 11316 11317 11318 11319 11320 11321 11322 11323 11324 11325 11326 11327 11328 11329 11330 11331 11332 11333 11334 11335 11336 11337 11338 11339 11340 11341 11342 11343 11344 11345 11346 11347 11348 11349 11350 11351 11352 11353 11354 11355 11356 11357 11358 11359 11360 11361 11362 11363 11364 11365 11366 11367 11368 11369 11370 11371 11372 11373 11374 11375 11376 11377 11378 11379 11380 11381 11382 11383 11384 11385 11386 11387 11388 11389 11390 11391 11392 11393 11394 11395 11396 11397 11398 11399 11400 11401 11402 11403 11404 11405 11406 11407 11408 11409 11410 11411 11412 11413 11414 11415 11416 11417 11418 11419 11420 11421 11422 11423 11424 11425 11426 11427 11428 11429 11430 11431 11432 11433 11434 11435 11436 11437 11438 11439 11440 11441 11442 11443 11444 11445 11446 11447 11448 11449 11450 11451 11452 11453 11454 11455 11456 11457 11458 11459 11460 11461 11462 11463 11464 11465 11466 11467 11468 11469 11470 11471 11472 11473 11474 11475 11476 11477 11478 11479 11480 11481 11482 11483 11484 11485 11486 11487 11488 11489 11490 11491 11492 11493 11494 11495 11496 11497 11498 11499 11500 11501 11502 11503 11504 11505 11506 11507 11508 11509 11510 11511 11512 11513 11514 11515 11516 11517 11518 11519 11520 11521 11522 11523 11524 11525 11526 11527 11528 11529 11530 11531 11532 11533 11534 11535 11536 11537 11538 11539 11540 11541 11542 11543 11544 11545 11546 11547 11548 11549 11550 11551 11552 11553 11554 11555 11556 11557 11558 11559 11560 11561 11562 11563 11564 11565 11566 11567 11568 11569 11570 11571 11572 11573 11574 11575 11576 11577 11578 11579 11580 11581 11582 11583 11584 11585 11586 11587 11588 11589 11590 11591 11592 11593 11594 11595 11596 11597 11598 11599 11600 11601 11602 11603 11604 11605 11606 11607 11608 11609 11610 11611 11612 11613 11614 11615 11616 11617 11618 11619 11620 11621 11622 11623 11624 11625 11626 11627 11628 11629 11630 11631 11632 11633 11634 11635 11636 11637 11638 11639 11640 11641 11642 11643 11644 11645 11646 11647 11648 11649 11650 11651 11652 11653 11654 11655 11656 11657 11658 11659 11660 11661 11662 11663 11664 11665 11666 11667 11668 11669 11670 11671 11672 11673 11674 11675 11676 11677 11678 11679 11680 11681 11682 11683 11684 11685 11686 11687 11688 11689 11690 11691 11692 11693 11694 11695 11696 11697 11698 11699 11700 11701 11702 11703 11704 11705 11706 11707 11708 11709 11710 11711 11712 11713 11714 11715 11716 11717 11718 11719 11720 11721 11722 11723 11724 11725 11726 11727 11728 11729 11730 11731 11732 11733 11734 11735 11736 11737 11738 11739 11740 11741 11742 11743 11744 11745 11746 11747 11748 11749 11750 11751 11752 11753 11754 11755 11756 11757 11758 11759 11760 11761 11762 11763 11764 11765 11766 11767 11768 11769 11770 11771 11772 11773 11774 11775 11776 11777 11778 11779 11780 11781 11782 11783 11784 11785 11786 11787 11788 11789 11790 11791 11792 11793 11794 11795 11796 11797 11798 11799 11800 11801 11802 11803 11804 11805 11806 11807 11808 11809 11810 11811 11812 11813 11814 11815 11816 11817 11818 11819 11820 11821 11822 11823 11824 11825 11826 11827 11828 11829 11830 11831 11832 11833 11834 11835 11836 11837 11838 11839 11840 11841 11842 11843 11844 11845 11846 11847 11848 11849 11850 11851 11852 11853 11854 11855 11856 11857 11858 11859 11860 11861 11862 11863 11864 11865 11866 11867 11868 11869 11870 11871 11872 11873 11874 11875 11876 11877 11878 11879 11880 11881 11882 11883 11884 11885 11886 11887 11888 11889 11890 11891 11892 11893 11894 11895 11896 11897 11898 11899 11900 11901 11902 11903 11904 11905 11906 11907 11908 11909 11910 11911 11912 11913 11914 11915 11916 11917 11918 11919 11920 11921 11922 11923 11924 11925 11926 11927 11928 11929 11930 11931 11932 11933 11934 11935 11936 11937 11938 11939 11940 11941 11942 11943 11944 11945 11946 11947 11948 11949 11950 11951 11952 11953 11954 11955 11956 11957 11958 11959 11960 11961 11962 11963 11964 11965 11966 11967 11968 11969 11970 11971 11972 11973 11974 11975 11976 11977 11978 11979 11980 11981 11982 11983 11984 11985 11986 11987 11988 11989 11990 11991 11992 11993 11994 11995 11996 11997 11998 11999 12000 12001 12002 12003 12004 12005 12006 12007 12008 12009 12010 12011 12012 12013 12014 12015 12016 12017 12018 12019 12020 12021 12022 12023 12024 12025 12026 12027 12028 12029 12030 12031 12032 12033 12034 12035 12036
diff --git a/bn.pdf b/bn.pdf
index 52421fd..bf80e6a 100644
Binary files a/bn.pdf and b/bn.pdf differ
diff --git a/bn.tex b/bn.tex
index a254586..3d1d26d 100644
--- a/bn.tex
+++ b/bn.tex
@@ -49,7 +49,7 @@
\begin{document}
\frontmatter
\pagestyle{empty}
-\title{LibTomMath User Manual \\ v0.30}
+\title{LibTomMath User Manual \\ v0.31}
\author{Tom St Denis \\ tomstdenis@iahu.ca}
\maketitle
This text, the library and the accompanying textbook are all hereby placed in the public domain. This book has been
diff --git a/bn_fast_s_mp_mul_digs.c b/bn_fast_s_mp_mul_digs.c
index 75fa706..d268df3 100644
--- a/bn_fast_s_mp_mul_digs.c
+++ b/bn_fast_s_mp_mul_digs.c
@@ -88,7 +88,7 @@ fast_s_mp_mul_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
}
/* setup dest */
- olduse = c->used;
+ olduse = c->used;
c->used = digs;
{
diff --git a/bn_mp_2expt.c b/bn_mp_2expt.c
index 5c4e256..502e85b 100644
--- a/bn_mp_2expt.c
+++ b/bn_mp_2expt.c
@@ -36,7 +36,7 @@ mp_2expt (mp_int * a, int b)
a->used = b / DIGIT_BIT + 1;
/* put the single bit in its place */
- a->dp[b / DIGIT_BIT] = 1 << (b % DIGIT_BIT);
+ a->dp[b / DIGIT_BIT] = ((mp_digit)1) << (b % DIGIT_BIT);
return MP_OKAY;
}
diff --git a/bn_mp_clear.c b/bn_mp_clear.c
index afe9b26..cd439df 100644
--- a/bn_mp_clear.c
+++ b/bn_mp_clear.c
@@ -18,10 +18,14 @@
void
mp_clear (mp_int * a)
{
+ int i;
+
/* only do anything if a hasn't been freed previously */
if (a->dp != NULL) {
/* first zero the digits */
- memset (a->dp, 0, sizeof (mp_digit) * a->used);
+ for (i = 0; i < a->used; i++) {
+ a->dp[i] = 0;
+ }
/* free ram */
XFREE(a->dp);
diff --git a/bn_mp_div.c b/bn_mp_div.c
index 652a094..ea2d514 100644
--- a/bn_mp_div.c
+++ b/bn_mp_div.c
@@ -187,7 +187,7 @@ int mp_div (mp_int * a, mp_int * b, mp_int * c, mp_int * d)
*/
/* get sign before writing to c */
- x.sign = a->sign;
+ x.sign = x.used == 0 ? MP_ZPOS : a->sign;
if (c != NULL) {
mp_clamp (&q);
diff --git a/bn_mp_init.c b/bn_mp_init.c
index 5c5c1ad..cac782a 100644
--- a/bn_mp_init.c
+++ b/bn_mp_init.c
@@ -14,15 +14,22 @@
*/
#include <tommath.h>
-/* init a new bigint */
+/* init a new mp_int */
int mp_init (mp_int * a)
{
+ int i;
+
/* allocate memory required and clear it */
- a->dp = OPT_CAST(mp_digit) XCALLOC (sizeof (mp_digit), MP_PREC);
+ a->dp = OPT_CAST(mp_digit) XMALLOC (sizeof (mp_digit) * MP_PREC);
if (a->dp == NULL) {
return MP_MEM;
}
+ /* set the digits to zero */
+ for (i = 0; i < MP_PREC; i++) {
+ a->dp[i] = 0;
+ }
+
/* set the used to zero, allocated digits to the default precision
* and sign to positive */
a->used = 0;
diff --git a/bn_mp_karatsuba_mul.c b/bn_mp_karatsuba_mul.c
index 169dacf..105590e 100644
--- a/bn_mp_karatsuba_mul.c
+++ b/bn_mp_karatsuba_mul.c
@@ -76,9 +76,6 @@ int mp_karatsuba_mul (mp_int * a, mp_int * b, mp_int * c)
goto X0Y0;
/* now shift the digits */
- x0.sign = x1.sign = a->sign;
- y0.sign = y1.sign = b->sign;
-
x0.used = y0.used = B;
x1.used = a->used - B;
y1.used = b->used - B;
diff --git a/bn_mp_mul.c b/bn_mp_mul.c
index 6f3c491..8e11f9f 100644
--- a/bn_mp_mul.c
+++ b/bn_mp_mul.c
@@ -43,6 +43,6 @@ int mp_mul (mp_int * a, mp_int * b, mp_int * c)
res = s_mp_mul (a, b, c);
}
}
- c->sign = neg;
+ c->sign = (c->used > 0) ? neg : MP_ZPOS;
return res;
}
diff --git a/bn_mp_reduce_is_2k.c b/bn_mp_reduce_is_2k.c
index d43b9ff..cc36115 100644
--- a/bn_mp_reduce_is_2k.c
+++ b/bn_mp_reduce_is_2k.c
@@ -17,7 +17,8 @@
/* determines if mp_reduce_2k can be used */
int mp_reduce_is_2k(mp_int *a)
{
- int ix, iy, iz, iw;
+ int ix, iy, iw;
+ mp_digit iz;
if (a->used == 0) {
return 0;
@@ -34,7 +35,7 @@ int mp_reduce_is_2k(mp_int *a)
return 0;
}
iz <<= 1;
- if (iz > (int)MP_MASK) {
+ if (iz > (mp_digit)MP_MASK) {
++iw;
iz = 1;
}
diff --git a/bncore.c b/bncore.c
index acb78a0..918a99a 100644
--- a/bncore.c
+++ b/bncore.c
@@ -18,14 +18,16 @@
CPU /Compiler /MUL CUTOFF/SQR CUTOFF
-------------------------------------------------------------
- Intel P4 /GCC v3.2 / 70/ 108
- AMD Athlon XP /GCC v3.2 / 109/ 127
-
+ Intel P4 Northwood /GCC v3.3.3 / 59/ 81/profiled build
+ Intel P4 Northwood /GCC v3.3.3 / 59/ 80/profiled_single build
+ Intel P4 Northwood /ICC v8.0 / 57/ 70/profiled build
+ Intel P4 Northwood /ICC v8.0 / 54/ 76/profiled_single build
+ AMD Athlon XP /GCC v3.2 / 109/ 127/
+
*/
-/* configured for a AMD XP Thoroughbred core with etc/tune.c */
-int KARATSUBA_MUL_CUTOFF = 109, /* Min. number of digits before Karatsuba multiplication is used. */
- KARATSUBA_SQR_CUTOFF = 127, /* Min. number of digits before Karatsuba squaring is used. */
+int KARATSUBA_MUL_CUTOFF = 57, /* Min. number of digits before Karatsuba multiplication is used. */
+ KARATSUBA_SQR_CUTOFF = 70, /* Min. number of digits before Karatsuba squaring is used. */
TOOM_MUL_CUTOFF = 350, /* no optimal values of these are known yet so set em high */
TOOM_SQR_CUTOFF = 400;
diff --git a/booker.pl b/booker.pl
index 4f4231f..de28780 100644
--- a/booker.pl
+++ b/booker.pl
@@ -84,6 +84,7 @@ while (<IN>) {
$text[$line++] = $_;
last if ($_ =~ /tommath\.h/);
}
+ <SRC>;
}
$inline = 0;
diff --git a/changes.txt b/changes.txt
index 63e9d61..c90d27a 100644
--- a/changes.txt
+++ b/changes.txt
@@ -1,3 +1,12 @@
+August 9th, 2004
+v0.31 -- "profiled" builds now :-) new timings for Intel Northwoods
+ -- Added "pretty" build target
+ -- Update mp_init() to actually assign 0's instead of relying on calloc()
+ -- "Wolfgang Ehrhardt" <Wolfgang.Ehrhardt@munich.netsurf.de> found a bug in mp_mul() where if
+ you multiply a negative by zero you get negative zero as the result. Oops.
+ -- J Harper from PeerSec let me toy with his AMD64 and I got 60-bit digits working properly
+ [this also means that I fixed a bug where if sizeof(int) < sizeof(mp_digit) it would bug]
+
April 11th, 2004
v0.30 -- Added "mp_toradix_n" which stores upto "n-1" least significant digits of an mp_int
-- Johan Lindh sent a patch so MSVC wouldn't whine about redefining malloc [in weird dll modes]
diff --git a/demo/demo.c b/demo/demo.c
index 8014ea8..8cbcb8a 100644
--- a/demo/demo.c
+++ b/demo/demo.c
@@ -1,7 +1,5 @@
#include <time.h>
-#define TESTING
-
#ifdef IOWNANATHLON
#include <unistd.h>
#define SLEEP sleep(4)
@@ -11,49 +9,6 @@
#include "tommath.h"
-#ifdef TIMER
-ulong64 _tt;
-
-#if defined(__i386__) || defined(_M_IX86) || defined(_M_AMD64)
-/* RDTSC from Scott Duplichan */
-static ulong64 TIMFUNC (void)
- {
- #if defined __GNUC__
- #ifdef __i386__
- ulong64 a;
- __asm__ __volatile__ ("rdtsc ":"=A" (a));
- return a;
- #else /* gcc-IA64 version */
- unsigned long result;
- __asm__ __volatile__("mov %0=ar.itc" : "=r"(result) :: "memory");
- while (__builtin_expect ((int) result == -1, 0))
- __asm__ __volatile__("mov %0=ar.itc" : "=r"(result) :: "memory");
- return result;
- #endif
-
- // Microsoft and Intel Windows compilers
- #elif defined _M_IX86
- __asm rdtsc
- #elif defined _M_AMD64
- return __rdtsc ();
- #elif defined _M_IA64
- #if defined __INTEL_COMPILER
- #include <ia64intrin.h>
- #endif
- return __getReg (3116);
- #else
- #error need rdtsc function for this build
- #endif
- }
-#else
-#define TIMFUNC clock
-#endif
-
-ulong64 rdtsc(void) { return TIMFUNC() - _tt; }
-void reset(void) { _tt = TIMFUNC(); }
-
-#endif
-
void ndraw(mp_int *a, char *name)
{
char buf[4096];
@@ -89,10 +44,6 @@ int myrng(unsigned char *dst, int len, void *dat)
}
-#define DO2(x) x; x;
-#define DO4(x) DO2(x); DO2(x);
-#define DO8(x) DO4(x); DO4(x);
-#define DO(x) DO8(x); DO8(x);
char cmd[4096], buf[4096];
int main(void)
@@ -103,10 +54,6 @@ int main(void)
unsigned rr;
int i, n, err, cnt, ix, old_kara_m, old_kara_s;
-#ifdef TIMER
- ulong64 tt, CLK_PER_SEC;
- FILE *log, *logb, *logc;
-#endif
mp_init(&a);
mp_init(&b);
@@ -117,11 +64,10 @@ int main(void)
srand(time(NULL));
-#ifdef TESTING
// test mp_get_int
printf("Testing: mp_get_int\n");
for(i=0;i<1000;++i) {
- t = (unsigned long)rand()*rand()+1;
+ t = ((unsigned long)rand()*rand()+1)&0xFFFFFFFF;
mp_set_int(&a,t);
if (t!=mp_get_int(&a)) {
printf("mp_get_int() bad result!\n");
@@ -141,7 +87,7 @@ int main(void)
// test mp_sqrt
printf("Testing: mp_sqrt\n");
- for (i=0;i<10000;++i) {
+ for (i=0;i<1000;++i) {
printf("%6d\r", i); fflush(stdout);
n = (rand()&15)+1;
mp_rand(&a,n);
@@ -157,7 +103,7 @@ int main(void)
}
printf("\nTesting: mp_is_square\n");
- for (i=0;i<100000;++i) {
+ for (i=0;i<1000;++i) {
printf("%6d\r", i); fflush(stdout);
/* test mp_is_square false negatives */
@@ -186,11 +132,9 @@ int main(void)
}
printf("\n\n");
-#endif
-#ifdef TESTING
/* test for size */
- for (ix = 16; ix < 512; ix++) {
+ for (ix = 10; ix < 256; ix++) {
printf("Testing (not safe-prime): %9d bits \r", ix); fflush(stdout);
err = mp_prime_random_ex(&a, 8, ix, (rand()&1)?LTM_PRIME_2MSB_OFF:LTM_PRIME_2MSB_ON, myrng, NULL);
if (err != MP_OKAY) {
@@ -203,7 +147,7 @@ int main(void)
}
}
- for (ix = 16; ix < 512; ix++) {
+ for (ix = 16; ix < 256; ix++) {
printf("Testing ( safe-prime): %9d bits \r", ix); fflush(stdout);
err = mp_prime_random_ex(&a, 8, ix, ((rand()&1)?LTM_PRIME_2MSB_OFF:LTM_PRIME_2MSB_ON)|LTM_PRIME_SAFE, myrng, NULL);
if (err != MP_OKAY) {
@@ -225,9 +169,7 @@ int main(void)
}
printf("\n\n");
-#endif
-#ifdef TESTING
mp_read_radix(&a, "123456", 10);
mp_toradix_n(&a, buf, 10, 3);
printf("a == %s\n", buf);
@@ -235,7 +177,6 @@ int main(void)
printf("a == %s\n", buf);
mp_toradix_n(&a, buf, 10, 30);
printf("a == %s\n", buf);
-#endif
#if 0
@@ -248,22 +189,6 @@ int main(void)
}
#endif
-#if 0
-{
- mp_word aa, bb;
-
- for (;;) {
- aa = abs(rand()) & MP_MASK;
- bb = abs(rand()) & MP_MASK;
- if (MULT(aa,bb) != (aa*bb)) {
- printf("%llu * %llu == %llu or %llu?\n", aa, bb, (ulong64)MULT(aa,bb), (ulong64)(aa*bb));
- return 0;
- }
- }
-}
-#endif
-
-#ifdef TESTING
/* test mp_cnt_lsb */
printf("testing mp_cnt_lsb...\n");
mp_set(&a, 1);
@@ -274,12 +199,10 @@ int main(void)
}
mp_mul_2(&a, &a);
}
-#endif
/* test mp_reduce_2k */
-#ifdef TESTING
printf("Testing mp_reduce_2k...\n");
- for (cnt = 3; cnt <= 384; ++cnt) {
+ for (cnt = 3; cnt <= 128; ++cnt) {
mp_digit tmp;
mp_2expt(&a, cnt);
mp_sub_d(&a, 2, &a); /* a = 2**cnt - 2 */
@@ -289,7 +212,7 @@ int main(void)
printf("(%d)", mp_reduce_is_2k(&a));
mp_reduce_2k_setup(&a, &tmp);
printf("(%d)", tmp);
- for (ix = 0; ix < 10000; ix++) {
+ for (ix = 0; ix < 1000; ix++) {
if (!(ix & 127)) {printf("."); fflush(stdout); }
mp_rand(&b, (cnt/DIGIT_BIT + 1) * 2);
mp_copy(&c, &b);
@@ -301,14 +224,11 @@ int main(void)
}
}
}
-#endif
-
/* test mp_div_3 */
-#ifdef TESTING
printf("Testing mp_div_3...\n");
mp_set(&d, 3);
- for (cnt = 0; cnt < 1000000; ) {
+ for (cnt = 0; cnt < 10000; ) {
mp_digit r1, r2;
if (!(++cnt & 127)) printf("%9d\r", cnt);
@@ -321,12 +241,10 @@ int main(void)
}
}
printf("\n\nPassed div_3 testing\n");
-#endif
/* test the DR reduction */
-#ifdef TESTING
printf("testing mp_dr_reduce...\n");
- for (cnt = 2; cnt < 128; cnt++) {
+ for (cnt = 2; cnt < 32; cnt++) {
printf("%d digit modulus\n", cnt);
mp_grow(&a, cnt);
mp_zero(&a);
@@ -334,7 +252,7 @@ int main(void)
a.dp[ix] = MP_MASK;
}
a.used = cnt;
- mp_prime_next_prime(&a, 3, 0);
+ a.dp[0] = 3;
mp_rand(&b, cnt - 1);
mp_copy(&b, &c);
@@ -346,206 +264,16 @@ int main(void)
mp_copy(&b, &c);
mp_mod(&b, &a, &b);
- mp_dr_reduce(&c, &a, (1<<DIGIT_BIT)-a.dp[0]);
+ mp_dr_reduce(&c, &a, (((mp_digit)1)<<DIGIT_BIT)-a.dp[0]);
if (mp_cmp(&b, &c) != MP_EQ) {
printf("Failed on trial %lu\n", rr); exit(-1);
}
- } while (++rr < 100000);
+ } while (++rr < 500);
printf("Passed DR test for %d digits\n", cnt);
}
-#endif
-#ifdef TIMER
- /* temp. turn off TOOM */
- TOOM_MUL_CUTOFF = TOOM_SQR_CUTOFF = 100000;
-
- reset();
- sleep(1);
- CLK_PER_SEC = rdtsc();
-
- printf("CLK_PER_SEC == %lu\n", CLK_PER_SEC);
-
-
- log = fopen("logs/add.log", "w");
- for (cnt = 8; cnt <= 128; cnt += 8) {
- SLEEP;
- mp_rand(&a, cnt);
- mp_rand(&b, cnt);
- reset();
- rr = 0;
- do {
- DO(mp_add(&a,&b,&c));
- rr += 16;
- } while (rdtsc() < (CLK_PER_SEC * 2));
- tt = rdtsc();
- printf("Adding\t\t%4d-bit => %9llu/sec, %9llu ticks\n", mp_count_bits(&a), (((ulong64)rr)*CLK_PER_SEC)/tt, tt);
- fprintf(log, "%d %9llu\n", cnt*DIGIT_BIT, (((ulong64)rr)*CLK_PER_SEC)/tt); fflush(log);
- }
- fclose(log);
-
- log = fopen("logs/sub.log", "w");
- for (cnt = 8; cnt <= 128; cnt += 8) {
- SLEEP;
- mp_rand(&a, cnt);
- mp_rand(&b, cnt);
- reset();
- rr = 0;
- do {
- DO(mp_sub(&a,&b,&c));
- rr += 16;
- } while (rdtsc() < (CLK_PER_SEC * 2));
- tt = rdtsc();
- printf("Subtracting\t\t%4d-bit => %9llu/sec, %9llu ticks\n", mp_count_bits(&a), (((ulong64)rr)*CLK_PER_SEC)/tt, tt);
- fprintf(log, "%d %9llu\n", cnt*DIGIT_BIT, (((ulong64)rr)*CLK_PER_SEC)/tt); fflush(log);
- }
- fclose(log);
-
- /* do mult/square twice, first without karatsuba and second with */
-mult_test:
- old_kara_m = KARATSUBA_MUL_CUTOFF;
- old_kara_s = KARATSUBA_SQR_CUTOFF;
- for (ix = 0; ix < 2; ix++) {
- printf("With%s Karatsuba\n", (ix==0)?"out":"");
-
- KARATSUBA_MUL_CUTOFF = (ix==0)?9999:old_kara_m;
- KARATSUBA_SQR_CUTOFF = (ix==0)?9999:old_kara_s;
-
- log = fopen((ix==0)?"logs/mult.log":"logs/mult_kara.log", "w");
- for (cnt = 32; cnt <= 288; cnt += 8) {
- SLEEP;
- mp_rand(&a, cnt);
- mp_rand(&b, cnt);
- reset();
- rr = 0;
- do {
- DO(mp_mul(&a, &b, &c));
- rr += 16;
- } while (rdtsc() < (CLK_PER_SEC * 2));
- tt = rdtsc();
- printf("Multiplying\t%4d-bit => %9llu/sec, %9llu ticks\n", mp_count_bits(&a), (((ulong64)rr)*CLK_PER_SEC)/tt, tt);
- fprintf(log, "%d %9llu\n", mp_count_bits(&a), (((ulong64)rr)*CLK_PER_SEC)/tt); fflush(log);
- }
- fclose(log);
-
- log = fopen((ix==0)?"logs/sqr.log":"logs/sqr_kara.log", "w");
- for (cnt = 32; cnt <= 288; cnt += 8) {
- SLEEP;
- mp_rand(&a, cnt);
- reset();
- rr = 0;
- do {
- DO(mp_sqr(&a, &b));
- rr += 16;
- } while (rdtsc() < (CLK_PER_SEC * 2));
- tt = rdtsc();
- printf("Squaring\t%4d-bit => %9llu/sec, %9llu ticks\n", mp_count_bits(&a), (((ulong64)rr)*CLK_PER_SEC)/tt, tt);
- fprintf(log, "%d %9llu\n", mp_count_bits(&a), (((ulong64)rr)*CLK_PER_SEC)/tt); fflush(log);
- }
- fclose(log);
-
- }
-expt_test:
- {
- char *primes[] = {
- /* 2K moduli mersenne primes */
- "6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151",
- "531137992816767098689588206552468627329593117727031923199444138200403559860852242739162502265229285668889329486246501015346579337652707239409519978766587351943831270835393219031728127",
- "10407932194664399081925240327364085538615262247266704805319112350403608059673360298012239441732324184842421613954281007791383566248323464908139906605677320762924129509389220345773183349661583550472959420547689811211693677147548478866962501384438260291732348885311160828538416585028255604666224831890918801847068222203140521026698435488732958028878050869736186900714720710555703168729087",
- "1475979915214180235084898622737381736312066145333169775147771216478570297878078949377407337049389289382748507531496480477281264838760259191814463365330269540496961201113430156902396093989090226259326935025281409614983499388222831448598601834318536230923772641390209490231836446899608210795482963763094236630945410832793769905399982457186322944729636418890623372171723742105636440368218459649632948538696905872650486914434637457507280441823676813517852099348660847172579408422316678097670224011990280170474894487426924742108823536808485072502240519452587542875349976558572670229633962575212637477897785501552646522609988869914013540483809865681250419497686697771007",
- "259117086013202627776246767922441530941818887553125427303974923161874019266586362086201209516800483406550695241733194177441689509238807017410377709597512042313066624082916353517952311186154862265604547691127595848775610568757931191017711408826252153849035830401185072116424747461823031471398340229288074545677907941037288235820705892351068433882986888616658650280927692080339605869308790500409503709875902119018371991620994002568935113136548829739112656797303241986517250116412703509705427773477972349821676443446668383119322540099648994051790241624056519054483690809616061625743042361721863339415852426431208737266591962061753535748892894599629195183082621860853400937932839420261866586142503251450773096274235376822938649407127700846077124211823080804139298087057504713825264571448379371125032081826126566649084251699453951887789613650248405739378594599444335231188280123660406262468609212150349937584782292237144339628858485938215738821232393687046160677362909315071",
- "190797007524439073807468042969529173669356994749940177394741882673528979787005053706368049835514900244303495954950709725762186311224148828811920216904542206960744666169364221195289538436845390250168663932838805192055137154390912666527533007309292687539092257043362517857366624699975402375462954490293259233303137330643531556539739921926201438606439020075174723029056838272505051571967594608350063404495977660656269020823960825567012344189908927956646011998057988548630107637380993519826582389781888135705408653045219655801758081251164080554609057468028203308718724654081055323215860189611391296030471108443146745671967766308925858547271507311563765171008318248647110097614890313562856541784154881743146033909602737947385055355960331855614540900081456378659068370317267696980001187750995491090350108417050917991562167972281070161305972518044872048331306383715094854938415738549894606070722584737978176686422134354526989443028353644037187375385397838259511833166416134323695660367676897722287918773420968982326089026150031515424165462111337527431154890666327374921446276833564519776797633875503548665093914556482031482248883127023777039667707976559857333357013727342079099064400455741830654320379350833236245819348824064783585692924881021978332974949906122664421376034687815350484991",
-
- /* DR moduli */
- "14059105607947488696282932836518693308967803494693489478439861164411992439598399594747002144074658928593502845729752797260025831423419686528151609940203368612079",
- "101745825697019260773923519755878567461315282017759829107608914364075275235254395622580447400994175578963163918967182013639660669771108475957692810857098847138903161308502419410142185759152435680068435915159402496058513611411688900243039",
- "736335108039604595805923406147184530889923370574768772191969612422073040099331944991573923112581267542507986451953227192970402893063850485730703075899286013451337291468249027691733891486704001513279827771740183629161065194874727962517148100775228363421083691764065477590823919364012917984605619526140821797602431",
- "38564998830736521417281865696453025806593491967131023221754800625044118265468851210705360385717536794615180260494208076605798671660719333199513807806252394423283413430106003596332513246682903994829528690198205120921557533726473585751382193953592127439965050261476810842071573684505878854588706623484573925925903505747545471088867712185004135201289273405614415899438276535626346098904241020877974002916168099951885406379295536200413493190419727789712076165162175783",
- "542189391331696172661670440619180536749994166415993334151601745392193484590296600979602378676624808129613777993466242203025054573692562689251250471628358318743978285860720148446448885701001277560572526947619392551574490839286458454994488665744991822837769918095117129546414124448777033941223565831420390846864429504774477949153794689948747680362212954278693335653935890352619041936727463717926744868338358149568368643403037768649616778526013610493696186055899318268339432671541328195724261329606699831016666359440874843103020666106568222401047720269951530296879490444224546654729111504346660859907296364097126834834235287147",
- "1487259134814709264092032648525971038895865645148901180585340454985524155135260217788758027400478312256339496385275012465661575576202252063145698732079880294664220579764848767704076761853197216563262660046602703973050798218246170835962005598561669706844469447435461092542265792444947706769615695252256130901271870341005768912974433684521436211263358097522726462083917939091760026658925757076733484173202927141441492573799914240222628795405623953109131594523623353044898339481494120112723445689647986475279242446083151413667587008191682564376412347964146113898565886683139407005941383669325997475076910488086663256335689181157957571445067490187939553165903773554290260531009121879044170766615232300936675369451260747671432073394867530820527479172464106442450727640226503746586340279816318821395210726268291535648506190714616083163403189943334431056876038286530365757187367147446004855912033137386225053275419626102417236133948503",
- "1095121115716677802856811290392395128588168592409109494900178008967955253005183831872715423151551999734857184538199864469605657805519106717529655044054833197687459782636297255219742994736751541815269727940751860670268774903340296040006114013971309257028332849679096824800250742691718610670812374272414086863715763724622797509437062518082383056050144624962776302147890521249477060215148275163688301275847155316042279405557632639366066847442861422164832655874655824221577849928863023018366835675399949740429332468186340518172487073360822220449055340582568461568645259954873303616953776393853174845132081121976327462740354930744487429617202585015510744298530101547706821590188733515880733527449780963163909830077616357506845523215289297624086914545378511082534229620116563260168494523906566709418166011112754529766183554579321224940951177394088465596712620076240067370589036924024728375076210477267488679008016579588696191194060127319035195370137160936882402244399699172017835144537488486396906144217720028992863941288217185353914991583400421682751000603596655790990815525126154394344641336397793791497068253936771017031980867706707490224041075826337383538651825493679503771934836094655802776331664261631740148281763487765852746577808019633679",
-
- /* generic unrestricted moduli */
- "17933601194860113372237070562165128350027320072176844226673287945873370751245439587792371960615073855669274087805055507977323024886880985062002853331424203",
- "2893527720709661239493896562339544088620375736490408468011883030469939904368086092336458298221245707898933583190713188177399401852627749210994595974791782790253946539043962213027074922559572312141181787434278708783207966459019479487",
- "347743159439876626079252796797422223177535447388206607607181663903045907591201940478223621722118173270898487582987137708656414344685816179420855160986340457973820182883508387588163122354089264395604796675278966117567294812714812796820596564876450716066283126720010859041484786529056457896367683122960411136319",
- "47266428956356393164697365098120418976400602706072312735924071745438532218237979333351774907308168340693326687317443721193266215155735814510792148768576498491199122744351399489453533553203833318691678263241941706256996197460424029012419012634671862283532342656309677173602509498417976091509154360039893165037637034737020327399910409885798185771003505320583967737293415979917317338985837385734747478364242020380416892056650841470869294527543597349250299539682430605173321029026555546832473048600327036845781970289288898317888427517364945316709081173840186150794397479045034008257793436817683392375274635794835245695887",
- "436463808505957768574894870394349739623346440601945961161254440072143298152040105676491048248110146278752857839930515766167441407021501229924721335644557342265864606569000117714935185566842453630868849121480179691838399545644365571106757731317371758557990781880691336695584799313313687287468894148823761785582982549586183756806449017542622267874275103877481475534991201849912222670102069951687572917937634467778042874315463238062009202992087620963771759666448266532858079402669920025224220613419441069718482837399612644978839925207109870840278194042158748845445131729137117098529028886770063736487420613144045836803985635654192482395882603511950547826439092832800532152534003936926017612446606135655146445620623395788978726744728503058670046885876251527122350275750995227",
- "11424167473351836398078306042624362277956429440521137061889702611766348760692206243140413411077394583180726863277012016602279290144126785129569474909173584789822341986742719230331946072730319555984484911716797058875905400999504305877245849119687509023232790273637466821052576859232452982061831009770786031785669030271542286603956118755585683996118896215213488875253101894663403069677745948305893849505434201763745232895780711972432011344857521691017896316861403206449421332243658855453435784006517202894181640562433575390821384210960117518650374602256601091379644034244332285065935413233557998331562749140202965844219336298970011513882564935538704289446968322281451907487362046511461221329799897350993370560697505809686438782036235372137015731304779072430260986460269894522159103008260495503005267165927542949439526272736586626709581721032189532726389643625590680105784844246152702670169304203783072275089194754889511973916207",
- "1214855636816562637502584060163403830270705000634713483015101384881871978446801224798536155406895823305035467591632531067547890948695117172076954220727075688048751022421198712032848890056357845974246560748347918630050853933697792254955890439720297560693579400297062396904306270145886830719309296352765295712183040773146419022875165382778007040109957609739589875590885701126197906063620133954893216612678838507540777138437797705602453719559017633986486649523611975865005712371194067612263330335590526176087004421363598470302731349138773205901447704682181517904064735636518462452242791676541725292378925568296858010151852326316777511935037531017413910506921922450666933202278489024521263798482237150056835746454842662048692127173834433089016107854491097456725016327709663199738238442164843147132789153725513257167915555162094970853584447993125488607696008169807374736711297007473812256272245489405898470297178738029484459690836250560495461579533254473316340608217876781986188705928270735695752830825527963838355419762516246028680280988020401914551825487349990306976304093109384451438813251211051597392127491464898797406789175453067960072008590614886532333015881171367104445044718144312416815712216611576221546455968770801413440778423979",
- NULL
- };
- log = fopen("logs/expt.log", "w");
- logb = fopen("logs/expt_dr.log", "w");
- logc = fopen("logs/expt_2k.log", "w");
- for (n = 0; primes[n]; n++) {
- SLEEP;
- mp_read_radix(&a, primes[n], 10);
- mp_zero(&b);
- for (rr = 0; rr < mp_count_bits(&a); rr++) {
- mp_mul_2(&b, &b);
- b.dp[0] |= lbit();
- b.used += 1;
- }
- mp_sub_d(&a, 1, &c);
- mp_mod(&b, &c, &b);
- mp_set(&c, 3);
- reset();
- rr = 0;
- do {
- DO(mp_exptmod(&c, &b, &a, &d));
- rr += 16;
- } while (rdtsc() < (CLK_PER_SEC * 2));
- tt = rdtsc();
- mp_sub_d(&a, 1, &e);
- mp_sub(&e, &b, &b);
- mp_exptmod(&c, &b, &a, &e); /* c^(p-1-b) mod a */
- mp_mulmod(&e, &d, &a, &d); /* c^b * c^(p-1-b) == c^p-1 == 1 */
- if (mp_cmp_d(&d, 1)) {
- printf("Different (%d)!!!\n", mp_count_bits(&a));
- draw(&d);
- exit(0);
- }
- printf("Exponentiating\t%4d-bit => %9llu/sec, %9llu ticks\n", mp_count_bits(&a), (((ulong64)rr)*CLK_PER_SEC)/tt, tt);
- fprintf((n < 6) ? logc : (n < 13) ? logb : log, "%d %9llu\n", mp_count_bits(&a), (((ulong64)rr)*CLK_PER_SEC)/tt);
- }
- }
- fclose(log);
- fclose(logb);
- fclose(logc);
-
- log = fopen("logs/invmod.log", "w");
- for (cnt = 4; cnt <= 128; cnt += 4) {
- SLEEP;
- mp_rand(&a, cnt);
- mp_rand(&b, cnt);
-
- do {
- mp_add_d(&b, 1, &b);
- mp_gcd(&a, &b, &c);
- } while (mp_cmp_d(&c, 1) != MP_EQ);
-
- reset();
- rr = 0;
- do {
- DO(mp_invmod(&b, &a, &c));
- rr += 16;
- } while (rdtsc() < (CLK_PER_SEC * 2));
- tt = rdtsc();
- mp_mulmod(&b, &c, &a, &d);
- if (mp_cmp_d(&d, 1) != MP_EQ) {
- printf("Failed to invert\n");
- return 0;
- }
- printf("Inverting mod\t%4d-bit => %9llu/sec, %9llu ticks\n", mp_count_bits(&a), (((ulong64)rr)*CLK_PER_SEC)/tt, tt);
- fprintf(log, "%d %9llu\n", cnt*DIGIT_BIT, (((ulong64)rr)*CLK_PER_SEC)/tt);
- }
- fclose(log);
-
- return 0;
-
-#endif
div2_n = mul2_n = inv_n = expt_n = lcm_n = gcd_n = add_n =
sub_n = mul_n = div_n = sqr_n = mul2d_n = div2d_n = cnt = add_d_n = sub_d_n= 0;
diff --git a/demo/timing.c b/demo/timing.c
new file mode 100644
index 0000000..30e95ce
--- /dev/null
+++ b/demo/timing.c
@@ -0,0 +1,291 @@
+#include <tommath.h>
+#include <time.h>
+
+ulong64 _tt;
+
+#ifdef IOWNANATHLON
+#include <unistd.h>
+#define SLEEP sleep(4)
+#else
+#define SLEEP
+#endif
+
+
+void ndraw(mp_int *a, char *name)
+{
+ char buf[4096];
+ printf("%s: ", name);
+ mp_toradix(a, buf, 64);
+ printf("%s\n", buf);
+}
+
+static void draw(mp_int *a)
+{
+ ndraw(a, "");
+}
+
+
+unsigned long lfsr = 0xAAAAAAAAUL;
+
+int lbit(void)
+{
+ if (lfsr & 0x80000000UL) {
+ lfsr = ((lfsr << 1) ^ 0x8000001BUL) & 0xFFFFFFFFUL;
+ return 1;
+ } else {
+ lfsr <<= 1;
+ return 0;
+ }
+}
+
+#if defined(__i386__) || defined(_M_IX86) || defined(_M_AMD64)
+/* RDTSC from Scott Duplichan */
+static ulong64 TIMFUNC (void)
+ {
+ #if defined __GNUC__
+ #ifdef __i386__
+ ulong64 a;
+ __asm__ __volatile__ ("rdtsc ":"=A" (a));
+ return a;
+ #else /* gcc-IA64 version */
+ unsigned long result;
+ __asm__ __volatile__("mov %0=ar.itc" : "=r"(result) :: "memory");
+ while (__builtin_expect ((int) result == -1, 0))
+ __asm__ __volatile__("mov %0=ar.itc" : "=r"(result) :: "memory");
+ return result;
+ #endif
+
+ // Microsoft and Intel Windows compilers
+ #elif defined _M_IX86
+ __asm rdtsc
+ #elif defined _M_AMD64
+ return __rdtsc ();
+ #elif defined _M_IA64
+ #if defined __INTEL_COMPILER
+ #include <ia64intrin.h>
+ #endif
+ return __getReg (3116);
+ #else
+ #error need rdtsc function for this build
+ #endif
+ }
+#else
+#define TIMFUNC clock
+#endif
+
+#define DO(x) x; x;
+//#define DO4(x) DO2(x); DO2(x);
+//#define DO8(x) DO4(x); DO4(x);
+//#define DO(x) DO8(x); DO8(x);
+
+int main(void)
+{
+ ulong64 tt, gg, CLK_PER_SEC;
+ FILE *log, *logb, *logc;
+ mp_int a, b, c, d, e, f;
+ int n, cnt, ix, old_kara_m, old_kara_s;
+ unsigned rr;
+
+ mp_init(&a);
+ mp_init(&b);
+ mp_init(&c);
+ mp_init(&d);
+ mp_init(&e);
+ mp_init(&f);
+
+ srand(time(NULL));
+
+
+ /* temp. turn off TOOM */
+ TOOM_MUL_CUTOFF = TOOM_SQR_CUTOFF = 100000;
+
+ CLK_PER_SEC = TIMFUNC();
+ sleep(1);
+ CLK_PER_SEC = TIMFUNC() - CLK_PER_SEC;
+
+ printf("CLK_PER_SEC == %llu\n", CLK_PER_SEC);
+
+ log = fopen("logs/add.log", "w");
+ for (cnt = 8; cnt <= 128; cnt += 8) {
+ SLEEP;
+ mp_rand(&a, cnt);
+ mp_rand(&b, cnt);
+ rr = 0;
+ tt = -1;
+ do {
+ gg = TIMFUNC();
+ DO(mp_add(&a,&b,&c));
+ gg = (TIMFUNC() - gg)>>1;
+ if (tt > gg) tt = gg;
+ } while (++rr < 100000);
+ printf("Adding\t\t%4d-bit => %9llu/sec, %9llu cycles\n", mp_count_bits(&a), CLK_PER_SEC/tt, tt);
+ fprintf(log, "%d %9llu\n", cnt*DIGIT_BIT, tt); fflush(log);
+ }
+ fclose(log);
+
+ log = fopen("logs/sub.log", "w");
+ for (cnt = 8; cnt <= 128; cnt += 8) {
+ SLEEP;
+ mp_rand(&a, cnt);
+ mp_rand(&b, cnt);
+ rr = 0;
+ tt = -1;
+ do {
+ gg = TIMFUNC();
+ DO(mp_sub(&a,&b,&c));
+ gg = (TIMFUNC() - gg)>>1;
+ if (tt > gg) tt = gg;
+ } while (++rr < 100000);
+
+ printf("Subtracting\t\t%4d-bit => %9llu/sec, %9llu cycles\n", mp_count_bits(&a), CLK_PER_SEC/tt, tt);
+ fprintf(log, "%d %9llu\n", cnt*DIGIT_BIT, tt); fflush(log);
+ }
+ fclose(log);
+
+ /* do mult/square twice, first without karatsuba and second with */
+ old_kara_m = KARATSUBA_MUL_CUTOFF;
+ old_kara_s = KARATSUBA_SQR_CUTOFF;
+ for (ix = 0; ix < 1; ix++) {
+ printf("With%s Karatsuba\n", (ix==0)?"out":"");
+
+ KARATSUBA_MUL_CUTOFF = (ix==0)?9999:old_kara_m;
+ KARATSUBA_SQR_CUTOFF = (ix==0)?9999:old_kara_s;
+
+ log = fopen((ix==0)?"logs/mult.log":"logs/mult_kara.log", "w");
+ for (cnt = 32; cnt <= 288; cnt += 8) {
+ SLEEP;
+ mp_rand(&a, cnt);
+ mp_rand(&b, cnt);
+ rr = 0;
+ tt = -1;
+ do {
+ gg = TIMFUNC();
+ DO(mp_mul(&a, &b, &c));
+ gg = (TIMFUNC() - gg)>>1;
+ if (tt > gg) tt = gg;
+ } while (++rr < 100);
+ printf("Multiplying\t%4d-bit => %9llu/sec, %9llu cycles\n", mp_count_bits(&a), CLK_PER_SEC/tt, tt);
+ fprintf(log, "%d %9llu\n", mp_count_bits(&a), tt); fflush(log);
+ }
+ fclose(log);
+
+ log = fopen((ix==0)?"logs/sqr.log":"logs/sqr_kara.log", "w");
+ for (cnt = 32; cnt <= 288; cnt += 8) {
+ SLEEP;
+ mp_rand(&a, cnt);
+ rr = 0;
+ tt = -1;
+ do {
+ gg = TIMFUNC();
+ DO(mp_sqr(&a, &b));
+ gg = (TIMFUNC() - gg)>>1;
+ if (tt > gg) tt = gg;
+ } while (++rr < 100);
+ printf("Squaring\t%4d-bit => %9llu/sec, %9llu cycles\n", mp_count_bits(&a), CLK_PER_SEC/tt, tt);
+ fprintf(log, "%d %9llu\n", mp_count_bits(&a), tt); fflush(log);
+ }
+ fclose(log);
+
+ }
+
+ {
+ char *primes[] = {
+ /* 2K moduli mersenne primes */
+ "6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151",
+ "531137992816767098689588206552468627329593117727031923199444138200403559860852242739162502265229285668889329486246501015346579337652707239409519978766587351943831270835393219031728127",
+ "10407932194664399081925240327364085538615262247266704805319112350403608059673360298012239441732324184842421613954281007791383566248323464908139906605677320762924129509389220345773183349661583550472959420547689811211693677147548478866962501384438260291732348885311160828538416585028255604666224831890918801847068222203140521026698435488732958028878050869736186900714720710555703168729087",
+ "1475979915214180235084898622737381736312066145333169775147771216478570297878078949377407337049389289382748507531496480477281264838760259191814463365330269540496961201113430156902396093989090226259326935025281409614983499388222831448598601834318536230923772641390209490231836446899608210795482963763094236630945410832793769905399982457186322944729636418890623372171723742105636440368218459649632948538696905872650486914434637457507280441823676813517852099348660847172579408422316678097670224011990280170474894487426924742108823536808485072502240519452587542875349976558572670229633962575212637477897785501552646522609988869914013540483809865681250419497686697771007",
+ "259117086013202627776246767922441530941818887553125427303974923161874019266586362086201209516800483406550695241733194177441689509238807017410377709597512042313066624082916353517952311186154862265604547691127595848775610568757931191017711408826252153849035830401185072116424747461823031471398340229288074545677907941037288235820705892351068433882986888616658650280927692080339605869308790500409503709875902119018371991620994002568935113136548829739112656797303241986517250116412703509705427773477972349821676443446668383119322540099648994051790241624056519054483690809616061625743042361721863339415852426431208737266591962061753535748892894599629195183082621860853400937932839420261866586142503251450773096274235376822938649407127700846077124211823080804139298087057504713825264571448379371125032081826126566649084251699453951887789613650248405739378594599444335231188280123660406262468609212150349937584782292237144339628858485938215738821232393687046160677362909315071",
+ "190797007524439073807468042969529173669356994749940177394741882673528979787005053706368049835514900244303495954950709725762186311224148828811920216904542206960744666169364221195289538436845390250168663932838805192055137154390912666527533007309292687539092257043362517857366624699975402375462954490293259233303137330643531556539739921926201438606439020075174723029056838272505051571967594608350063404495977660656269020823960825567012344189908927956646011998057988548630107637380993519826582389781888135705408653045219655801758081251164080554609057468028203308718724654081055323215860189611391296030471108443146745671967766308925858547271507311563765171008318248647110097614890313562856541784154881743146033909602737947385055355960331855614540900081456378659068370317267696980001187750995491090350108417050917991562167972281070161305972518044872048331306383715094854938415738549894606070722584737978176686422134354526989443028353644037187375385397838259511833166416134323695660367676897722287918773420968982326089026150031515424165462111337527431154890666327374921446276833564519776797633875503548665093914556482031482248883127023777039667707976559857333357013727342079099064400455741830654320379350833236245819348824064783585692924881021978332974949906122664421376034687815350484991",
+
+ /* DR moduli */
+ "14059105607947488696282932836518693308967803494693489478439861164411992439598399594747002144074658928593502845729752797260025831423419686528151609940203368612079",
+ "101745825697019260773923519755878567461315282017759829107608914364075275235254395622580447400994175578963163918967182013639660669771108475957692810857098847138903161308502419410142185759152435680068435915159402496058513611411688900243039",
+ "736335108039604595805923406147184530889923370574768772191969612422073040099331944991573923112581267542507986451953227192970402893063850485730703075899286013451337291468249027691733891486704001513279827771740183629161065194874727962517148100775228363421083691764065477590823919364012917984605619526140821797602431",
+ "38564998830736521417281865696453025806593491967131023221754800625044118265468851210705360385717536794615180260494208076605798671660719333199513807806252394423283413430106003596332513246682903994829528690198205120921557533726473585751382193953592127439965050261476810842071573684505878854588706623484573925925903505747545471088867712185004135201289273405614415899438276535626346098904241020877974002916168099951885406379295536200413493190419727789712076165162175783",
+ "542189391331696172661670440619180536749994166415993334151601745392193484590296600979602378676624808129613777993466242203025054573692562689251250471628358318743978285860720148446448885701001277560572526947619392551574490839286458454994488665744991822837769918095117129546414124448777033941223565831420390846864429504774477949153794689948747680362212954278693335653935890352619041936727463717926744868338358149568368643403037768649616778526013610493696186055899318268339432671541328195724261329606699831016666359440874843103020666106568222401047720269951530296879490444224546654729111504346660859907296364097126834834235287147",
+ "1487259134814709264092032648525971038895865645148901180585340454985524155135260217788758027400478312256339496385275012465661575576202252063145698732079880294664220579764848767704076761853197216563262660046602703973050798218246170835962005598561669706844469447435461092542265792444947706769615695252256130901271870341005768912974433684521436211263358097522726462083917939091760026658925757076733484173202927141441492573799914240222628795405623953109131594523623353044898339481494120112723445689647986475279242446083151413667587008191682564376412347964146113898565886683139407005941383669325997475076910488086663256335689181157957571445067490187939553165903773554290260531009121879044170766615232300936675369451260747671432073394867530820527479172464106442450727640226503746586340279816318821395210726268291535648506190714616083163403189943334431056876038286530365757187367147446004855912033137386225053275419626102417236133948503",
+ "1095121115716677802856811290392395128588168592409109494900178008967955253005183831872715423151551999734857184538199864469605657805519106717529655044054833197687459782636297255219742994736751541815269727940751860670268774903340296040006114013971309257028332849679096824800250742691718610670812374272414086863715763724622797509437062518082383056050144624962776302147890521249477060215148275163688301275847155316042279405557632639366066847442861422164832655874655824221577849928863023018366835675399949740429332468186340518172487073360822220449055340582568461568645259954873303616953776393853174845132081121976327462740354930744487429617202585015510744298530101547706821590188733515880733527449780963163909830077616357506845523215289297624086914545378511082534229620116563260168494523906566709418166011112754529766183554579321224940951177394088465596712620076240067370589036924024728375076210477267488679008016579588696191194060127319035195370137160936882402244399699172017835144537488486396906144217720028992863941288217185353914991583400421682751000603596655790990815525126154394344641336397793791497068253936771017031980867706707490224041075826337383538651825493679503771934836094655802776331664261631740148281763487765852746577808019633679",
+
+ /* generic unrestricted moduli */
+ "17933601194860113372237070562165128350027320072176844226673287945873370751245439587792371960615073855669274087805055507977323024886880985062002853331424203",
+ "2893527720709661239493896562339544088620375736490408468011883030469939904368086092336458298221245707898933583190713188177399401852627749210994595974791782790253946539043962213027074922559572312141181787434278708783207966459019479487",
+ "347743159439876626079252796797422223177535447388206607607181663903045907591201940478223621722118173270898487582987137708656414344685816179420855160986340457973820182883508387588163122354089264395604796675278966117567294812714812796820596564876450716066283126720010859041484786529056457896367683122960411136319",
+ "47266428956356393164697365098120418976400602706072312735924071745438532218237979333351774907308168340693326687317443721193266215155735814510792148768576498491199122744351399489453533553203833318691678263241941706256996197460424029012419012634671862283532342656309677173602509498417976091509154360039893165037637034737020327399910409885798185771003505320583967737293415979917317338985837385734747478364242020380416892056650841470869294527543597349250299539682430605173321029026555546832473048600327036845781970289288898317888427517364945316709081173840186150794397479045034008257793436817683392375274635794835245695887",
+ "436463808505957768574894870394349739623346440601945961161254440072143298152040105676491048248110146278752857839930515766167441407021501229924721335644557342265864606569000117714935185566842453630868849121480179691838399545644365571106757731317371758557990781880691336695584799313313687287468894148823761785582982549586183756806449017542622267874275103877481475534991201849912222670102069951687572917937634467778042874315463238062009202992087620963771759666448266532858079402669920025224220613419441069718482837399612644978839925207109870840278194042158748845445131729137117098529028886770063736487420613144045836803985635654192482395882603511950547826439092832800532152534003936926017612446606135655146445620623395788978726744728503058670046885876251527122350275750995227",
+ "11424167473351836398078306042624362277956429440521137061889702611766348760692206243140413411077394583180726863277012016602279290144126785129569474909173584789822341986742719230331946072730319555984484911716797058875905400999504305877245849119687509023232790273637466821052576859232452982061831009770786031785669030271542286603956118755585683996118896215213488875253101894663403069677745948305893849505434201763745232895780711972432011344857521691017896316861403206449421332243658855453435784006517202894181640562433575390821384210960117518650374602256601091379644034244332285065935413233557998331562749140202965844219336298970011513882564935538704289446968322281451907487362046511461221329799897350993370560697505809686438782036235372137015731304779072430260986460269894522159103008260495503005267165927542949439526272736586626709581721032189532726389643625590680105784844246152702670169304203783072275089194754889511973916207",
+ "1214855636816562637502584060163403830270705000634713483015101384881871978446801224798536155406895823305035467591632531067547890948695117172076954220727075688048751022421198712032848890056357845974246560748347918630050853933697792254955890439720297560693579400297062396904306270145886830719309296352765295712183040773146419022875165382778007040109957609739589875590885701126197906063620133954893216612678838507540777138437797705602453719559017633986486649523611975865005712371194067612263330335590526176087004421363598470302731349138773205901447704682181517904064735636518462452242791676541725292378925568296858010151852326316777511935037531017413910506921922450666933202278489024521263798482237150056835746454842662048692127173834433089016107854491097456725016327709663199738238442164843147132789153725513257167915555162094970853584447993125488607696008169807374736711297007473812256272245489405898470297178738029484459690836250560495461579533254473316340608217876781986188705928270735695752830825527963838355419762516246028680280988020401914551825487349990306976304093109384451438813251211051597392127491464898797406789175453067960072008590614886532333015881171367104445044718144312416815712216611576221546455968770801413440778423979",
+ NULL
+ };
+ log = fopen("logs/expt.log", "w");
+ logb = fopen("logs/expt_dr.log", "w");
+ logc = fopen("logs/expt_2k.log", "w");
+ for (n = 0; primes[n]; n++) {
+ SLEEP;
+ mp_read_radix(&a, primes[n], 10);
+ mp_zero(&b);
+ for (rr = 0; rr < (unsigned)mp_count_bits(&a); rr++) {
+ mp_mul_2(&b, &b);
+ b.dp[0] |= lbit();
+ b.used += 1;
+ }
+ mp_sub_d(&a, 1, &c);
+ mp_mod(&b, &c, &b);
+ mp_set(&c, 3);
+ rr = 0;
+ tt = -1;
+ do {
+ gg = TIMFUNC();
+ DO(mp_exptmod(&c, &b, &a, &d));
+ gg = (TIMFUNC() - gg)>>1;
+ if (tt > gg) tt = gg;
+ } while (++rr < 10);
+ mp_sub_d(&a, 1, &e);
+ mp_sub(&e, &b, &b);
+ mp_exptmod(&c, &b, &a, &e); /* c^(p-1-b) mod a */
+ mp_mulmod(&e, &d, &a, &d); /* c^b * c^(p-1-b) == c^p-1 == 1 */
+ if (mp_cmp_d(&d, 1)) {
+ printf("Different (%d)!!!\n", mp_count_bits(&a));
+ draw(&d);
+ exit(0);
+ }
+ printf("Exponentiating\t%4d-bit => %9llu/sec, %9llu cycles\n", mp_count_bits(&a), CLK_PER_SEC/tt, tt);
+ fprintf((n < 6) ? logc : (n < 13) ? logb : log, "%d %9llu\n", mp_count_bits(&a), tt);
+ }
+ }
+ fclose(log);
+ fclose(logb);
+ fclose(logc);
+
+ log = fopen("logs/invmod.log", "w");
+ for (cnt = 4; cnt <= 128; cnt += 4) {
+ SLEEP;
+ mp_rand(&a, cnt);
+ mp_rand(&b, cnt);
+
+ do {
+ mp_add_d(&b, 1, &b);
+ mp_gcd(&a, &b, &c);
+ } while (mp_cmp_d(&c, 1) != MP_EQ);
+
+ rr = 0;
+ tt = -1;
+ do {
+ gg = TIMFUNC();
+ DO(mp_invmod(&b, &a, &c));
+ gg = (TIMFUNC() - gg)>>1;
+ if (tt > gg) tt = gg;
+ } while (++rr < 1000);
+ mp_mulmod(&b, &c, &a, &d);
+ if (mp_cmp_d(&d, 1) != MP_EQ) {
+ printf("Failed to invert\n");
+ return 0;
+ }
+ printf("Inverting mod\t%4d-bit => %9llu/sec, %9llu cycles\n", mp_count_bits(&a), CLK_PER_SEC/tt, tt);
+ fprintf(log, "%d %9llu\n", cnt*DIGIT_BIT, tt);
+ }
+ fclose(log);
+
+ return 0;
+}
+
diff --git a/etc/makefile b/etc/makefile
index 98ddb1c..99154d8 100644
--- a/etc/makefile
+++ b/etc/makefile
@@ -46,4 +46,5 @@ mont: mont.o
clean:
- rm -f *.log *.o *.obj *.exe pprime tune mersenne drprime tune86 tune86l mont 2kprime pprime.dat
+ rm -f *.log *.o *.obj *.exe pprime tune mersenne drprime tune86 tune86l mont 2kprime pprime.dat \
+ *.da *.dyn *.dpi *~
diff --git a/etc/makefile.icc b/etc/makefile.icc
new file mode 100644
index 0000000..0a50728
--- /dev/null
+++ b/etc/makefile.icc
@@ -0,0 +1,67 @@
+CC = icc
+
+CFLAGS += -I../
+
+# optimize for SPEED
+#
+# -mcpu= can be pentium, pentiumpro (covers PII through PIII) or pentium4
+# -ax? specifies make code specifically for ? but compatible with IA-32
+# -x? specifies compile solely for ? [not specifically IA-32 compatible]
+#
+# where ? is
+# K - PIII
+# W - first P4 [Williamette]
+# N - P4 Northwood
+# P - P4 Prescott
+# B - Blend of P4 and PM [mobile]
+#
+# Default to just generic max opts
+CFLAGS += -O3 -xN -ip
+
+# default lib name (requires install with root)
+# LIBNAME=-ltommath
+
+# libname when you can't install the lib with install
+LIBNAME=../libtommath.a
+
+#provable primes
+pprime: pprime.o
+ $(CC) pprime.o $(LIBNAME) -o pprime
+
+# portable [well requires clock()] tuning app
+tune: tune.o
+ $(CC) tune.o $(LIBNAME) -o tune
+
+# same app but using RDTSC for higher precision [requires 80586+], coff based gcc installs [e.g. ming, cygwin, djgpp]
+tune86: tune.c
+ nasm -f coff timer.asm
+ $(CC) -DX86_TIMER $(CFLAGS) tune.c timer.o $(LIBNAME) -o tune86
+
+# for cygwin
+tune86c: tune.c
+ nasm -f gnuwin32 timer.asm
+ $(CC) -DX86_TIMER $(CFLAGS) tune.c timer.o $(LIBNAME) -o tune86
+
+#make tune86 for linux or any ELF format
+tune86l: tune.c
+ nasm -f elf -DUSE_ELF timer.asm
+ $(CC) -DX86_TIMER $(CFLAGS) tune.c timer.o $(LIBNAME) -o tune86l
+
+# spits out mersenne primes
+mersenne: mersenne.o
+ $(CC) mersenne.o $(LIBNAME) -o mersenne
+
+# fines DR safe primes for the given config
+drprime: drprime.o
+ $(CC) drprime.o $(LIBNAME) -o drprime
+
+# fines 2k safe primes for the given config
+2kprime: 2kprime.o
+ $(CC) 2kprime.o $(LIBNAME) -o 2kprime
+
+mont: mont.o
+ $(CC) mont.o $(LIBNAME) -o mont
+
+
+clean:
+ rm -f *.log *.o *.obj *.exe pprime tune mersenne drprime tune86 tune86l mont 2kprime pprime.dat *.il
diff --git a/logs/add.log b/logs/add.log
index e53b415..2ba7207 100644
--- a/logs/add.log
+++ b/logs/add.log
@@ -1,16 +1,16 @@
-224 20297071
-448 15151383
-672 13088682
-896 11111587
-1120 9240621
-1344 8221878
-1568 7227434
-1792 6718051
-2016 6042524
-2240 5685200
-2464 5240465
-2688 4818032
-2912 4412794
-3136 4155883
-3360 3927078
-3584 3722138
+224 1572
+448 1740
+672 1902
+896 2116
+1120 2324
+1344 2484
+1568 2548
+1792 2772
+2016 2958
+2240 3058
+2464 3276
+2688 3436
+2912 3542
+3136 3702
+3360 3926
+3584 4074
diff --git a/logs/addsub.png b/logs/addsub.png
index e733f8d..a5679ac 100644
Binary files a/logs/addsub.png and b/logs/addsub.png differ
diff --git a/logs/expt.log b/logs/expt.log
index 2597b48..695c936 100644
--- a/logs/expt.log
+++ b/logs/expt.log
@@ -1,7 +1,7 @@
-513 745
-769 282
-1025 130
-2049 20
-2561 11
-3073 6
-4097 2
+513 19933908
+769 55707832
+1025 119872576
+2049 856114218
+2561 1602741360
+3073 2718192748
+4097 6264335828
diff --git a/logs/expt.png b/logs/expt.png
index 59bafa2..9ee8bb7 100644
Binary files a/logs/expt.png and b/logs/expt.png differ
diff --git a/logs/expt_2k.log b/logs/expt_2k.log
index f4c282c..d7c47f3 100644
--- a/logs/expt_2k.log
+++ b/logs/expt_2k.log
@@ -1,6 +1,6 @@
-521 783
-607 585
-1279 138
-2203 39
-3217 15
-4253 6
+521 18847776
+607 24665920
+1279 110036220
+2203 414562036
+3217 1108350966
+4253 2286079370
diff --git a/logs/expt_dr.log b/logs/expt_dr.log
index c552e12..b017e7c 100644
--- a/logs/expt_dr.log
+++ b/logs/expt_dr.log
@@ -1,7 +1,7 @@
-532 1296
-784 551
-1036 283
-1540 109
-2072 52
-3080 18
-4116 7
+532 9656134
+784 23022274
+1036 45227854
+1540 129652848
+2072 280625626
+3080 845619480
+4116 1866206400
diff --git a/logs/graphs.dem b/logs/graphs.dem
index d5c9b8a..dfaf613 100644
--- a/logs/graphs.dem
+++ b/logs/graphs.dem
@@ -1,17 +1,17 @@
-set terminal png
-set size 1.75
-set ylabel "Operations per Second"
-set xlabel "Operand size (bits)"
-
-set output "addsub.png"
-plot 'add.log' smooth bezier title "Addition", 'sub.log' smooth bezier title "Subtraction"
-
-set output "mult.png"
-plot 'sqr.log' smooth bezier title "Squaring (without Karatsuba)", 'sqr_kara.log' smooth bezier title "Squaring (Karatsuba)", 'mult.log' smooth bezier title "Multiplication (without Karatsuba)", 'mult_kara.log' smooth bezier title "Multiplication (Karatsuba)"
-
-set output "expt.png"
-plot 'expt.log' smooth bezier title "Exptmod (Montgomery)", 'expt_dr.log' smooth bezier title "Exptmod (Dimminished Radix)", 'expt_2k.log' smooth bezier title "Exptmod (2k Reduction)"
-
-set output "invmod.png"
-plot 'invmod.log' smooth bezier title "Modular Inverse"
-
+set terminal png
+set size 1.75
+set ylabel "Cycles per Operation"
+set xlabel "Operand size (bits)"
+
+set output "addsub.png"
+plot 'add.log' smooth bezier title "Addition", 'sub.log' smooth bezier title "Subtraction"
+
+set output "mult.png"
+plot 'sqr.log' smooth bezier title "Squaring (without Karatsuba)", 'sqr_kara.log' smooth bezier title "Squaring (Karatsuba)", 'mult.log' smooth bezier title "Multiplication (without Karatsuba)", 'mult_kara.log' smooth bezier title "Multiplication (Karatsuba)"
+
+set output "expt.png"
+plot 'expt.log' smooth bezier title "Exptmod (Montgomery)", 'expt_dr.log' smooth bezier title "Exptmod (Dimminished Radix)", 'expt_2k.log' smooth bezier title "Exptmod (2k Reduction)"
+
+set output "invmod.png"
+plot 'invmod.log' smooth bezier title "Modular Inverse"
+
diff --git a/logs/invmod.log b/logs/invmod.log
index c9294ef..e69de29 100644
--- a/logs/invmod.log
+++ b/logs/invmod.log
@@ -1,32 +0,0 @@
-112 17364
-224 8643
-336 8867
-448 6228
-560 4737
-672 2259
-784 2899
-896 1497
-1008 1238
-1120 1010
-1232 870
-1344 1265
-1456 1102
-1568 981
-1680 539
-1792 484
-1904 722
-2016 392
-2128 604
-2240 551
-2352 511
-2464 469
-2576 263
-2688 247
-2800 227
-2912 354
-3024 336
-3136 312
-3248 296
-3360 166
-3472 155
-3584 248
diff --git a/logs/invmod.png b/logs/invmod.png
index baa287f..0a8a4ad 100644
Binary files a/logs/invmod.png and b/logs/invmod.png differ
diff --git a/logs/k7/README b/logs/k7/README
deleted file mode 100644
index ea20c81..0000000
--- a/logs/k7/README
+++ /dev/null
@@ -1,13 +0,0 @@
-To use the pretty graphs you have to first build/run the ltmtest from the root directory of the package.
-Todo this type
-
-make timing ; ltmtest
-
-in the root. It will run for a while [about ten minutes on most PCs] and produce a series of .log files in logs/.
-
-After doing that run "gnuplot graphs.dem" to make the PNGs. If you managed todo that all so far just open index.html to view
-them all :-)
-
-Have fun
-
-Tom
\ No newline at end of file
diff --git a/logs/k7/add.log b/logs/k7/add.log
deleted file mode 100644
index 796ab48..0000000
--- a/logs/k7/add.log
+++ /dev/null
@@ -1,16 +0,0 @@
-224 11069160
-448 9156136
-672 8089755
-896 7399424
-1120 6389352
-1344 5818648
-1568 5257112
-1792 4982160
-2016 4527856
-2240 4325312
-2464 4051760
-2688 3767640
-2912 3612520
-3136 3415208
-3360 3258656
-3584 3113360
diff --git a/logs/k7/addsub.png b/logs/k7/addsub.png
deleted file mode 100644
index 56391d9..0000000
Binary files a/logs/k7/addsub.png and /dev/null differ
diff --git a/logs/k7/expt.log b/logs/k7/expt.log
deleted file mode 100644
index 46bb50b..0000000
--- a/logs/k7/expt.log
+++ /dev/null
@@ -1,7 +0,0 @@
-513 664
-769 256
-1025 117
-2049 17
-2561 9
-3073 5
-4097 2
diff --git a/logs/k7/expt.png b/logs/k7/expt.png
deleted file mode 100644
index fc82677..0000000
Binary files a/logs/k7/expt.png and /dev/null differ
diff --git a/logs/k7/expt_dr.log b/logs/k7/expt_dr.log
deleted file mode 100644
index 7df658f..0000000
--- a/logs/k7/expt_dr.log
+++ /dev/null
@@ -1,7 +0,0 @@
-532 1088
-784 460
-1036 240
-1540 92
-2072 43
-3080 15
-4116 6
diff --git a/logs/k7/graphs.dem b/logs/k7/graphs.dem
deleted file mode 100644
index c580495..0000000
--- a/logs/k7/graphs.dem
+++ /dev/null
@@ -1,17 +0,0 @@
-set terminal png color
-set size 1.75
-set ylabel "Operations per Second"
-set xlabel "Operand size (bits)"
-
-set output "addsub.png"
-plot 'add.log' smooth bezier title "Addition", 'sub.log' smooth bezier title "Subtraction"
-
-set output "mult.png"
-plot 'sqr.log' smooth bezier title "Squaring (without Karatsuba)", 'sqr_kara.log' smooth bezier title "Squaring (Karatsuba)", 'mult.log' smooth bezier title "Multiplication (without Karatsuba)", 'mult_kara.log' smooth bezier title "Multiplication (Karatsuba)"
-
-set output "expt.png"
-plot 'expt.log' smooth bezier title "Exptmod (Montgomery)", 'expt_dr.log' smooth bezier title "Exptmod (Dimminished Radix)"
-
-set output "invmod.png"
-plot 'invmod.log' smooth bezier title "Modular Inverse"
-
diff --git a/logs/k7/index.html b/logs/k7/index.html
deleted file mode 100644
index 19fe403..0000000
--- a/logs/k7/index.html
+++ /dev/null
@@ -1,24 +0,0 @@
-<html>
-<head>
-<title>LibTomMath Log Plots</title>
-</head>
-<body>
-
-<h1>Addition and Subtraction</h1>
-<center><img src=addsub.png></center>
-<hr>
-
-<h1>Multipliers</h1>
-<center><img src=mult.png></center>
-<hr>
-
-<h1>Exptmod</h1>
-<center><img src=expt.png></center>
-<hr>
-
-<h1>Modular Inverse</h1>
-<center><img src=invmod.png></center>
-<hr>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/logs/k7/invmod.log b/logs/k7/invmod.log
deleted file mode 100644
index d1198fb..0000000
--- a/logs/k7/invmod.log
+++ /dev/null
@@ -1,32 +0,0 @@
-112 16248
-224 8192
-336 5320
-448 3560
-560 2728
-672 2064
-784 1704
-896 2176
-1008 1184
-1120 976
-1232 1280
-1344 1176
-1456 624
-1568 912
-1680 504
-1792 452
-1904 658
-2016 608
-2128 336
-2240 312
-2352 288
-2464 264
-2576 408
-2688 376
-2800 354
-2912 198
-3024 307
-3136 173
-3248 162
-3360 256
-3472 145
-3584 226
diff --git a/logs/k7/invmod.png b/logs/k7/invmod.png
deleted file mode 100644
index a497a72..0000000
Binary files a/logs/k7/invmod.png and /dev/null differ
diff --git a/logs/k7/mult.log b/logs/k7/mult.log
deleted file mode 100644
index 4b1bff3..0000000
--- a/logs/k7/mult.log
+++ /dev/null
@@ -1,17 +0,0 @@
-896 322904
-1344 151592
-1792 90472
-2240 59984
-2688 42624
-3136 31872
-3584 24704
-4032 19704
-4480 16096
-4928 13376
-5376 11272
-5824 9616
-6272 8360
-6720 7304
-7168 1664
-7616 1472
-8064 1328
diff --git a/logs/k7/mult.png b/logs/k7/mult.png
deleted file mode 100644
index 3cd8a93..0000000
Binary files a/logs/k7/mult.png and /dev/null differ
diff --git a/logs/k7/mult_kara.log b/logs/k7/mult_kara.log
deleted file mode 100644
index 53c0864..0000000
--- a/logs/k7/mult_kara.log
+++ /dev/null
@@ -1,17 +0,0 @@
-896 322872
-1344 151688
-1792 90480
-2240 59984
-2688 42656
-3136 32144
-3584 25840
-4032 21328
-4480 17856
-4928 14928
-5376 12856
-5824 11256
-6272 9880
-6720 8984
-7168 7928
-7616 7200
-8064 6576
diff --git a/logs/k7/sqr.log b/logs/k7/sqr.log
deleted file mode 100644
index 2fb2e98..0000000
--- a/logs/k7/sqr.log
+++ /dev/null
@@ -1,17 +0,0 @@
-896 415472
-1344 223736
-1792 141232
-2240 97624
-2688 71400
-3136 54800
-3584 16904
-4032 13528
-4480 10968
-4928 9128
-5376 7784
-5824 6672
-6272 5760
-6720 5056
-7168 4440
-7616 3952
-8064 3512
diff --git a/logs/k7/sqr_kara.log b/logs/k7/sqr_kara.log
deleted file mode 100644
index ba30f9e..0000000
--- a/logs/k7/sqr_kara.log
+++ /dev/null
@@ -1,17 +0,0 @@
-896 420464
-1344 224800
-1792 142808
-2240 97704
-2688 71416
-3136 54504
-3584 38320
-4032 32360
-4480 27576
-4928 23840
-5376 20688
-5824 18264
-6272 16176
-6720 14440
-7168 11688
-7616 10752
-8064 9936
diff --git a/logs/k7/sub.log b/logs/k7/sub.log
deleted file mode 100644
index 91c7d65..0000000
--- a/logs/k7/sub.log
+++ /dev/null
@@ -1,16 +0,0 @@
-224 9728504
-448 8573648
-672 7488096
-896 6714064
-1120 5950472
-1344 5457400
-1568 5038896
-1792 4683632
-2016 4384656
-2240 4105976
-2464 3871608
-2688 3650680
-2912 3463552
-3136 3290016
-3360 3135272
-3584 2993848
diff --git a/logs/mult.log b/logs/mult.log
index d4f5899..5b2d258 100644
--- a/logs/mult.log
+++ b/logs/mult.log
@@ -1,33 +1,33 @@
-920 374785
-1142 242737
-1371 176704
-1596 134341
-1816 105537
-2044 85089
-2268 70051
-2490 58671
-2716 49851
-2937 42881
-3162 37288
-3387 32697
-3608 28915
-3836 25759
-4057 23088
-4284 20800
-4508 18827
-4730 17164
-4956 15689
-5180 14397
-5398 13260
-5628 12249
-5852 11346
-6071 10537
-6298 9812
-6522 9161
-6742 8572
-6971 8038
-7195 2915
-7419 2744
-7644 2587
-7866 2444
-8090 2311
+923 45612
+1143 68010
+1370 94894
+1596 126514
+1820 163014
+2044 203564
+2268 249156
+2492 299226
+2716 354138
+2940 413022
+3163 477406
+3387 545876
+3612 619044
+3835 696754
+4060 779174
+4284 866216
+4508 958100
+4731 1055898
+4954 1162294
+5179 1267654
+5404 1377572
+5628 1503736
+5852 1622310
+6076 1746624
+6299 1875390
+6524 2009086
+6748 2145990
+6971 2289044
+7196 2891644
+7418 3064792
+7644 3249780
+7868 3455868
+8092 3644238
diff --git a/logs/mult.png b/logs/mult.png
index d304db2..4f7a4ee 100644
Binary files a/logs/mult.png and b/logs/mult.png differ
diff --git a/logs/mult_kara.log b/logs/mult_kara.log
index 6edc439..c69769b 100644
--- a/logs/mult_kara.log
+++ b/logs/mult_kara.log
@@ -1,33 +1,33 @@
-924 374171
-1147 243163
-1371 177111
-1596 134465
-1819 105619
-2044 85145
-2266 70086
-2488 58717
-2715 49869
-2939 42894
-3164 37389
-3387 33510
-3610 29993
-3836 27205
-4060 24751
-4281 22576
-4508 20670
-4732 19019
-4954 17527
-5180 16217
-5404 15044
-5624 14003
-5849 13051
-6076 12067
-6300 11438
-6524 10772
-6748 10298
-6972 9715
-7195 9330
-7416 8836
-7644 8465
-7864 8042
-8091 7735
+921 92388
+1148 61410
+1372 43799
+1594 33047
+1819 26913
+2043 21996
+2268 18453
+2492 15623
+2715 13378
+2940 11626
+3164 10252
+3385 9291
+3610 8348
+3835 7615
+4060 6928
+4283 6401
+4508 5836
+4732 5387
+4955 4985
+5178 4614
+5404 4300
+5622 4005
+5852 3742
+6073 3502
+6298 3262
+6524 3137
+6748 2967
+6971 2807
+7195 2679
+7420 2571
+7643 2442
+7867 2324
+8091 2235
diff --git a/logs/p4/README b/logs/p4/README
deleted file mode 100644
index ea20c81..0000000
--- a/logs/p4/README
+++ /dev/null
@@ -1,13 +0,0 @@
-To use the pretty graphs you have to first build/run the ltmtest from the root directory of the package.
-Todo this type
-
-make timing ; ltmtest
-
-in the root. It will run for a while [about ten minutes on most PCs] and produce a series of .log files in logs/.
-
-After doing that run "gnuplot graphs.dem" to make the PNGs. If you managed todo that all so far just open index.html to view
-them all :-)
-
-Have fun
-
-Tom
\ No newline at end of file
diff --git a/logs/p4/add.log b/logs/p4/add.log
deleted file mode 100644
index 72b2506..0000000
--- a/logs/p4/add.log
+++ /dev/null
@@ -1,16 +0,0 @@
-224 8113248
-448 6585584
-672 5687678
-896 4761144
-1120 4111592
-1344 3995154
-1568 3532387
-1792 3225400
-2016 2963960
-2240 2720112
-2464 2533952
-2688 2307168
-2912 2287064
-3136 2150160
-3360 2035992
-3584 1936304
diff --git a/logs/p4/addsub.png b/logs/p4/addsub.png
deleted file mode 100644
index f4398ca..0000000
Binary files a/logs/p4/addsub.png and /dev/null differ
diff --git a/logs/p4/expt.log b/logs/p4/expt.log
deleted file mode 100644
index 3e6ffb8..0000000
--- a/logs/p4/expt.log
+++ /dev/null
@@ -1,7 +0,0 @@
-513 195
-769 68
-1025 31
-2049 4
-2561 2
-3073 1
-4097 0
diff --git a/logs/p4/expt.png b/logs/p4/expt.png
deleted file mode 100644
index dac1ce2..0000000
Binary files a/logs/p4/expt.png and /dev/null differ
diff --git a/logs/p4/expt_dr.log b/logs/p4/expt_dr.log
deleted file mode 100644
index 2f5f6a3..0000000
--- a/logs/p4/expt_dr.log
+++ /dev/null
@@ -1,7 +0,0 @@
-532 393
-784 158
-1036 79
-1540 27
-2072 12
-3080 4
-4116 1
diff --git a/logs/p4/graphs.dem b/logs/p4/graphs.dem
deleted file mode 100644
index c580495..0000000
--- a/logs/p4/graphs.dem
+++ /dev/null
@@ -1,17 +0,0 @@
-set terminal png color
-set size 1.75
-set ylabel "Operations per Second"
-set xlabel "Operand size (bits)"
-
-set output "addsub.png"
-plot 'add.log' smooth bezier title "Addition", 'sub.log' smooth bezier title "Subtraction"
-
-set output "mult.png"
-plot 'sqr.log' smooth bezier title "Squaring (without Karatsuba)", 'sqr_kara.log' smooth bezier title "Squaring (Karatsuba)", 'mult.log' smooth bezier title "Multiplication (without Karatsuba)", 'mult_kara.log' smooth bezier title "Multiplication (Karatsuba)"
-
-set output "expt.png"
-plot 'expt.log' smooth bezier title "Exptmod (Montgomery)", 'expt_dr.log' smooth bezier title "Exptmod (Dimminished Radix)"
-
-set output "invmod.png"
-plot 'invmod.log' smooth bezier title "Modular Inverse"
-
diff --git a/logs/p4/index.html b/logs/p4/index.html
deleted file mode 100644
index 19fe403..0000000
--- a/logs/p4/index.html
+++ /dev/null
@@ -1,24 +0,0 @@
-<html>
-<head>
-<title>LibTomMath Log Plots</title>
-</head>
-<body>
-
-<h1>Addition and Subtraction</h1>
-<center><img src=addsub.png></center>
-<hr>
-
-<h1>Multipliers</h1>
-<center><img src=mult.png></center>
-<hr>
-
-<h1>Exptmod</h1>
-<center><img src=expt.png></center>
-<hr>
-
-<h1>Modular Inverse</h1>
-<center><img src=invmod.png></center>
-<hr>
-
-</body>
-</html>
\ No newline at end of file
diff --git a/logs/p4/invmod.log b/logs/p4/invmod.log
deleted file mode 100644
index 096087b..0000000
--- a/logs/p4/invmod.log
+++ /dev/null
@@ -1,32 +0,0 @@
-112 13608
-224 6872
-336 4264
-448 2792
-560 2144
-672 1560
-784 1296
-896 1672
-1008 896
-1120 736
-1232 1024
-1344 888
-1456 472
-1568 680
-1680 373
-1792 328
-1904 484
-2016 436
-2128 232
-2240 211
-2352 200
-2464 177
-2576 293
-2688 262
-2800 251
-2912 137
-3024 216
-3136 117
-3248 113
-3360 181
-3472 98
-3584 158
diff --git a/logs/p4/invmod.png b/logs/p4/invmod.png
deleted file mode 100644
index 3b0580f..0000000
Binary files a/logs/p4/invmod.png and /dev/null differ
diff --git a/logs/p4/mult.log b/logs/p4/mult.log
deleted file mode 100644
index 6e43806..0000000
--- a/logs/p4/mult.log
+++ /dev/null
@@ -1,17 +0,0 @@
-896 77600
-1344 35776
-1792 19688
-2240 13248
-2688 9424
-3136 7056
-3584 5464
-4032 4368
-4480 3568
-4928 2976
-5376 2520
-5824 2152
-6272 1872
-6720 1632
-7168 650
-7616 576
-8064 515
diff --git a/logs/p4/mult.png b/logs/p4/mult.png
deleted file mode 100644
index 8623558..0000000
Binary files a/logs/p4/mult.png and /dev/null differ
diff --git a/logs/p4/mult_kara.log b/logs/p4/mult_kara.log
deleted file mode 100644
index e1d50a6..0000000
--- a/logs/p4/mult_kara.log
+++ /dev/null
@@ -1,17 +0,0 @@
-896 77752
-1344 35832
-1792 19688
-2240 14704
-2688 10832
-3136 8336
-3584 6600
-4032 5424
-4480 4648
-4928 3976
-5376 3448
-5824 3016
-6272 2664
-6720 2384
-7168 2120
-7616 1912
-8064 1752
diff --git a/logs/p4/sqr.log b/logs/p4/sqr.log
deleted file mode 100644
index b133fb3..0000000
--- a/logs/p4/sqr.log
+++ /dev/null
@@ -1,17 +0,0 @@
-896 128088
-1344 63640
-1792 37968
-2240 25488
-2688 18176
-3136 13672
-3584 4920
-4032 3912
-4480 3160
-4928 2616
-5376 2216
-5824 1896
-6272 1624
-6720 1408
-7168 1240
-7616 1096
-8064 984
diff --git a/logs/p4/sqr_kara.log b/logs/p4/sqr_kara.log
deleted file mode 100644
index 13e4f3e..0000000
--- a/logs/p4/sqr_kara.log
+++ /dev/null
@@ -1,17 +0,0 @@
-896 127456
-1344 63752
-1792 37920
-2240 25440
-2688 18200
-3136 13728
-3584 10968
-4032 9072
-4480 7608
-4928 6440
-5376 5528
-5824 4768
-6272 4328
-6720 3888
-7168 3504
-7616 3176
-8064 2896
diff --git a/logs/p4/sub.log b/logs/p4/sub.log
deleted file mode 100644
index 424de32..0000000
--- a/logs/p4/sub.log
+++ /dev/null
@@ -1,16 +0,0 @@
-224 7355896
-448 6162880
-672 5218984
-896 4622776
-1120 3999320
-1344 3629480
-1568 3290384
-1792 2954752
-2016 2737056
-2240 2563320
-2464 2451928
-2688 2310920
-2912 2139048
-3136 2034080
-3360 1890800
-3584 1808624
diff --git a/logs/sqr.log b/logs/sqr.log
index 81fa612..ec142fe 100644
--- a/logs/sqr.log
+++ b/logs/sqr.log
@@ -1,33 +1,33 @@
-922 471095
-1147 337137
-1366 254327
-1596 199732
-1819 161225
-2044 132852
-2268 111493
-2490 94864
-2715 81745
-2940 71187
-3162 62575
-3387 55418
-3612 14540
-3836 12944
-4060 11627
-4281 10546
-4508 9502
-4730 8688
-4954 7937
-5180 7273
-5402 6701
-5627 6189
-5850 5733
-6076 5310
-6300 4933
-6522 4631
-6748 4313
-6971 4064
-7196 3801
-7420 3576
-7642 3388
-7868 3191
-8092 3020
+924 26026
+1146 37682
+1370 51714
+1595 68130
+1820 86850
+2043 107880
+2267 131236
+2490 156828
+2716 184704
+2940 214934
+3162 247424
+3388 282494
+3608 308390
+3834 345978
+4060 386156
+4282 427648
+4505 471556
+4731 517948
+4954 566396
+5180 618292
+5402 670130
+5628 725674
+5852 783310
+6076 843480
+6300 905136
+6524 969132
+6748 1033680
+6971 1100912
+7195 1170954
+7420 1252576
+7643 1325038
+7867 1413890
+8091 1493140
diff --git a/logs/sqr_kara.log b/logs/sqr_kara.log
index 3b547cf..f75256a 100644
--- a/logs/sqr_kara.log
+++ b/logs/sqr_kara.log
@@ -1,33 +1,33 @@
-922 470930
-1148 337217
-1372 254433
-1596 199827
-1820 161204
-2043 132871
-2267 111522
-2488 94932
-2714 81814
-2939 71231
-3164 62616
-3385 55467
-3611 44426
-3836 40695
-4060 37391
-4283 34371
-4508 31779
-4732 29499
-4956 27426
-5177 25598
-5403 23944
-5628 22416
-5851 21052
-6076 19781
-6299 18588
-6523 17539
-6746 16618
-6972 15705
-7196 13582
-7420 13004
-7643 12496
-7868 11963
-8092 11497
+923 165854
+1146 112539
+1372 80388
+1595 60051
+1820 47498
+2044 38017
+2268 31935
+2492 27373
+2714 23798
+2939 20630
+3164 18198
+3388 16191
+3612 14538
+3836 13038
+4058 11683
+4284 10915
+4508 9998
+4731 9271
+4954 8555
+5180 7910
+5404 7383
+5628 7012
+5852 6527
+6075 6175
+6299 5737
+6524 5398
+6744 5110
+6971 4864
+7196 4567
+7420 4371
+7644 4182
+7868 3981
+8092 3758
diff --git a/logs/sub.log b/logs/sub.log
index f1ade94..97ea200 100644
--- a/logs/sub.log
+++ b/logs/sub.log
@@ -1,16 +1,16 @@
-224 16370431
-448 13327848
-672 11009401
-896 9125342
-1120 7930419
-1344 7114040
-1568 6506998
-1792 5899346
-2016 5435327
-2240 5038931
-2464 4696364
-2688 4425678
-2912 4134476
-3136 3913280
-3360 3692536
-3584 3505219
+224 2012
+448 2208
+672 2366
+896 2532
+1120 2682
+1344 2838
+1568 3016
+1792 3146
+2016 3318
+2240 3538
+2464 3756
+2688 3914
+2912 4060
+3136 4216
+3360 4392
+3584 4550
diff --git a/makefile b/makefile
index 07b7842..95bd003 100644
--- a/makefile
+++ b/makefile
@@ -12,7 +12,10 @@ CFLAGS += -O3 -funroll-loops
#x86 optimizations [should be valid for any GCC install though]
CFLAGS += -fomit-frame-pointer
-VERSION=0.30
+#debug
+#CFLAGS += -g3
+
+VERSION=0.31
default: libtommath.a
@@ -20,7 +23,7 @@ default: libtommath.a
LIBNAME=libtommath.a
HEADERS=tommath.h
-#LIBPATH-The directory for libtomcrypt to be installed to.
+#LIBPATH-The directory for libtommath to be installed to.
#INCPATH-The directory to install the header files for libtommath.
#DATAPATH-The directory to install the pdf docs.
DESTDIR=
@@ -58,6 +61,30 @@ libtommath.a: $(OBJECTS)
$(AR) $(ARFLAGS) libtommath.a $(OBJECTS)
ranlib libtommath.a
+
+#make a profiled library (takes a while!!!)
+#
+# This will build the library with profile generation
+# then run the test demo and rebuild the library.
+#
+# So far I've seen improvements in the MP math
+profiled:
+ make CFLAGS="$(CFLAGS) -fprofile-arcs -DTESTING" timing
+ ./ltmtest
+ rm -f *.a *.o ltmtest
+ make CFLAGS="$(CFLAGS) -fbranch-probabilities"
+
+#make a single object profiled library
+profiled_single:
+ perl gen.pl
+ $(CC) $(CFLAGS) -fprofile-arcs -DTESTING -c mpi.c -o mpi.o
+ $(CC) $(CFLAGS) -DTESTING -DTIMER demo/timing.c mpi.o -o ltmtest
+ ./ltmtest
+ rm -f *.o ltmtest
+ $(CC) $(CFLAGS) -fbranch-probabilities -DTESTING -c mpi.c -o mpi.o
+ $(AR) $(ARFLAGS) libtommath.a mpi.o
+ ranlib libtommath.a
+
install: libtommath.a
install -d -g root -o root $(DESTDIR)$(LIBPATH)
install -d -g root -o root $(DESTDIR)$(INCPATH)
@@ -71,7 +98,7 @@ mtest: test
cd mtest ; $(CC) $(CFLAGS) mtest.c -o mtest -s
timing: libtommath.a
- $(CC) $(CFLAGS) -DTIMER demo/demo.c libtommath.a -o ltmtest -s
+ $(CC) $(CFLAGS) -DTIMER demo/timing.c libtommath.a -o ltmtest -s
# makes the LTM book DVI file, requires tetex, perl and makeindex [part of tetex I think]
docdvi: tommath.src
@@ -106,10 +133,13 @@ mandvi: bn.tex
manual: mandvi
pdflatex bn >/dev/null
rm -f bn.aux bn.dvi bn.log bn.idx bn.lof bn.out bn.toc
-
+
+pretty:
+ perl pretty.build
+
clean:
rm -f *.bat *.pdf *.o *.a *.obj *.lib *.exe *.dll etclib/*.o demo/demo.o test ltmtest mpitest mtest/mtest mtest/mtest.exe \
- *.idx *.toc *.log *.aux *.dvi *.lof *.ind *.ilg *.ps *.log *.s mpi.c
+ *.idx *.toc *.log *.aux *.dvi *.lof *.ind *.ilg *.ps *.log *.s mpi.c *.da *.dyn *.dpi tommath.tex *~ demo/*~ etc/*~
cd etc ; make clean
cd pics ; make clean
diff --git a/makefile.bcc b/makefile.bcc
index 6874d2f..b71f380 100644
--- a/makefile.bcc
+++ b/makefile.bcc
@@ -30,7 +30,8 @@ bn_mp_reduce_2k.obj bn_mp_reduce_is_2k.obj bn_mp_reduce_2k_setup.obj \
bn_mp_radix_smap.obj bn_mp_read_radix.obj bn_mp_toradix.obj bn_mp_radix_size.obj \
bn_mp_fread.obj bn_mp_fwrite.obj bn_mp_cnt_lsb.obj bn_error.obj \
bn_mp_init_multi.obj bn_mp_clear_multi.obj bn_prime_sizes_tab.obj bn_mp_exteuclid.obj bn_mp_toradix_n.obj \
-bn_mp_prime_random_ex.obj bn_mp_get_int.obj bn_mp_sqrt.obj bn_mp_is_square.obj
+bn_mp_prime_random_ex.obj bn_mp_get_int.obj bn_mp_sqrt.obj bn_mp_is_square.obj \
+bn_mp_init_set.obj bn_mp_init_set_int.obj
TARGET = libtommath.lib
diff --git a/makefile.cygwin_dll b/makefile.cygwin_dll
index e5ab814..332a328 100644
--- a/makefile.cygwin_dll
+++ b/makefile.cygwin_dll
@@ -35,7 +35,8 @@ bn_mp_reduce_2k.o bn_mp_reduce_is_2k.o bn_mp_reduce_2k_setup.o \
bn_mp_radix_smap.o bn_mp_read_radix.o bn_mp_toradix.o bn_mp_radix_size.o \
bn_mp_fread.o bn_mp_fwrite.o bn_mp_cnt_lsb.o bn_error.o \
bn_mp_init_multi.o bn_mp_clear_multi.o bn_prime_sizes_tab.o bn_mp_exteuclid.o bn_mp_toradix_n.o \
-bn_mp_prime_random_ex.o bn_mp_get_int.o bn_mp_sqrt.o bn_mp_is_square.o
+bn_mp_prime_random_ex.o bn_mp_get_int.o bn_mp_sqrt.o bn_mp_is_square.o bn_mp_init_set.o \
+bn_mp_init_set_int.o
# make a Windows DLL via Cygwin
windll: $(OBJECTS)
diff --git a/makefile.icc b/makefile.icc
new file mode 100644
index 0000000..e4c0d19
--- /dev/null
+++ b/makefile.icc
@@ -0,0 +1,110 @@
+#Makefile for ICC
+#
+#Tom St Denis
+CC=icc
+
+CFLAGS += -I./
+
+# optimize for SPEED
+#
+# -mcpu= can be pentium, pentiumpro (covers PII through PIII) or pentium4
+# -ax? specifies make code specifically for ? but compatible with IA-32
+# -x? specifies compile solely for ? [not specifically IA-32 compatible]
+#
+# where ? is
+# K - PIII
+# W - first P4 [Williamette]
+# N - P4 Northwood
+# P - P4 Prescott
+# B - Blend of P4 and PM [mobile]
+#
+# Default to just generic max opts
+CFLAGS += -O3 -xN
+
+default: libtommath.a
+
+#default files to install
+LIBNAME=libtommath.a
+HEADERS=tommath.h
+
+#LIBPATH-The directory for libtomcrypt to be installed to.
+#INCPATH-The directory to install the header files for libtommath.
+#DATAPATH-The directory to install the pdf docs.
+DESTDIR=
+LIBPATH=/usr/lib
+INCPATH=/usr/include
+DATAPATH=/usr/share/doc/libtommath/pdf
+
+OBJECTS=bncore.o bn_mp_init.o bn_mp_clear.o bn_mp_exch.o bn_mp_grow.o bn_mp_shrink.o \
+bn_mp_clamp.o bn_mp_zero.o bn_mp_set.o bn_mp_set_int.o bn_mp_init_size.o bn_mp_copy.o \
+bn_mp_init_copy.o bn_mp_abs.o bn_mp_neg.o bn_mp_cmp_mag.o bn_mp_cmp.o bn_mp_cmp_d.o \
+bn_mp_rshd.o bn_mp_lshd.o bn_mp_mod_2d.o bn_mp_div_2d.o bn_mp_mul_2d.o bn_mp_div_2.o \
+bn_mp_mul_2.o bn_s_mp_add.o bn_s_mp_sub.o bn_fast_s_mp_mul_digs.o bn_s_mp_mul_digs.o \
+bn_fast_s_mp_mul_high_digs.o bn_s_mp_mul_high_digs.o bn_fast_s_mp_sqr.o bn_s_mp_sqr.o \
+bn_mp_add.o bn_mp_sub.o bn_mp_karatsuba_mul.o bn_mp_mul.o bn_mp_karatsuba_sqr.o \
+bn_mp_sqr.o bn_mp_div.o bn_mp_mod.o bn_mp_add_d.o bn_mp_sub_d.o bn_mp_mul_d.o \
+bn_mp_div_d.o bn_mp_mod_d.o bn_mp_expt_d.o bn_mp_addmod.o bn_mp_submod.o \
+bn_mp_mulmod.o bn_mp_sqrmod.o bn_mp_gcd.o bn_mp_lcm.o bn_fast_mp_invmod.o bn_mp_invmod.o \
+bn_mp_reduce.o bn_mp_montgomery_setup.o bn_fast_mp_montgomery_reduce.o bn_mp_montgomery_reduce.o \
+bn_mp_exptmod_fast.o bn_mp_exptmod.o bn_mp_2expt.o bn_mp_n_root.o bn_mp_jacobi.o bn_reverse.o \
+bn_mp_count_bits.o bn_mp_read_unsigned_bin.o bn_mp_read_signed_bin.o bn_mp_to_unsigned_bin.o \
+bn_mp_to_signed_bin.o bn_mp_unsigned_bin_size.o bn_mp_signed_bin_size.o \
+bn_mp_xor.o bn_mp_and.o bn_mp_or.o bn_mp_rand.o bn_mp_montgomery_calc_normalization.o \
+bn_mp_prime_is_divisible.o bn_prime_tab.o bn_mp_prime_fermat.o bn_mp_prime_miller_rabin.o \
+bn_mp_prime_is_prime.o bn_mp_prime_next_prime.o bn_mp_dr_reduce.o \
+bn_mp_dr_is_modulus.o bn_mp_dr_setup.o bn_mp_reduce_setup.o \
+bn_mp_toom_mul.o bn_mp_toom_sqr.o bn_mp_div_3.o bn_s_mp_exptmod.o \
+bn_mp_reduce_2k.o bn_mp_reduce_is_2k.o bn_mp_reduce_2k_setup.o \
+bn_mp_radix_smap.o bn_mp_read_radix.o bn_mp_toradix.o bn_mp_radix_size.o \
+bn_mp_fread.o bn_mp_fwrite.o bn_mp_cnt_lsb.o bn_error.o \
+bn_mp_init_multi.o bn_mp_clear_multi.o bn_prime_sizes_tab.o bn_mp_exteuclid.o bn_mp_toradix_n.o \
+bn_mp_prime_random_ex.o bn_mp_get_int.o bn_mp_sqrt.o bn_mp_is_square.o bn_mp_init_set.o \
+bn_mp_init_set_int.o
+
+libtommath.a: $(OBJECTS)
+ $(AR) $(ARFLAGS) libtommath.a $(OBJECTS)
+ ranlib libtommath.a
+
+#make a profiled library (takes a while!!!)
+#
+# This will build the library with profile generation
+# then run the test demo and rebuild the library.
+#
+# So far I've seen improvements in the MP math
+profiled:
+ make -f makefile.icc CFLAGS="$(CFLAGS) -prof_gen -DTESTING" timing
+ ./ltmtest
+ rm -f *.a *.o ltmtest
+ make -f makefile.icc CFLAGS="$(CFLAGS) -prof_use"
+
+#make a single object profiled library
+profiled_single:
+ perl gen.pl
+ $(CC) $(CFLAGS) -prof_gen -DTESTING -c mpi.c -o mpi.o
+ $(CC) $(CFLAGS) -DTESTING -DTIMER demo/demo.c mpi.o -o ltmtest
+ ./ltmtest
+ rm -f *.o ltmtest
+ $(CC) $(CFLAGS) -prof_use -ip -DTESTING -c mpi.c -o mpi.o
+ $(AR) $(ARFLAGS) libtommath.a mpi.o
+ ranlib libtommath.a
+
+install: libtommath.a
+ install -d -g root -o root $(DESTDIR)$(LIBPATH)
+ install -d -g root -o root $(DESTDIR)$(INCPATH)
+ install -g root -o root $(LIBNAME) $(DESTDIR)$(LIBPATH)
+ install -g root -o root $(HEADERS) $(DESTDIR)$(INCPATH)
+
+test: libtommath.a demo/demo.o
+ $(CC) demo/demo.o libtommath.a -o test
+
+mtest: test
+ cd mtest ; $(CC) $(CFLAGS) mtest.c -o mtest
+
+timing: libtommath.a
+ $(CC) $(CFLAGS) -DTIMER demo/timing.c libtommath.a -o ltmtest
+
+clean:
+ rm -f *.bat *.pdf *.o *.a *.obj *.lib *.exe *.dll etclib/*.o demo/demo.o test ltmtest mpitest mtest/mtest mtest/mtest.exe \
+ *.idx *.toc *.log *.aux *.dvi *.lof *.ind *.ilg *.ps *.log *.s mpi.c *.il etc/*.il *.dyn
+ cd etc ; make clean
+ cd pics ; make clean
diff --git a/makefile.msvc b/makefile.msvc
index beeb77e..7d67442 100644
--- a/makefile.msvc
+++ b/makefile.msvc
@@ -29,7 +29,8 @@ bn_mp_reduce_2k.obj bn_mp_reduce_is_2k.obj bn_mp_reduce_2k_setup.obj \
bn_mp_radix_smap.obj bn_mp_read_radix.obj bn_mp_toradix.obj bn_mp_radix_size.obj \
bn_mp_fread.obj bn_mp_fwrite.obj bn_mp_cnt_lsb.obj bn_error.obj \
bn_mp_init_multi.obj bn_mp_clear_multi.obj bn_prime_sizes_tab.obj bn_mp_exteuclid.obj bn_mp_toradix_n.obj \
-bn_mp_prime_random_ex.obj bn_mp_get_int.obj bn_mp_sqrt.obj bn_mp_is_square.obj
+bn_mp_prime_random_ex.obj bn_mp_get_int.obj bn_mp_sqrt.obj bn_mp_is_square.obj \
+bn_mp_init_set.obj bn_mp_init_set_int.obj
library: $(OBJECTS)
lib /out:tommath.lib $(OBJECTS)
diff --git a/poster.pdf b/poster.pdf
index 3731bd2..6689f2e 100644
Binary files a/poster.pdf and b/poster.pdf differ
diff --git a/pre_gen/mpi.c b/pre_gen/mpi.c
index 1f9997f..370b34d 100644
--- a/pre_gen/mpi.c
+++ b/pre_gen/mpi.c
@@ -452,7 +452,7 @@ fast_s_mp_mul_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
}
/* setup dest */
- olduse = c->used;
+ olduse = c->used;
c->used = digs;
{
@@ -779,7 +779,7 @@ mp_2expt (mp_int * a, int b)
a->used = b / DIGIT_BIT + 1;
/* put the single bit in its place */
- a->dp[b / DIGIT_BIT] = 1 << (b % DIGIT_BIT);
+ a->dp[b / DIGIT_BIT] = ((mp_digit)1) << (b % DIGIT_BIT);
return MP_OKAY;
}
@@ -1142,10 +1142,14 @@ mp_clamp (mp_int * a)
void
mp_clear (mp_int * a)
{
+ int i;
+
/* only do anything if a hasn't been freed previously */
if (a->dp != NULL) {
/* first zero the digits */
- memset (a->dp, 0, sizeof (mp_digit) * a->used);
+ for (i = 0; i < a->used; i++) {
+ a->dp[i] = 0;
+ }
/* free ram */
XFREE(a->dp);
@@ -1677,7 +1681,7 @@ int mp_div (mp_int * a, mp_int * b, mp_int * c, mp_int * d)
*/
/* get sign before writing to c */
- x.sign = a->sign;
+ x.sign = x.used == 0 ? MP_ZPOS : a->sign;
if (c != NULL) {
mp_clamp (&q);
@@ -3083,15 +3087,22 @@ int mp_grow (mp_int * a, int size)
*/
#include <tommath.h>
-/* init a new bigint */
+/* init a new mp_int */
int mp_init (mp_int * a)
{
+ int i;
+
/* allocate memory required and clear it */
- a->dp = OPT_CAST(mp_digit) XCALLOC (sizeof (mp_digit), MP_PREC);
+ a->dp = OPT_CAST(mp_digit) XMALLOC (sizeof (mp_digit) * MP_PREC);
if (a->dp == NULL) {
return MP_MEM;
}
+ /* set the digits to zero */
+ for (i = 0; i < MP_PREC; i++) {
+ a->dp[i] = 0;
+ }
+
/* set the used to zero, allocated digits to the default precision
* and sign to positive */
a->used = 0;
@@ -3753,9 +3764,6 @@ int mp_karatsuba_mul (mp_int * a, mp_int * b, mp_int * c)
goto X0Y0;
/* now shift the digits */
- x0.sign = x1.sign = a->sign;
- y0.sign = y1.sign = b->sign;
-
x0.used = y0.used = B;
x1.used = a->used - B;
y1.used = b->used - B;
@@ -4484,7 +4492,7 @@ int mp_mul (mp_int * a, mp_int * b, mp_int * c)
res = s_mp_mul (a, b, c);
}
}
- c->sign = neg;
+ c->sign = (c->used > 0) ? neg : MP_ZPOS;
return res;
}
@@ -6090,7 +6098,8 @@ mp_reduce_2k_setup(mp_int *a, mp_digit *d)
/* determines if mp_reduce_2k can be used */
int mp_reduce_is_2k(mp_int *a)
{
- int ix, iy, iz, iw;
+ int ix, iy, iw;
+ mp_digit iz;
if (a->used == 0) {
return 0;
@@ -6107,7 +6116,7 @@ int mp_reduce_is_2k(mp_int *a)
return 0;
}
iz <<= 1;
- if (iz > (int)MP_MASK) {
+ if (iz > (mp_digit)MP_MASK) {
++iw;
iz = 1;
}
@@ -8396,14 +8405,16 @@ s_mp_sub (mp_int * a, mp_int * b, mp_int * c)
CPU /Compiler /MUL CUTOFF/SQR CUTOFF
-------------------------------------------------------------
- Intel P4 /GCC v3.2 / 70/ 108
- AMD Athlon XP /GCC v3.2 / 109/ 127
-
+ Intel P4 Northwood /GCC v3.3.3 / 59/ 81/profiled build
+ Intel P4 Northwood /GCC v3.3.3 / 59/ 80/profiled_single build
+ Intel P4 Northwood /ICC v8.0 / 57/ 70/profiled build
+ Intel P4 Northwood /ICC v8.0 / 54/ 76/profiled_single build
+ AMD Athlon XP /GCC v3.2 / 109/ 127/
+
*/
-/* configured for a AMD XP Thoroughbred core with etc/tune.c */
-int KARATSUBA_MUL_CUTOFF = 109, /* Min. number of digits before Karatsuba multiplication is used. */
- KARATSUBA_SQR_CUTOFF = 127, /* Min. number of digits before Karatsuba squaring is used. */
+int KARATSUBA_MUL_CUTOFF = 57, /* Min. number of digits before Karatsuba multiplication is used. */
+ KARATSUBA_SQR_CUTOFF = 70, /* Min. number of digits before Karatsuba squaring is used. */
TOOM_MUL_CUTOFF = 350, /* no optimal values of these are known yet so set em high */
TOOM_SQR_CUTOFF = 400;
diff --git a/pretty.build b/pretty.build
new file mode 100644
index 0000000..a708b8a
--- /dev/null
+++ b/pretty.build
@@ -0,0 +1,66 @@
+#!/bin/perl -w
+#
+# Cute little builder for perl
+# Total waste of development time...
+#
+# This will build all the object files and then the archive .a file
+# requires GCC, GNU make and a sense of humour.
+#
+# Tom St Denis
+use strict;
+
+my $count = 0;
+my $starttime = time;
+my $rate = 0;
+print "Scanning for source files...\n";
+foreach my $filename (glob "*.c") {
+ ++$count;
+}
+print "Source files to build: $count\nBuilding...\n";
+my $i = 0;
+my $lines = 0;
+my $filesbuilt = 0;
+foreach my $filename (glob "*.c") {
+ printf("Building %3.2f%%, ", (++$i/$count)*100.0);
+ if ($i % 4 == 0) { print "/, "; }
+ if ($i % 4 == 1) { print "-, "; }
+ if ($i % 4 == 2) { print "\\, "; }
+ if ($i % 4 == 3) { print "|, "; }
+ if ($rate > 0) {
+ my $tleft = ($count - $i) / $rate;
+ my $tsec = $tleft%60;
+ my $tmin = ($tleft/60)%60;
+ my $thour = ($tleft/3600)%60;
+ printf("%2d:%02d:%02d left, ", $thour, $tmin, $tsec);
+ }
+ my $cnt = ($i/$count)*30.0;
+ my $x = 0;
+ print "[";
+ for (; $x < $cnt; $x++) { print "#"; }
+ for (; $x < 30; $x++) { print " "; }
+ print "]\r";
+ my $tmp = $filename;
+ $tmp =~ s/\.c/".o"/ge;
+ if (open(SRC, "<$tmp")) {
+ close SRC;
+ } else {
+ !system("make $tmp > /dev/null 2>/dev/null") or die "\nERROR: Failed to make $tmp!!!\n";
+ open( SRC, "<$filename" ) or die "Couldn't open $filename for reading: $!";
+ ++$lines while (<SRC>);
+ close SRC or die "Error closing $filename after reading: $!";
+ ++$filesbuilt;
+ }
+
+ # update timer
+ if (time != $starttime) {
+ my $delay = time - $starttime;
+ $rate = $i/$delay;
+ }
+}
+
+# finish building the library
+printf("\nFinished building source (%d seconds, %3.2f files per second).\n", time - $starttime, $rate);
+print "Compiled approximately $filesbuilt files and $lines lines of code.\n";
+print "Doing final make (building archive...)\n";
+!system("make > /dev/null 2>/dev/null") or die "\nERROR: Failed to perform last make command!!!\n";
+print "done.\n";
\ No newline at end of file
diff --git a/tommath.pdf b/tommath.pdf
index fc3301a..bcc919a 100644
Binary files a/tommath.pdf and b/tommath.pdf differ
diff --git a/tommath.src b/tommath.src
index 0389831..6ee842d 100644
--- a/tommath.src
+++ b/tommath.src
@@ -258,7 +258,7 @@ floating point is meant to be implemented in hardware the precision of the manti
a mantissa of much larger precision than hardware alone can efficiently support. This approach could be useful where
scientific applications must minimize the total output error over long calculations.
-Another use for large integers is within arithmetic on polynomials of large characteristic (i.e. $GF(p)[x]$ for large $p$).
+Yet another use for large integers is within arithmetic on polynomials of large characteristic (i.e. $GF(p)[x]$ for large $p$).
In fact the library discussed within this text has already been used to form a polynomial basis library\footnote{See \url{http://poly.libtomcrypt.org} for more details.}.
\subsection{Benefits of Multiple Precision Arithmetic}
@@ -316,7 +316,7 @@ the reader how the algorithms fit together as well as where to start on various
\section{Discussion and Notation}
\subsection{Notation}
-A multiple precision integer of $n$-digits shall be denoted as $x = (x_{n-1} ... x_1 x_0)_{ \beta }$ and represent
+A multiple precision integer of $n$-digits shall be denoted as $x = (x_{n-1}, \ldots, x_1, x_0)_{ \beta }$ and represent
the integer $x \equiv \sum_{i=0}^{n-1} x_i\beta^i$. The elements of the array $x$ are said to be the radix $\beta$ digits
of the integer. For example, $x = (1,2,3)_{10}$ would represent the integer
$1\cdot 10^2 + 2\cdot10^1 + 3\cdot10^0 = 123$.
@@ -339,12 +339,11 @@ algorithms will be used to establish the relevant theory which will subsequently
precision algorithm to solve the same problem.
\subsection{Precision Notation}
-For the purposes of this text a single precision variable must be able to represent integers in the range
-$0 \le x < q \beta$ while a double precision variable must be able to represent integers in the range
-$0 \le x < q \beta^2$. The variable $\beta$ represents the radix of a single digit of a multiple precision integer and
-must be of the form $q^p$ for $q, p \in \Z^+$. The extra radix-$q$ factor allows additions and subtractions to proceed
-without truncation of the carry. Since all modern computers are binary, it is assumed that $q$ is two, for all intents
-and purposes.
+The variable $\beta$ represents the radix of a single digit of a multiple precision integer and
+must be of the form $q^p$ for $q, p \in \Z^+$. A single precision variable must be able to represent integers in
+the range $0 \le x < q \beta$ while a double precision variable must be able to represent integers in the range
+$0 \le x < q \beta^2$. The extra radix-$q$ factor allows additions and subtractions to proceed without truncation of the
+carry. Since all modern computers are binary, it is assumed that $q$ is two.
\index{mp\_digit} \index{mp\_word}
Within the source code that will be presented for each algorithm, the data type \textbf{mp\_digit} will represent
@@ -376,7 +375,7 @@ the $/$ division symbol is used the intention is to perform an integer division
$5/2 = 2$ which will often be written as $\lfloor 5/2 \rfloor = 2$ for clarity. When an expression is written as a
fraction a real value division is implied, for example ${5 \over 2} = 2.5$.
-The norm of a multiple precision integer, for example, $\vert \vert x \vert \vert$ will be used to represent the number of digits in the representation
+The norm of a multiple precision integer, for example $\vert \vert x \vert \vert$, will be used to represent the number of digits in the representation
of the integer. For example, $\vert \vert 123 \vert \vert = 3$ and $\vert \vert 79452 \vert \vert = 5$.
\subsection{Work Effort}
@@ -569,7 +568,7 @@ By building outwards from a base foundation instead of using a parallel design m
highly modular. Being highly modular is a desirable property of any project as it often means the resulting product
has a small footprint and updates are easy to perform.
-Usually when I start a project I will begin with the header file. I define the data types I think I will need and
+Usually when I start a project I will begin with the header files. I define the data types I think I will need and
prototype the initial functions that are not dependent on other functions (within the library). After I
implement these base functions I prototype more dependent functions and implement them. The process repeats until
I implement all of the functions I require. For example, in the case of LibTomMath I implemented functions such as
@@ -619,14 +618,26 @@ any such data type but it does provide for making composite data types known as
used within LibTomMath.
\index{mp\_int}
-\begin{verbatim}
-typedef struct {
- int used, alloc, sign;
- mp_digit *dp;
-} mp_int;
-\end{verbatim}
+\begin{figure}[here]
+\begin{center}
+\begin{small}
+%\begin{verbatim}
+\begin{tabular}{|l|}
+\hline
+typedef struct \{ \\
+\hspace{3mm}int used, alloc, sign;\\
+\hspace{3mm}mp\_digit *dp;\\
+\} \textbf{mp\_int}; \\
+\hline
+\end{tabular}
+%\end{verbatim}
+\end{small}
+\caption{The mp\_int Structure}
+\label{fig:mpint}
+\end{center}
+\end{figure}
-The mp\_int structure can be broken down as follows.
+The mp\_int structure (fig. \ref{fig:mpint}) can be broken down as follows.
\begin{enumerate}
\item The \textbf{used} parameter denotes how many digits of the array \textbf{dp} contain the digits used to represent
@@ -701,9 +712,10 @@ fault by dereferencing memory not owned by the application.
In the case of LibTomMath the only errors that are checked for are related to inappropriate inputs (division by zero for
instance) and memory allocation errors. It will not check that the mp\_int passed to any function is valid nor
will it check pointers for validity. Any function that can cause a runtime error will return an error code as an
-\textbf{int} data type with one of the following values.
+\textbf{int} data type with one of the following values (fig \ref{fig:errcodes}).
\index{MP\_OKAY} \index{MP\_VAL} \index{MP\_MEM}
+\begin{figure}[here]
\begin{center}
\begin{tabular}{|l|l|}
\hline \textbf{Value} & \textbf{Meaning} \\
@@ -713,6 +725,9 @@ will it check pointers for validity. Any function that can cause a runtime erro
\hline
\end{tabular}
\end{center}
+\caption{LibTomMath Error Codes}
+\label{fig:errcodes}
+\end{figure}
When an error is detected within a function it should free any memory it allocated, often during the initialization of
temporary mp\_ints, and return as soon as possible. The goal is to leave the system in the same state it was when the
@@ -748,6 +763,7 @@ to zero. The \textbf{used} count set to zero and \textbf{sign} set to \textbf{M
An mp\_int is said to be initialized if it is set to a valid, preferably default, state such that all of the members of the
structure are set to valid values. The mp\_init algorithm will perform such an action.
+\index{mp\_init}
\begin{figure}[here]
\begin{center}
\begin{tabular}{l}
@@ -770,17 +786,23 @@ structure are set to valid values. The mp\_init algorithm will perform such an
\end{figure}
\textbf{Algorithm mp\_init.}
-The \textbf{MP\_PREC} name represents a constant\footnote{Defined in the ``tommath.h'' header file within LibTomMath.}
-used to dictate the minimum precision of allocated mp\_int integers. Ideally, it is at least equal to $32$ since for most
-purposes that will be more than enough.
+The purpose of this function is to initialize an mp\_int structure so that the rest of the library can properly
+manipulte it. It is assumed that the input may not have had any of its members previously initialized which is certainly
+a valid assumption if the input resides on the stack.
-Memory for the default number of digits is allocated first. If the allocation fails the algorithm returns immediately
-with the \textbf{MP\_MEM} error code. If the allocation succeeds the remaining members of the mp\_int structure
-must be initialized to reflect the default initial state.
+Before any of the members such as \textbf{sign}, \textbf{used} or \textbf{alloc} are initialized the memory for
+the digits is allocated. If this fails the function returns before setting any of the other members. The \textbf{MP\_PREC}
+name represents a constant\footnote{Defined in the ``tommath.h'' header file within LibTomMath.}
+used to dictate the minimum precision of newly initialized mp\_int integers. Ideally, it is at least equal to the smallest
+precision number you'll be working with.
-The allocated digits are all set to zero (step three) to ensure they are in a known state. The \textbf{sign}, \textbf{used}
-and \textbf{alloc} are subsequently initialized to represent the zero integer. By step seven the algorithm returns a success
-code and the mp\_int $a$ has been successfully initialized to a valid state representing the integer zero.
+Allocating a block of digits at first instead of a single digit has the benefit of lowering the number of usually slow
+heap operations later functions will have to perform in the future. If \textbf{MP\_PREC} is set correctly the slack
+memory and the number of heap operations will be trivial.
+
+Once the allocation has been made the digits have to be set to zero as well as the \textbf{used}, \textbf{sign} and
+\textbf{alloc} members initialized. This ensures that the mp\_int will always represent the default state of zero regardless
+of the original condition of the input.
\textbf{Remark.}
This function introduces the idiosyncrasy that all iterative loops, commonly initiated with the ``for'' keyword, iterate incrementally
@@ -796,19 +818,21 @@ One immediate observation of this initializtion function is that it does not ret
is assumed that the caller has already allocated memory for the mp\_int structure, typically on the application stack. The
call to mp\_init() is used only to initialize the members of the structure to a known default state.
-Before any of the other members of the structure are initialized memory from the application heap is allocated with
-the calloc() function (line @22,calloc@). The size of the allocated memory is large enough to hold \textbf{MP\_PREC}
-mp\_digit variables. The calloc() function is used instead\footnote{calloc() will allocate memory in the same
-manner as malloc() except that it also sets the contents to zero upon successfully allocating the memory.} of malloc()
-since digits have to be set to zero for the function to finish correctly. The \textbf{OPT\_CAST} token is a macro
-definition which will turn into a cast from void * to mp\_digit * for C++ compilers. It is not required for C compilers.
+Here we see (line @23,XMALLOC@) the memory allocation is performed first. This allows us to exit cleanly and quickly
+if there is an error. If the allocation fails the routine will return \textbf{MP\_MEM} to the caller to indicate there
+was a memory error. The function XMALLOC is what actually allocates the memory. Technically XMALLOC is not a function
+but a macro defined in ``tommath.h``. By default, XMALLOC will evaluate to malloc() which is the C library's built--in
+memory allocation routine.
-After the memory has been successfully allocated the remainder of the members are initialized
-(lines @29,used@ through @31,sign@) to their respective default states. At this point the algorithm has succeeded and
-a success code is returned to the calling function.
+In order to assure the mp\_int is in a known state the digits must be set to zero. On most platforms this could have been
+accomplished by using calloc() instead of malloc(). However, to correctly initialize a integer type to a given value in a
+portable fashion you have to actually assign the value. The for loop (line @28,for@) performs this required
+operation.
-If this function returns \textbf{MP\_OKAY} it is safe to assume the mp\_int structure has been properly initialized and
-is safe to use with other functions within the library.
+After the memory has been successfully initialized the remainder of the members are initialized
+(lines @29,used@ through @31,sign@) to their respective default states. At this point the algorithm has succeeded and
+a success code is returned to the calling function. If this function returns \textbf{MP\_OKAY} it is safe to assume the
+mp\_int structure has been properly initialized and is safe to use with other functions within the library.
\subsection{Clearing an mp\_int}
When an mp\_int is no longer required by the application, the memory that has been allocated for its digits must be
@@ -819,7 +843,7 @@ returned to the application's memory pool with the mp\_clear algorithm.
\begin{tabular}{l}
\hline Algorithm \textbf{mp\_clear}. \\
\textbf{Input}. An mp\_int $a$ \\
-\textbf{Output}. The memory for $a$ is freed for reuse. \\
+\textbf{Output}. The memory for $a$ shall be deallocated. \\
\hline \\
1. If $a$ has been previously freed then return(\textit{MP\_OKAY}). \\
2. for $n$ from 0 to $a.used - 1$ do \\
@@ -836,32 +860,31 @@ returned to the application's memory pool with the mp\_clear algorithm.
\end{figure}
\textbf{Algorithm mp\_clear.}
-This algorithm releases the memory allocated for an mp\_int back into the memory pool for reuse. It is designed
-such that a given mp\_int structure can be cleared multiple times between initializations without attempting to
-free the memory twice\footnote{In ISO C for example, calling free() twice on the same memory block causes undefinied
-behaviour.}.
-
-The first step determines if the mp\_int structure has been marked as free already. If it has, the algorithm returns
-success immediately as no further actions are required. Otherwise, the algorithm will proceed to put the structure
-in a known empty and otherwise invalid state. First the digits of the mp\_int are set to zero. The memory that has been allocated for the
-digits is then freed. The \textbf{used} and \textbf{alloc} counts are both set to zero and the \textbf{sign} set to
-\textbf{MP\_ZPOS}. This known fixed state for cleared mp\_int structures will make debuging easier for the end
-developer. That is, if they spot (via their debugger) an mp\_int they are using that is in this state it will be
-obvious that they erroneously and prematurely cleared the mp\_int structure.
-
-Note that once an mp\_int has been cleared the mp\_int structure is no longer in a valid state for any other algorithm
+This algorithm accomplishes two goals. First, it clears the digits and the other mp\_int members. This ensures that
+if a developer accidentally re-uses a cleared structure it is less likely to cause problems. The second goal
+is to free the allocated memory.
+
+The logic behind the algorithm is extended by marking cleared mp\_int structures so that subsequent calls to this
+algorithm will not try to free the memory multiple times. Cleared mp\_ints are detectable by having a pre-defined invalid
+digit pointer \textbf{dp} setting.
+
+Once an mp\_int has been cleared the mp\_int structure is no longer in a valid state for any other algorithm
with the exception of algorithms mp\_init, mp\_init\_copy, mp\_init\_size and mp\_clear.
EXAM,bn_mp_clear.c
-The ``if'' statement (line @21,a->dp != NULL@) prevents the heap from being corrupted if a user double-frees an
-mp\_int. This is because once the memory is freed the pointer is set to \textbf{NULL} (line @30,NULL@).
+The algorithm only operates on the mp\_int if it hasn't been previously cleared. The if statement (line @23,a->dp != NULL@)
+checks to see if the \textbf{dp} member is not \textbf{NULL}. If the mp\_int is a valid mp\_int then \textbf{dp} cannot be
+\textbf{NULL} in which case the if statement will evaluate to true.
+
+The digits of the mp\_int are cleared by the for loop (line @25,for@) which assigns a zero to every digit. Similar to mp\_init()
+the digits are assigned zero instead of using block memory operations (such as memset()) since this is more portable.
-Without the check, code that accidentally calls mp\_clear twice for a given mp\_int structure would try to free the memory
-allocated for the digits twice. This may cause some C libraries to signal a fault. By setting the pointer to
-\textbf{NULL} it helps debug code that may inadvertently free the mp\_int before it is truly not needed, because attempts
-to reference digits should fail immediately. The allocated digits are set to zero before being freed (line @24,memset@).
-This is ideal for cryptographic situations where the integer that the mp\_int represents might need to be kept a secret.
+The digits are deallocated off the heap via the XFREE macro. Similar to XMALLOC the XFREE macro actually evaluates to
+a standard C library function. In this case the free() function. Since free() only deallocates the memory the pointer
+still has to be reset to \textbf{NULL} manually (line @33,NULL@).
+
+Now that the digits have been cleared and deallocated the other members are set to their final values (lines @34,= 0@ and @35,ZPOS@).
\section{Maintenance Algorithms}
@@ -889,7 +912,7 @@ must be re-sized appropriately to accomodate the result. The mp\_grow algorithm
1. if $a.alloc \ge b$ then return(\textit{MP\_OKAY}) \\
2. $u \leftarrow b\mbox{ (mod }MP\_PREC\mbox{)}$ \\
3. $v \leftarrow b + 2 \cdot MP\_PREC - u$ \\
-4. Re-Allocate the array of digits $a$ to size $v$ \\
+4. Re-allocate the array of digits $a$ to size $v$ \\
5. If the allocation failed then return(\textit{MP\_MEM}). \\
6. for n from a.alloc to $v - 1$ do \\
\hspace{+3mm}6.1 $a_n \leftarrow 0$ \\
@@ -914,15 +937,19 @@ assumed to contain undefined values they are initially set to zero.
EXAM,bn_mp_grow.c
-The first step is to see if we actually need to perform a re-allocation at all (line @24,a->alloc < size@). If a reallocation
-must occur the digit count is padded upwards to help prevent many trivial reallocations (line @28,size@). Next the reallocation is performed
-and the return of realloc() is stored in a temporary pointer named $tmp$ (line @36,realloc@). The return is stored in a temporary
-instead of $a.dp$ to prevent the code from losing the original pointer in case the reallocation fails. Had the return been stored
-in $a.dp$ instead there would be no way to reclaim the heap originally used.
+A quick optimization is to first determine if a memory re-allocation is required at all. The if statement (line @23,if@) checks
+if the \textbf{alloc} member of the mp\_int is smaller than the requested digit count. If the count is not larger than \textbf{alloc}
+the function skips the re-allocation part thus saving time.
+
+When a re-allocation is performed it is turned into an optimal request to save time in the future. The requested digit count is
+padded upwards to 2nd multiple of \textbf{MP\_PREC} larger than \textbf{alloc} (line @25, size@). The XREALLOC function is used
+to re-allocate the memory. As per the other functions XREALLOC is actually a macro which evaluates to realloc by default. The realloc
+function leaves the base of the allocation intact which means the first \textbf{alloc} digits of the mp\_int are the same as before
+the re-allocation. All that is left is to clear the newly allocated digits and return.
-If the reallocation fails the function will return \textbf{MP\_MEM} (line @39,return@), otherwise, the value of $tmp$ is assigned
-to the pointer $a.dp$ and the function continues. A simple for loop from line @48,a->alloc@ to line @50,}@ will zero all digits
-that were above the old \textbf{alloc} limit to make sure the integer is in a known state.
+Note that the re-allocation result is actually stored in a temporary pointer $tmp$. This is to allow this function to return
+an error with a valid pointer. Earlier releases of the library stored the result of XREALLOC into the mp\_int $a$. That would
+result in a memory leak if XREALLOC ever failed.
\subsection{Initializing Variable Precision mp\_ints}
Occasionally the number of digits required will be known in advance of an initialization, based on, for example, the size
@@ -970,7 +997,7 @@ The number of digits $b$ requested is padded (line @22,MP_PREC@) by first augmen
mp\_int is placed in a default state representing the integer zero. Otherwise, the error code \textbf{MP\_MEM} will be
returned (line @27,return@).
-The digits are allocated and set to zero at the same time with the calloc() function (line @25,calloc@). The
+The digits are allocated and set to zero at the same time with the calloc() function (line @25,XCALLOC@). The
\textbf{used} count is set to zero, the \textbf{alloc} count set to the padded digit count and the \textbf{sign} flag set
to \textbf{MP\_ZPOS} to achieve a default valid mp\_int state (lines @29,used@, @30,alloc@ and @31,sign@). If the function
returns succesfully then it is correct to assume that the mp\_int structure is in a valid state for the remainder of the
diff --git a/tommath.tex b/tommath.tex
index 629edba..3fbe907 100644
--- a/tommath.tex
+++ b/tommath.tex
@@ -258,7 +258,7 @@ floating point is meant to be implemented in hardware the precision of the manti
a mantissa of much larger precision than hardware alone can efficiently support. This approach could be useful where
scientific applications must minimize the total output error over long calculations.
-Another use for large integers is within arithmetic on polynomials of large characteristic (i.e. $GF(p)[x]$ for large $p$).
+Yet another use for large integers is within arithmetic on polynomials of large characteristic (i.e. $GF(p)[x]$ for large $p$).
In fact the library discussed within this text has already been used to form a polynomial basis library\footnote{See \url{http://poly.libtomcrypt.org} for more details.}.
\subsection{Benefits of Multiple Precision Arithmetic}
@@ -316,7 +316,7 @@ the reader how the algorithms fit together as well as where to start on various
\section{Discussion and Notation}
\subsection{Notation}
-A multiple precision integer of $n$-digits shall be denoted as $x = (x_{n-1} ... x_1 x_0)_{ \beta }$ and represent
+A multiple precision integer of $n$-digits shall be denoted as $x = (x_{n-1}, \ldots, x_1, x_0)_{ \beta }$ and represent
the integer $x \equiv \sum_{i=0}^{n-1} x_i\beta^i$. The elements of the array $x$ are said to be the radix $\beta$ digits
of the integer. For example, $x = (1,2,3)_{10}$ would represent the integer
$1\cdot 10^2 + 2\cdot10^1 + 3\cdot10^0 = 123$.
@@ -339,12 +339,11 @@ algorithms will be used to establish the relevant theory which will subsequently
precision algorithm to solve the same problem.
\subsection{Precision Notation}
-For the purposes of this text a single precision variable must be able to represent integers in the range
-$0 \le x < q \beta$ while a double precision variable must be able to represent integers in the range
-$0 \le x < q \beta^2$. The variable $\beta$ represents the radix of a single digit of a multiple precision integer and
-must be of the form $q^p$ for $q, p \in \Z^+$. The extra radix-$q$ factor allows additions and subtractions to proceed
-without truncation of the carry. Since all modern computers are binary, it is assumed that $q$ is two, for all intents
-and purposes.
+The variable $\beta$ represents the radix of a single digit of a multiple precision integer and
+must be of the form $q^p$ for $q, p \in \Z^+$. A single precision variable must be able to represent integers in
+the range $0 \le x < q \beta$ while a double precision variable must be able to represent integers in the range
+$0 \le x < q \beta^2$. The extra radix-$q$ factor allows additions and subtractions to proceed without truncation of the
+carry. Since all modern computers are binary, it is assumed that $q$ is two.
\index{mp\_digit} \index{mp\_word}
Within the source code that will be presented for each algorithm, the data type \textbf{mp\_digit} will represent
@@ -376,7 +375,7 @@ the $/$ division symbol is used the intention is to perform an integer division
$5/2 = 2$ which will often be written as $\lfloor 5/2 \rfloor = 2$ for clarity. When an expression is written as a
fraction a real value division is implied, for example ${5 \over 2} = 2.5$.
-The norm of a multiple precision integer, for example, $\vert \vert x \vert \vert$ will be used to represent the number of digits in the representation
+The norm of a multiple precision integer, for example $\vert \vert x \vert \vert$, will be used to represent the number of digits in the representation
of the integer. For example, $\vert \vert 123 \vert \vert = 3$ and $\vert \vert 79452 \vert \vert = 5$.
\subsection{Work Effort}
@@ -569,7 +568,7 @@ By building outwards from a base foundation instead of using a parallel design m
highly modular. Being highly modular is a desirable property of any project as it often means the resulting product
has a small footprint and updates are easy to perform.
-Usually when I start a project I will begin with the header file. I define the data types I think I will need and
+Usually when I start a project I will begin with the header files. I define the data types I think I will need and
prototype the initial functions that are not dependent on other functions (within the library). After I
implement these base functions I prototype more dependent functions and implement them. The process repeats until
I implement all of the functions I require. For example, in the case of LibTomMath I implemented functions such as
@@ -625,14 +624,26 @@ any such data type but it does provide for making composite data types known as
used within LibTomMath.
\index{mp\_int}
-\begin{verbatim}
-typedef struct {
- int used, alloc, sign;
- mp_digit *dp;
-} mp_int;
-\end{verbatim}
+\begin{figure}[here]
+\begin{center}
+\begin{small}
+%\begin{verbatim}
+\begin{tabular}{|l|}
+\hline
+typedef struct \{ \\
+\hspace{3mm}int used, alloc, sign;\\
+\hspace{3mm}mp\_digit *dp;\\
+\} \textbf{mp\_int}; \\
+\hline
+\end{tabular}
+%\end{verbatim}
+\end{small}
+\caption{The mp\_int Structure}
+\label{fig:mpint}
+\end{center}
+\end{figure}
-The mp\_int structure can be broken down as follows.
+The mp\_int structure (fig. \ref{fig:mpint}) can be broken down as follows.
\begin{enumerate}
\item The \textbf{used} parameter denotes how many digits of the array \textbf{dp} contain the digits used to represent
@@ -707,9 +718,10 @@ fault by dereferencing memory not owned by the application.
In the case of LibTomMath the only errors that are checked for are related to inappropriate inputs (division by zero for
instance) and memory allocation errors. It will not check that the mp\_int passed to any function is valid nor
will it check pointers for validity. Any function that can cause a runtime error will return an error code as an
-\textbf{int} data type with one of the following values.
+\textbf{int} data type with one of the following values (fig \ref{fig:errcodes}).
\index{MP\_OKAY} \index{MP\_VAL} \index{MP\_MEM}
+\begin{figure}[here]
\begin{center}
\begin{tabular}{|l|l|}
\hline \textbf{Value} & \textbf{Meaning} \\
@@ -719,6 +731,9 @@ will it check pointers for validity. Any function that can cause a runtime erro
\hline
\end{tabular}
\end{center}
+\caption{LibTomMath Error Codes}
+\label{fig:errcodes}
+\end{figure}
When an error is detected within a function it should free any memory it allocated, often during the initialization of
temporary mp\_ints, and return as soon as possible. The goal is to leave the system in the same state it was when the
@@ -754,6 +769,7 @@ to zero. The \textbf{used} count set to zero and \textbf{sign} set to \textbf{M
An mp\_int is said to be initialized if it is set to a valid, preferably default, state such that all of the members of the
structure are set to valid values. The mp\_init algorithm will perform such an action.
+\index{mp\_init}
\begin{figure}[here]
\begin{center}
\begin{tabular}{l}
@@ -776,17 +792,23 @@ structure are set to valid values. The mp\_init algorithm will perform such an
\end{figure}
\textbf{Algorithm mp\_init.}
-The \textbf{MP\_PREC} name represents a constant\footnote{Defined in the ``tommath.h'' header file within LibTomMath.}
-used to dictate the minimum precision of allocated mp\_int integers. Ideally, it is at least equal to $32$ since for most
-purposes that will be more than enough.
+The purpose of this function is to initialize an mp\_int structure so that the rest of the library can properly
+manipulte it. It is assumed that the input may not have had any of its members previously initialized which is certainly
+a valid assumption if the input resides on the stack.
-Memory for the default number of digits is allocated first. If the allocation fails the algorithm returns immediately
-with the \textbf{MP\_MEM} error code. If the allocation succeeds the remaining members of the mp\_int structure
-must be initialized to reflect the default initial state.
+Before any of the members such as \textbf{sign}, \textbf{used} or \textbf{alloc} are initialized the memory for
+the digits is allocated. If this fails the function returns before setting any of the other members. The \textbf{MP\_PREC}
+name represents a constant\footnote{Defined in the ``tommath.h'' header file within LibTomMath.}
+used to dictate the minimum precision of newly initialized mp\_int integers. Ideally, it is at least equal to the smallest
+precision number you'll be working with.
-The allocated digits are all set to zero (step three) to ensure they are in a known state. The \textbf{sign}, \textbf{used}
-and \textbf{alloc} are subsequently initialized to represent the zero integer. By step seven the algorithm returns a success
-code and the mp\_int $a$ has been successfully initialized to a valid state representing the integer zero.
+Allocating a block of digits at first instead of a single digit has the benefit of lowering the number of usually slow
+heap operations later functions will have to perform in the future. If \textbf{MP\_PREC} is set correctly the slack
+memory and the number of heap operations will be trivial.
+
+Once the allocation has been made the digits have to be set to zero as well as the \textbf{used}, \textbf{sign} and
+\textbf{alloc} members initialized. This ensures that the mp\_int will always represent the default state of zero regardless
+of the original condition of the input.
\textbf{Remark.}
This function introduces the idiosyncrasy that all iterative loops, commonly initiated with the ``for'' keyword, iterate incrementally
@@ -800,24 +822,30 @@ decrementally.
\hspace{-5.1mm}{\bf File}: bn\_mp\_init.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* init a new bigint */
-018 int mp_init (mp_int * a)
-019 \{
-020 /* allocate memory required and clear it */
-021 a->dp = OPT_CAST(mp_digit) XCALLOC (sizeof (mp_digit), MP_PREC);
-022 if (a->dp == NULL) \{
-023 return MP_MEM;
-024 \}
-025
-026 /* set the used to zero, allocated digits to the default precision
-027 * and sign to positive */
-028 a->used = 0;
-029 a->alloc = MP_PREC;
-030 a->sign = MP_ZPOS;
+016 /* init a new mp_int */
+017 int mp_init (mp_int * a)
+018 \{
+019 int i;
+020
+021 /* allocate memory required and clear it */
+022 a->dp = OPT_CAST(mp_digit) XMALLOC (sizeof (mp_digit) * MP_PREC);
+023 if (a->dp == NULL) \{
+024 return MP_MEM;
+025 \}
+026
+027 /* set the digits to zero */
+028 for (i = 0; i < MP_PREC; i++) \{
+029 a->dp[i] = 0;
+030 \}
031
-032 return MP_OKAY;
-033 \}
+032 /* set the used to zero, allocated digits to the default precision
+033 * and sign to positive */
+034 a->used = 0;
+035 a->alloc = MP_PREC;
+036 a->sign = MP_ZPOS;
+037
+038 return MP_OKAY;
+039 \}
\end{alltt}
\end{small}
@@ -825,19 +853,21 @@ One immediate observation of this initializtion function is that it does not ret
is assumed that the caller has already allocated memory for the mp\_int structure, typically on the application stack. The
call to mp\_init() is used only to initialize the members of the structure to a known default state.
-Before any of the other members of the structure are initialized memory from the application heap is allocated with
-the calloc() function (line @22,calloc@). The size of the allocated memory is large enough to hold \textbf{MP\_PREC}
-mp\_digit variables. The calloc() function is used instead\footnote{calloc() will allocate memory in the same
-manner as malloc() except that it also sets the contents to zero upon successfully allocating the memory.} of malloc()
-since digits have to be set to zero for the function to finish correctly. The \textbf{OPT\_CAST} token is a macro
-definition which will turn into a cast from void * to mp\_digit * for C++ compilers. It is not required for C compilers.
+Here we see (line 22) the memory allocation is performed first. This allows us to exit cleanly and quickly
+if there is an error. If the allocation fails the routine will return \textbf{MP\_MEM} to the caller to indicate there
+was a memory error. The function XMALLOC is what actually allocates the memory. Technically XMALLOC is not a function
+but a macro defined in ``tommath.h``. By default, XMALLOC will evaluate to malloc() which is the C library's built--in
+memory allocation routine.
-After the memory has been successfully allocated the remainder of the members are initialized
-(lines 28 through 30) to their respective default states. At this point the algorithm has succeeded and
-a success code is returned to the calling function.
+In order to assure the mp\_int is in a known state the digits must be set to zero. On most platforms this could have been
+accomplished by using calloc() instead of malloc(). However, to correctly initialize a integer type to a given value in a
+portable fashion you have to actually assign the value. The for loop (line 28) performs this required
+operation.
-If this function returns \textbf{MP\_OKAY} it is safe to assume the mp\_int structure has been properly initialized and
-is safe to use with other functions within the library.
+After the memory has been successfully initialized the remainder of the members are initialized
+(lines 32 through 33) to their respective default states. At this point the algorithm has succeeded and
+a success code is returned to the calling function. If this function returns \textbf{MP\_OKAY} it is safe to assume the
+mp\_int structure has been properly initialized and is safe to use with other functions within the library.
\subsection{Clearing an mp\_int}
When an mp\_int is no longer required by the application, the memory that has been allocated for its digits must be
@@ -848,7 +878,7 @@ returned to the application's memory pool with the mp\_clear algorithm.
\begin{tabular}{l}
\hline Algorithm \textbf{mp\_clear}. \\
\textbf{Input}. An mp\_int $a$ \\
-\textbf{Output}. The memory for $a$ is freed for reuse. \\
+\textbf{Output}. The memory for $a$ shall be deallocated. \\
\hline \\
1. If $a$ has been previously freed then return(\textit{MP\_OKAY}). \\
2. for $n$ from 0 to $a.used - 1$ do \\
@@ -865,56 +895,58 @@ returned to the application's memory pool with the mp\_clear algorithm.
\end{figure}
\textbf{Algorithm mp\_clear.}
-This algorithm releases the memory allocated for an mp\_int back into the memory pool for reuse. It is designed
-such that a given mp\_int structure can be cleared multiple times between initializations without attempting to
-free the memory twice\footnote{In ISO C for example, calling free() twice on the same memory block causes undefinied
-behaviour.}.
-
-The first step determines if the mp\_int structure has been marked as free already. If it has, the algorithm returns
-success immediately as no further actions are required. Otherwise, the algorithm will proceed to put the structure
-in a known empty and otherwise invalid state. First the digits of the mp\_int are set to zero. The memory that has been allocated for the
-digits is then freed. The \textbf{used} and \textbf{alloc} counts are both set to zero and the \textbf{sign} set to
-\textbf{MP\_ZPOS}. This known fixed state for cleared mp\_int structures will make debuging easier for the end
-developer. That is, if they spot (via their debugger) an mp\_int they are using that is in this state it will be
-obvious that they erroneously and prematurely cleared the mp\_int structure.
-
-Note that once an mp\_int has been cleared the mp\_int structure is no longer in a valid state for any other algorithm
+This algorithm accomplishes two goals. First, it clears the digits and the other mp\_int members. This ensures that
+if a developer accidentally re-uses a cleared structure it is less likely to cause problems. The second goal
+is to free the allocated memory.
+
+The logic behind the algorithm is extended by marking cleared mp\_int structures so that subsequent calls to this
+algorithm will not try to free the memory multiple times. Cleared mp\_ints are detectable by having a pre-defined invalid
+digit pointer \textbf{dp} setting.
+
+Once an mp\_int has been cleared the mp\_int structure is no longer in a valid state for any other algorithm
with the exception of algorithms mp\_init, mp\_init\_copy, mp\_init\_size and mp\_clear.
\vspace{+3mm}\begin{small}
\hspace{-5.1mm}{\bf File}: bn\_mp\_clear.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* clear one (frees) */
-018 void
-019 mp_clear (mp_int * a)
-020 \{
-021 /* only do anything if a hasn't been freed previously */
-022 if (a->dp != NULL) \{
-023 /* first zero the digits */
-024 memset (a->dp, 0, sizeof (mp_digit) * a->used);
-025
-026 /* free ram */
-027 XFREE(a->dp);
+016 /* clear one (frees) */
+017 void
+018 mp_clear (mp_int * a)
+019 \{
+020 int i;
+021
+022 /* only do anything if a hasn't been freed previously */
+023 if (a->dp != NULL) \{
+024 /* first zero the digits */
+025 for (i = 0; i < a->used; i++) \{
+026 a->dp[i] = 0;
+027 \}
028
-029 /* reset members to make debugging easier */
-030 a->dp = NULL;
-031 a->alloc = a->used = 0;
-032 a->sign = MP_ZPOS;
-033 \}
-034 \}
+029 /* free ram */
+030 XFREE(a->dp);
+031
+032 /* reset members to make debugging easier */
+033 a->dp = NULL;
+034 a->alloc = a->used = 0;
+035 a->sign = MP_ZPOS;
+036 \}
+037 \}
\end{alltt}
\end{small}
-The ``if'' statement (line 22) prevents the heap from being corrupted if a user double-frees an
-mp\_int. This is because once the memory is freed the pointer is set to \textbf{NULL} (line 30).
+The algorithm only operates on the mp\_int if it hasn't been previously cleared. The if statement (line 23)
+checks to see if the \textbf{dp} member is not \textbf{NULL}. If the mp\_int is a valid mp\_int then \textbf{dp} cannot be
+\textbf{NULL} in which case the if statement will evaluate to true.
-Without the check, code that accidentally calls mp\_clear twice for a given mp\_int structure would try to free the memory
-allocated for the digits twice. This may cause some C libraries to signal a fault. By setting the pointer to
-\textbf{NULL} it helps debug code that may inadvertently free the mp\_int before it is truly not needed, because attempts
-to reference digits should fail immediately. The allocated digits are set to zero before being freed (line 24).
-This is ideal for cryptographic situations where the integer that the mp\_int represents might need to be kept a secret.
+The digits of the mp\_int are cleared by the for loop (line 25) which assigns a zero to every digit. Similar to mp\_init()
+the digits are assigned zero instead of using block memory operations (such as memset()) since this is more portable.
+
+The digits are deallocated off the heap via the XFREE macro. Similar to XMALLOC the XFREE macro actually evaluates to
+a standard C library function. In this case the free() function. Since free() only deallocates the memory the pointer
+still has to be reset to \textbf{NULL} manually (line 33).
+
+Now that the digits have been cleared and deallocated the other members are set to their final values (lines 34 and 35).
\section{Maintenance Algorithms}
@@ -942,7 +974,7 @@ must be re-sized appropriately to accomodate the result. The mp\_grow algorithm
1. if $a.alloc \ge b$ then return(\textit{MP\_OKAY}) \\
2. $u \leftarrow b\mbox{ (mod }MP\_PREC\mbox{)}$ \\
3. $v \leftarrow b + 2 \cdot MP\_PREC - u$ \\
-4. Re-Allocate the array of digits $a$ to size $v$ \\
+4. Re-allocate the array of digits $a$ to size $v$ \\
5. If the allocation failed then return(\textit{MP\_MEM}). \\
6. for n from a.alloc to $v - 1$ do \\
\hspace{+3mm}6.1 $a_n \leftarrow 0$ \\
@@ -969,54 +1001,57 @@ assumed to contain undefined values they are initially set to zero.
\hspace{-5.1mm}{\bf File}: bn\_mp\_grow.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* grow as required */
-018 int mp_grow (mp_int * a, int size)
-019 \{
-020 int i;
-021 mp_digit *tmp;
-022
-023 /* if the alloc size is smaller alloc more ram */
-024 if (a->alloc < size) \{
-025 /* ensure there are always at least MP_PREC digits extra on top */
-026 size += (MP_PREC * 2) - (size % MP_PREC);
-027
-028 /* reallocate the array a->dp
-029 *
-030 * We store the return in a temporary variable
-031 * in case the operation failed we don't want
-032 * to overwrite the dp member of a.
-033 */
-034 tmp = OPT_CAST(mp_digit) XREALLOC (a->dp, sizeof (mp_digit) * size);
-035 if (tmp == NULL) \{
-036 /* reallocation failed but "a" is still valid [can be freed] */
-037 return MP_MEM;
-038 \}
-039
-040 /* reallocation succeeded so set a->dp */
-041 a->dp = tmp;
-042
-043 /* zero excess digits */
-044 i = a->alloc;
-045 a->alloc = size;
-046 for (; i < a->alloc; i++) \{
-047 a->dp[i] = 0;
-048 \}
-049 \}
-050 return MP_OKAY;
-051 \}
+016 /* grow as required */
+017 int mp_grow (mp_int * a, int size)
+018 \{
+019 int i;
+020 mp_digit *tmp;
+021
+022 /* if the alloc size is smaller alloc more ram */
+023 if (a->alloc < size) \{
+024 /* ensure there are always at least MP_PREC digits extra on top */
+025 size += (MP_PREC * 2) - (size % MP_PREC);
+026
+027 /* reallocate the array a->dp
+028 *
+029 * We store the return in a temporary variable
+030 * in case the operation failed we don't want
+031 * to overwrite the dp member of a.
+032 */
+033 tmp = OPT_CAST(mp_digit) XREALLOC (a->dp, sizeof (mp_digit) * size);
+034 if (tmp == NULL) \{
+035 /* reallocation failed but "a" is still valid [can be freed] */
+036 return MP_MEM;
+037 \}
+038
+039 /* reallocation succeeded so set a->dp */
+040 a->dp = tmp;
+041
+042 /* zero excess digits */
+043 i = a->alloc;
+044 a->alloc = size;
+045 for (; i < a->alloc; i++) \{
+046 a->dp[i] = 0;
+047 \}
+048 \}
+049 return MP_OKAY;
+050 \}
\end{alltt}
\end{small}
-The first step is to see if we actually need to perform a re-allocation at all (line 24). If a reallocation
-must occur the digit count is padded upwards to help prevent many trivial reallocations (line 26). Next the reallocation is performed
-and the return of realloc() is stored in a temporary pointer named $tmp$ (line 36). The return is stored in a temporary
-instead of $a.dp$ to prevent the code from losing the original pointer in case the reallocation fails. Had the return been stored
-in $a.dp$ instead there would be no way to reclaim the heap originally used.
+A quick optimization is to first determine if a memory re-allocation is required at all. The if statement (line 23) checks
+if the \textbf{alloc} member of the mp\_int is smaller than the requested digit count. If the count is not larger than \textbf{alloc}
+the function skips the re-allocation part thus saving time.
+
+When a re-allocation is performed it is turned into an optimal request to save time in the future. The requested digit count is
+padded upwards to 2nd multiple of \textbf{MP\_PREC} larger than \textbf{alloc} (line 25). The XREALLOC function is used
+to re-allocate the memory. As per the other functions XREALLOC is actually a macro which evaluates to realloc by default. The realloc
+function leaves the base of the allocation intact which means the first \textbf{alloc} digits of the mp\_int are the same as before
+the re-allocation. All that is left is to clear the newly allocated digits and return.
-If the reallocation fails the function will return \textbf{MP\_MEM} (line 37), otherwise, the value of $tmp$ is assigned
-to the pointer $a.dp$ and the function continues. A simple for loop from line 46 to line 51 will zero all digits
-that were above the old \textbf{alloc} limit to make sure the integer is in a known state.
+Note that the re-allocation result is actually stored in a temporary pointer $tmp$. This is to allow this function to return
+an error with a valid pointer. Earlier releases of the library stored the result of XREALLOC into the mp\_int $a$. That would
+result in a memory leak if XREALLOC ever failed.
\subsection{Initializing Variable Precision mp\_ints}
Occasionally the number of digits required will be known in advance of an initialization, based on, for example, the size
@@ -1061,35 +1096,34 @@ correct no further memory re-allocations are required to work with the mp\_int.
\hspace{-5.1mm}{\bf File}: bn\_mp\_init\_size.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* init an mp_init for a given size */
-018 int mp_init_size (mp_int * a, int size)
-019 \{
-020 /* pad size so there are always extra digits */
-021 size += (MP_PREC * 2) - (size % MP_PREC);
-022
-023 /* alloc mem */
-024 a->dp = OPT_CAST(mp_digit) XCALLOC (sizeof (mp_digit), size);
-025 if (a->dp == NULL) \{
-026 return MP_MEM;
-027 \}
-028 a->used = 0;
-029 a->alloc = size;
-030 a->sign = MP_ZPOS;
-031
-032 return MP_OKAY;
-033 \}
+016 /* init an mp_init for a given size */
+017 int mp_init_size (mp_int * a, int size)
+018 \{
+019 /* pad size so there are always extra digits */
+020 size += (MP_PREC * 2) - (size % MP_PREC);
+021
+022 /* alloc mem */
+023 a->dp = OPT_CAST(mp_digit) XCALLOC (sizeof (mp_digit), size);
+024 if (a->dp == NULL) \{
+025 return MP_MEM;
+026 \}
+027 a->used = 0;
+028 a->alloc = size;
+029 a->sign = MP_ZPOS;
+030
+031 return MP_OKAY;
+032 \}
\end{alltt}
\end{small}
-The number of digits $b$ requested is padded (line 21) by first augmenting it to the next multiple of
+The number of digits $b$ requested is padded (line 20) by first augmenting it to the next multiple of
\textbf{MP\_PREC} and then adding \textbf{MP\_PREC} to the result. If the memory can be successfully allocated the
mp\_int is placed in a default state representing the integer zero. Otherwise, the error code \textbf{MP\_MEM} will be
-returned (line 26).
+returned (line 25).
-The digits are allocated and set to zero at the same time with the calloc() function (line @25,calloc@). The
+The digits are allocated and set to zero at the same time with the calloc() function (line 23). The
\textbf{used} count is set to zero, the \textbf{alloc} count set to the padded digit count and the \textbf{sign} flag set
-to \textbf{MP\_ZPOS} to achieve a default valid mp\_int state (lines 28, 29 and 30). If the function
+to \textbf{MP\_ZPOS} to achieve a default valid mp\_int state (lines 27, 28 and 29). If the function
returns succesfully then it is correct to assume that the mp\_int structure is in a valid state for the remainder of the
functions to work with.
@@ -1127,44 +1161,43 @@ initialization which allows for quick recovery from runtime errors.
\hspace{-5.1mm}{\bf File}: bn\_mp\_init\_multi.c
\vspace{-3mm}
\begin{alltt}
-016 #include <stdarg.h>
-017
-018 int mp_init_multi(mp_int *mp, ...)
-019 \{
-020 mp_err res = MP_OKAY; /* Assume ok until proven otherwise */
-021 int n = 0; /* Number of ok inits */
-022 mp_int* cur_arg = mp;
-023 va_list args;
-024
-025 va_start(args, mp); /* init args to next argument from caller */
-026 while (cur_arg != NULL) \{
-027 if (mp_init(cur_arg) != MP_OKAY) \{
-028 /* Oops - error! Back-track and mp_clear what we already
-029 succeeded in init-ing, then return error.
-030 */
-031 va_list clean_args;
-032
-033 /* end the current list */
-034 va_end(args);
-035
-036 /* now start cleaning up */
-037 cur_arg = mp;
-038 va_start(clean_args, mp);
-039 while (n--) \{
-040 mp_clear(cur_arg);
-041 cur_arg = va_arg(clean_args, mp_int*);
-042 \}
-043 va_end(clean_args);
-044 res = MP_MEM;
-045 break;
-046 \}
-047 n++;
-048 cur_arg = va_arg(args, mp_int*);
-049 \}
-050 va_end(args);
-051 return res; /* Assumed ok, if error flagged above. */
-052 \}
-053
+016
+017 int mp_init_multi(mp_int *mp, ...)
+018 \{
+019 mp_err res = MP_OKAY; /* Assume ok until proven otherwise */
+020 int n = 0; /* Number of ok inits */
+021 mp_int* cur_arg = mp;
+022 va_list args;
+023
+024 va_start(args, mp); /* init args to next argument from caller */
+025 while (cur_arg != NULL) \{
+026 if (mp_init(cur_arg) != MP_OKAY) \{
+027 /* Oops - error! Back-track and mp_clear what we already
+028 succeeded in init-ing, then return error.
+029 */
+030 va_list clean_args;
+031
+032 /* end the current list */
+033 va_end(args);
+034
+035 /* now start cleaning up */
+036 cur_arg = mp;
+037 va_start(clean_args, mp);
+038 while (n--) \{
+039 mp_clear(cur_arg);
+040 cur_arg = va_arg(clean_args, mp_int*);
+041 \}
+042 va_end(clean_args);
+043 res = MP_MEM;
+044 break;
+045 \}
+046 n++;
+047 cur_arg = va_arg(args, mp_int*);
+048 \}
+049 va_end(args);
+050 return res; /* Assumed ok, if error flagged above. */
+051 \}
+052
\end{alltt}
\end{small}
@@ -1174,8 +1207,8 @@ structures in an actual C array they are simply passed as arguments to the funct
appended on the right.
The function uses the ``stdarg.h'' \textit{va} functions to step portably through the arguments to the function. A count
-$n$ of succesfully initialized mp\_int structures is maintained (line 47) such that if a failure does occur,
-the algorithm can backtrack and free the previously initialized structures (lines 27 to 46).
+$n$ of succesfully initialized mp\_int structures is maintained (line 46) such that if a failure does occur,
+the algorithm can backtrack and free the previously initialized structures (lines 26 to 45).
\subsection{Clamping Excess Digits}
@@ -1226,36 +1259,35 @@ when all of the digits are zero to ensure that the mp\_int is valid at all times
\hspace{-5.1mm}{\bf File}: bn\_mp\_clamp.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* trim unused digits
-018 *
-019 * This is used to ensure that leading zero digits are
-020 * trimed and the leading "used" digit will be non-zero
-021 * Typically very fast. Also fixes the sign if there
-022 * are no more leading digits
-023 */
-024 void
-025 mp_clamp (mp_int * a)
-026 \{
-027 /* decrease used while the most significant digit is
-028 * zero.
-029 */
-030 while (a->used > 0 && a->dp[a->used - 1] == 0) \{
-031 --(a->used);
-032 \}
-033
-034 /* reset the sign flag if used == 0 */
-035 if (a->used == 0) \{
-036 a->sign = MP_ZPOS;
-037 \}
-038 \}
+016 /* trim unused digits
+017 *
+018 * This is used to ensure that leading zero digits are
+019 * trimed and the leading "used" digit will be non-zero
+020 * Typically very fast. Also fixes the sign if there
+021 * are no more leading digits
+022 */
+023 void
+024 mp_clamp (mp_int * a)
+025 \{
+026 /* decrease used while the most significant digit is
+027 * zero.
+028 */
+029 while (a->used > 0 && a->dp[a->used - 1] == 0) \{
+030 --(a->used);
+031 \}
+032
+033 /* reset the sign flag if used == 0 */
+034 if (a->used == 0) \{
+035 a->sign = MP_ZPOS;
+036 \}
+037 \}
\end{alltt}
\end{small}
-Note on line 27 how to test for the \textbf{used} count is made on the left of the \&\& operator. In the C programming
+Note on line 26 how to test for the \textbf{used} count is made on the left of the \&\& operator. In the C programming
language the terms to \&\& are evaluated left to right with a boolean short-circuit if any condition fails. This is
important since if the \textbf{used} is zero the test on the right would fetch below the array. That is obviously
-undesirable. The parenthesis on line 30 is used to make sure the \textbf{used} count is decremented and not
+undesirable. The parenthesis on line 29 is used to make sure the \textbf{used} count is decremented and not
the pointer ``a''.
\section*{Exercises}
@@ -1338,68 +1370,67 @@ implement the pseudo-code.
\hspace{-5.1mm}{\bf File}: bn\_mp\_copy.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* copy, b = a */
-018 int
-019 mp_copy (mp_int * a, mp_int * b)
-020 \{
-021 int res, n;
-022
-023 /* if dst == src do nothing */
-024 if (a == b) \{
-025 return MP_OKAY;
-026 \}
-027
-028 /* grow dest */
-029 if (b->alloc < a->used) \{
-030 if ((res = mp_grow (b, a->used)) != MP_OKAY) \{
-031 return res;
-032 \}
-033 \}
-034
-035 /* zero b and copy the parameters over */
-036 \{
-037 register mp_digit *tmpa, *tmpb;
-038
-039 /* pointer aliases */
-040
-041 /* source */
-042 tmpa = a->dp;
-043
-044 /* destination */
-045 tmpb = b->dp;
-046
-047 /* copy all the digits */
-048 for (n = 0; n < a->used; n++) \{
-049 *tmpb++ = *tmpa++;
-050 \}
-051
-052 /* clear high digits */
-053 for (; n < b->used; n++) \{
-054 *tmpb++ = 0;
-055 \}
-056 \}
-057
-058 /* copy used count and sign */
-059 b->used = a->used;
-060 b->sign = a->sign;
-061 return MP_OKAY;
-062 \}
+016 /* copy, b = a */
+017 int
+018 mp_copy (mp_int * a, mp_int * b)
+019 \{
+020 int res, n;
+021
+022 /* if dst == src do nothing */
+023 if (a == b) \{
+024 return MP_OKAY;
+025 \}
+026
+027 /* grow dest */
+028 if (b->alloc < a->used) \{
+029 if ((res = mp_grow (b, a->used)) != MP_OKAY) \{
+030 return res;
+031 \}
+032 \}
+033
+034 /* zero b and copy the parameters over */
+035 \{
+036 register mp_digit *tmpa, *tmpb;
+037
+038 /* pointer aliases */
+039
+040 /* source */
+041 tmpa = a->dp;
+042
+043 /* destination */
+044 tmpb = b->dp;
+045
+046 /* copy all the digits */
+047 for (n = 0; n < a->used; n++) \{
+048 *tmpb++ = *tmpa++;
+049 \}
+050
+051 /* clear high digits */
+052 for (; n < b->used; n++) \{
+053 *tmpb++ = 0;
+054 \}
+055 \}
+056
+057 /* copy used count and sign */
+058 b->used = a->used;
+059 b->sign = a->sign;
+060 return MP_OKAY;
+061 \}
\end{alltt}
\end{small}
Occasionally a dependent algorithm may copy an mp\_int effectively into itself such as when the input and output
mp\_int structures passed to a function are one and the same. For this case it is optimal to return immediately without
-copying digits (line 24).
+copying digits (line 23).
The mp\_int $b$ must have enough digits to accomodate the used digits of the mp\_int $a$. If $b.alloc$ is less than
-$a.used$ the algorithm mp\_grow is used to augment the precision of $b$ (lines 29 to 33). In order to
+$a.used$ the algorithm mp\_grow is used to augment the precision of $b$ (lines 28 to 32). In order to
simplify the inner loop that copies the digits from $a$ to $b$, two aliases $tmpa$ and $tmpb$ point directly at the digits
-of the mp\_ints $a$ and $b$ respectively. These aliases (lines 42 and 45) allow the compiler to access the digits without first dereferencing the
+of the mp\_ints $a$ and $b$ respectively. These aliases (lines 41 and 44) allow the compiler to access the digits without first dereferencing the
mp\_int pointers and then subsequently the pointer to the digits.
-After the aliases are established the digits from $a$ are copied into $b$ (lines 48 to 50) and then the excess
-digits of $b$ are set to zero (lines 53 to 55). Both ``for'' loops make use of the pointer aliases and in
+After the aliases are established the digits from $a$ are copied into $b$ (lines 47 to 49) and then the excess
+digits of $b$ are set to zero (lines 52 to 55). Both ``for'' loops make use of the pointer aliases and in
fact the alias for $b$ is carried through into the second ``for'' loop to clear the excess digits. This optimization
allows the alias to stay in a machine register fairly easy between the two loops.
@@ -1487,17 +1518,16 @@ such this algorithm will perform two operations in one step.
\hspace{-5.1mm}{\bf File}: bn\_mp\_init\_copy.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* creates "a" then copies b into it */
-018 int mp_init_copy (mp_int * a, mp_int * b)
-019 \{
-020 int res;
-021
-022 if ((res = mp_init (a)) != MP_OKAY) \{
-023 return res;
-024 \}
-025 return mp_copy (b, a);
-026 \}
+016 /* creates "a" then copies b into it */
+017 int mp_init_copy (mp_int * a, mp_int * b)
+018 \{
+019 int res;
+020
+021 if ((res = mp_init (a)) != MP_OKAY) \{
+022 return res;
+023 \}
+024 return mp_copy (b, a);
+025 \}
\end{alltt}
\end{small}
@@ -1533,15 +1563,14 @@ This algorithm simply resets a mp\_int to the default state.
\hspace{-5.1mm}{\bf File}: bn\_mp\_zero.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* set to zero */
-018 void
-019 mp_zero (mp_int * a)
-020 \{
-021 a->sign = MP_ZPOS;
-022 a->used = 0;
-023 memset (a->dp, 0, sizeof (mp_digit) * a->alloc);
-024 \}
+016 /* set to zero */
+017 void
+018 mp_zero (mp_int * a)
+019 \{
+020 a->sign = MP_ZPOS;
+021 a->used = 0;
+022 memset (a->dp, 0, sizeof (mp_digit) * a->alloc);
+023 \}
\end{alltt}
\end{small}
@@ -1580,28 +1609,27 @@ logic to handle it.
\hspace{-5.1mm}{\bf File}: bn\_mp\_abs.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* b = |a|
-018 *
-019 * Simple function copies the input and fixes the sign to positive
-020 */
-021 int
-022 mp_abs (mp_int * a, mp_int * b)
-023 \{
-024 int res;
-025
-026 /* copy a to b */
-027 if (a != b) \{
-028 if ((res = mp_copy (a, b)) != MP_OKAY) \{
-029 return res;
-030 \}
-031 \}
-032
-033 /* force the sign of b to positive */
-034 b->sign = MP_ZPOS;
-035
-036 return MP_OKAY;
-037 \}
+016 /* b = |a|
+017 *
+018 * Simple function copies the input and fixes the sign to positive
+019 */
+020 int
+021 mp_abs (mp_int * a, mp_int * b)
+022 \{
+023 int res;
+024
+025 /* copy a to b */
+026 if (a != b) \{
+027 if ((res = mp_copy (a, b)) != MP_OKAY) \{
+028 return res;
+029 \}
+030 \}
+031
+032 /* force the sign of b to positive */
+033 b->sign = MP_ZPOS;
+034
+035 return MP_OKAY;
+036 \}
\end{alltt}
\end{small}
@@ -1640,19 +1668,18 @@ zero as negative.
\hspace{-5.1mm}{\bf File}: bn\_mp\_neg.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* b = -a */
-018 int mp_neg (mp_int * a, mp_int * b)
-019 \{
-020 int res;
-021 if ((res = mp_copy (a, b)) != MP_OKAY) \{
-022 return res;
-023 \}
-024 if (mp_iszero(b) != MP_YES) \{
-025 b->sign = (a->sign == MP_ZPOS) ? MP_NEG : MP_ZPOS;
-026 \}
-027 return MP_OKAY;
-028 \}
+016 /* b = -a */
+017 int mp_neg (mp_int * a, mp_int * b)
+018 \{
+019 int res;
+020 if ((res = mp_copy (a, b)) != MP_OKAY) \{
+021 return res;
+022 \}
+023 if (mp_iszero(b) != MP_YES) \{
+024 b->sign = (a->sign == MP_ZPOS) ? MP_NEG : MP_ZPOS;
+025 \}
+026 return MP_OKAY;
+027 \}
\end{alltt}
\end{small}
@@ -1687,21 +1714,20 @@ single digit is set (\textit{modulo $\beta$}) and the \textbf{used} count is adj
\hspace{-5.1mm}{\bf File}: bn\_mp\_set.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* set to a digit */
-018 void mp_set (mp_int * a, mp_digit b)
-019 \{
-020 mp_zero (a);
-021 a->dp[0] = b & MP_MASK;
-022 a->used = (a->dp[0] != 0) ? 1 : 0;
-023 \}
+016 /* set to a digit */
+017 void mp_set (mp_int * a, mp_digit b)
+018 \{
+019 mp_zero (a);
+020 a->dp[0] = b & MP_MASK;
+021 a->used = (a->dp[0] != 0) ? 1 : 0;
+022 \}
\end{alltt}
\end{small}
-Line 20 calls mp\_zero() to clear the mp\_int and reset the sign. Line 21 copies the digit
+Line 19 calls mp\_zero() to clear the mp\_int and reset the sign. Line 20 copies the digit
into the least significant location. Note the usage of a new constant \textbf{MP\_MASK}. This constant is used to quickly
reduce an integer modulo $\beta$. Since $\beta$ is of the form $2^k$ for any suitable $k$ it suffices to perform a binary AND with
-$MP\_MASK = 2^k - 1$ to perform the reduction. Finally line 22 will set the \textbf{used} member with respect to the
+$MP\_MASK = 2^k - 1$ to perform the reduction. Finally line 21 will set the \textbf{used} member with respect to the
digit actually set. This function will always make the integer positive.
One important limitation of this function is that it will only set one digit. The size of a digit is not fixed, meaning source that uses
@@ -1744,40 +1770,39 @@ Excess zero digits are trimmed in steps 2.1 and 3 by using higher level algorith
\hspace{-5.1mm}{\bf File}: bn\_mp\_set\_int.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* set a 32-bit const */
-018 int mp_set_int (mp_int * a, unsigned long b)
-019 \{
-020 int x, res;
-021
-022 mp_zero (a);
-023
-024 /* set four bits at a time */
-025 for (x = 0; x < 8; x++) \{
-026 /* shift the number up four bits */
-027 if ((res = mp_mul_2d (a, 4, a)) != MP_OKAY) \{
-028 return res;
-029 \}
-030
-031 /* OR in the top four bits of the source */
-032 a->dp[0] |= (b >> 28) & 15;
-033
-034 /* shift the source up to the next four bits */
-035 b <<= 4;
-036
-037 /* ensure that digits are not clamped off */
-038 a->used += 1;
-039 \}
-040 mp_clamp (a);
-041 return MP_OKAY;
-042 \}
+016 /* set a 32-bit const */
+017 int mp_set_int (mp_int * a, unsigned long b)
+018 \{
+019 int x, res;
+020
+021 mp_zero (a);
+022
+023 /* set four bits at a time */
+024 for (x = 0; x < 8; x++) \{
+025 /* shift the number up four bits */
+026 if ((res = mp_mul_2d (a, 4, a)) != MP_OKAY) \{
+027 return res;
+028 \}
+029
+030 /* OR in the top four bits of the source */
+031 a->dp[0] |= (b >> 28) & 15;
+032
+033 /* shift the source up to the next four bits */
+034 b <<= 4;
+035
+036 /* ensure that digits are not clamped off */
+037 a->used += 1;
+038 \}
+039 mp_clamp (a);
+040 return MP_OKAY;
+041 \}
\end{alltt}
\end{small}
This function sets four bits of the number at a time to handle all practical \textbf{DIGIT\_BIT} sizes. The weird
-addition on line 38 ensures that the newly added in bits are added to the number of digits. While it may not
-seem obvious as to why the digit counter does not grow exceedingly large it is because of the shift on line 27
-as well as the call to mp\_clamp() on line 40. Both functions will clamp excess leading digits which keeps
+addition on line 37 ensures that the newly added in bits are added to the number of digits. While it may not
+seem obvious as to why the digit counter does not grow exceedingly large it is because of the shift on line 26
+as well as the call to mp\_clamp() on line 39. Both functions will clamp excess leading digits which keeps
the number of used digits low.
\section{Comparisons}
@@ -1838,44 +1863,43 @@ the zero'th digit. If after all of the digits have been compared, no difference
\hspace{-5.1mm}{\bf File}: bn\_mp\_cmp\_mag.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* compare maginitude of two ints (unsigned) */
-018 int mp_cmp_mag (mp_int * a, mp_int * b)
-019 \{
-020 int n;
-021 mp_digit *tmpa, *tmpb;
-022
-023 /* compare based on # of non-zero digits */
-024 if (a->used > b->used) \{
-025 return MP_GT;
-026 \}
-027
-028 if (a->used < b->used) \{
-029 return MP_LT;
-030 \}
-031
-032 /* alias for a */
-033 tmpa = a->dp + (a->used - 1);
-034
-035 /* alias for b */
-036 tmpb = b->dp + (a->used - 1);
-037
-038 /* compare based on digits */
-039 for (n = 0; n < a->used; ++n, --tmpa, --tmpb) \{
-040 if (*tmpa > *tmpb) \{
-041 return MP_GT;
-042 \}
-043
-044 if (*tmpa < *tmpb) \{
-045 return MP_LT;
-046 \}
-047 \}
-048 return MP_EQ;
-049 \}
+016 /* compare maginitude of two ints (unsigned) */
+017 int mp_cmp_mag (mp_int * a, mp_int * b)
+018 \{
+019 int n;
+020 mp_digit *tmpa, *tmpb;
+021
+022 /* compare based on # of non-zero digits */
+023 if (a->used > b->used) \{
+024 return MP_GT;
+025 \}
+026
+027 if (a->used < b->used) \{
+028 return MP_LT;
+029 \}
+030
+031 /* alias for a */
+032 tmpa = a->dp + (a->used - 1);
+033
+034 /* alias for b */
+035 tmpb = b->dp + (a->used - 1);
+036
+037 /* compare based on digits */
+038 for (n = 0; n < a->used; ++n, --tmpa, --tmpb) \{
+039 if (*tmpa > *tmpb) \{
+040 return MP_GT;
+041 \}
+042
+043 if (*tmpa < *tmpb) \{
+044 return MP_LT;
+045 \}
+046 \}
+047 return MP_EQ;
+048 \}
\end{alltt}
\end{small}
-The two if statements on lines 24 and 28 compare the number of digits in the two inputs. These two are performed before all of the digits
+The two if statements on lines 23 and 27 compare the number of digits in the two inputs. These two are performed before all of the digits
are compared since it is a very cheap test to perform and can potentially save considerable time. The implementation given is also not valid
without those two statements. $b.alloc$ may be smaller than $a.used$, meaning that undefined values will be read from $b$ past the end of the
array of digits.
@@ -1913,34 +1937,33 @@ $\vert a \vert < \vert b \vert$. Step number four will compare the two when the
\hspace{-5.1mm}{\bf File}: bn\_mp\_cmp.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* compare two ints (signed)*/
-018 int
-019 mp_cmp (mp_int * a, mp_int * b)
-020 \{
-021 /* compare based on sign */
-022 if (a->sign != b->sign) \{
-023 if (a->sign == MP_NEG) \{
-024 return MP_LT;
-025 \} else \{
-026 return MP_GT;
-027 \}
-028 \}
-029
-030 /* compare digits */
-031 if (a->sign == MP_NEG) \{
-032 /* if negative compare opposite direction */
-033 return mp_cmp_mag(b, a);
-034 \} else \{
-035 return mp_cmp_mag(a, b);
-036 \}
-037 \}
+016 /* compare two ints (signed)*/
+017 int
+018 mp_cmp (mp_int * a, mp_int * b)
+019 \{
+020 /* compare based on sign */
+021 if (a->sign != b->sign) \{
+022 if (a->sign == MP_NEG) \{
+023 return MP_LT;
+024 \} else \{
+025 return MP_GT;
+026 \}
+027 \}
+028
+029 /* compare digits */
+030 if (a->sign == MP_NEG) \{
+031 /* if negative compare opposite direction */
+032 return mp_cmp_mag(b, a);
+033 \} else \{
+034 return mp_cmp_mag(a, b);
+035 \}
+036 \}
\end{alltt}
\end{small}
-The two if statements on lines 22 and 23 perform the initial sign comparison. If the signs are not the equal then which ever
-has the positive sign is larger. At line 31, the inputs are compared based on magnitudes. If the signs were both negative then
-the unsigned comparison is performed in the opposite direction (\textit{line 33}). Otherwise, the signs are assumed to
+The two if statements on lines 22 and 30 perform the initial sign comparison. If the signs are not the equal then which ever
+has the positive sign is larger. At line 30, the inputs are compared based on magnitudes. If the signs were both negative then
+the unsigned comparison is performed in the opposite direction (\textit{line 32}). Otherwise, the signs are assumed to
be both positive and a forward direction unsigned comparison is performed.
\section*{Exercises}
@@ -2064,110 +2087,109 @@ The final carry is stored in $c_{max}$ and digits above $max$ upto $oldused$ are
\hspace{-5.1mm}{\bf File}: bn\_s\_mp\_add.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* low level addition, based on HAC pp.594, Algorithm 14.7 */
-018 int
-019 s_mp_add (mp_int * a, mp_int * b, mp_int * c)
-020 \{
-021 mp_int *x;
-022 int olduse, res, min, max;
-023
-024 /* find sizes, we let |a| <= |b| which means we have to sort
-025 * them. "x" will point to the input with the most digits
-026 */
-027 if (a->used > b->used) \{
-028 min = b->used;
-029 max = a->used;
-030 x = a;
-031 \} else \{
-032 min = a->used;
-033 max = b->used;
-034 x = b;
-035 \}
-036
-037 /* init result */
-038 if (c->alloc < max + 1) \{
-039 if ((res = mp_grow (c, max + 1)) != MP_OKAY) \{
-040 return res;
-041 \}
-042 \}
-043
-044 /* get old used digit count and set new one */
-045 olduse = c->used;
-046 c->used = max + 1;
-047
-048 \{
-049 register mp_digit u, *tmpa, *tmpb, *tmpc;
-050 register int i;
-051
-052 /* alias for digit pointers */
-053
-054 /* first input */
-055 tmpa = a->dp;
-056
-057 /* second input */
-058 tmpb = b->dp;
-059
-060 /* destination */
-061 tmpc = c->dp;
-062
-063 /* zero the carry */
-064 u = 0;
-065 for (i = 0; i < min; i++) \{
-066 /* Compute the sum at one digit, T[i] = A[i] + B[i] + U */
-067 *tmpc = *tmpa++ + *tmpb++ + u;
-068
-069 /* U = carry bit of T[i] */
-070 u = *tmpc >> ((mp_digit)DIGIT_BIT);
-071
-072 /* take away carry bit from T[i] */
-073 *tmpc++ &= MP_MASK;
-074 \}
-075
-076 /* now copy higher words if any, that is in A+B
-077 * if A or B has more digits add those in
-078 */
-079 if (min != max) \{
-080 for (; i < max; i++) \{
-081 /* T[i] = X[i] + U */
-082 *tmpc = x->dp[i] + u;
-083
-084 /* U = carry bit of T[i] */
-085 u = *tmpc >> ((mp_digit)DIGIT_BIT);
-086
-087 /* take away carry bit from T[i] */
-088 *tmpc++ &= MP_MASK;
-089 \}
-090 \}
-091
-092 /* add carry */
-093 *tmpc++ = u;
-094
-095 /* clear digits above oldused */
-096 for (i = c->used; i < olduse; i++) \{
-097 *tmpc++ = 0;
-098 \}
-099 \}
-100
-101 mp_clamp (c);
-102 return MP_OKAY;
-103 \}
+016 /* low level addition, based on HAC pp.594, Algorithm 14.7 */
+017 int
+018 s_mp_add (mp_int * a, mp_int * b, mp_int * c)
+019 \{
+020 mp_int *x;
+021 int olduse, res, min, max;
+022
+023 /* find sizes, we let |a| <= |b| which means we have to sort
+024 * them. "x" will point to the input with the most digits
+025 */
+026 if (a->used > b->used) \{
+027 min = b->used;
+028 max = a->used;
+029 x = a;
+030 \} else \{
+031 min = a->used;
+032 max = b->used;
+033 x = b;
+034 \}
+035
+036 /* init result */
+037 if (c->alloc < max + 1) \{
+038 if ((res = mp_grow (c, max + 1)) != MP_OKAY) \{
+039 return res;
+040 \}
+041 \}
+042
+043 /* get old used digit count and set new one */
+044 olduse = c->used;
+045 c->used = max + 1;
+046
+047 \{
+048 register mp_digit u, *tmpa, *tmpb, *tmpc;
+049 register int i;
+050
+051 /* alias for digit pointers */
+052
+053 /* first input */
+054 tmpa = a->dp;
+055
+056 /* second input */
+057 tmpb = b->dp;
+058
+059 /* destination */
+060 tmpc = c->dp;
+061
+062 /* zero the carry */
+063 u = 0;
+064 for (i = 0; i < min; i++) \{
+065 /* Compute the sum at one digit, T[i] = A[i] + B[i] + U */
+066 *tmpc = *tmpa++ + *tmpb++ + u;
+067
+068 /* U = carry bit of T[i] */
+069 u = *tmpc >> ((mp_digit)DIGIT_BIT);
+070
+071 /* take away carry bit from T[i] */
+072 *tmpc++ &= MP_MASK;
+073 \}
+074
+075 /* now copy higher words if any, that is in A+B
+076 * if A or B has more digits add those in
+077 */
+078 if (min != max) \{
+079 for (; i < max; i++) \{
+080 /* T[i] = X[i] + U */
+081 *tmpc = x->dp[i] + u;
+082
+083 /* U = carry bit of T[i] */
+084 u = *tmpc >> ((mp_digit)DIGIT_BIT);
+085
+086 /* take away carry bit from T[i] */
+087 *tmpc++ &= MP_MASK;
+088 \}
+089 \}
+090
+091 /* add carry */
+092 *tmpc++ = u;
+093
+094 /* clear digits above oldused */
+095 for (i = c->used; i < olduse; i++) \{
+096 *tmpc++ = 0;
+097 \}
+098 \}
+099
+100 mp_clamp (c);
+101 return MP_OKAY;
+102 \}
\end{alltt}
\end{small}
-Lines 27 to 35 perform the initial sorting of the inputs and determine the $min$ and $max$ variables. Note that $x$ is a pointer to a
-mp\_int assigned to the largest input, in effect it is a local alias. Lines 37 to 42 ensure that the destination is grown to
+Lines 26 to 34 perform the initial sorting of the inputs and determine the $min$ and $max$ variables. Note that $x$ is a pointer to a
+mp\_int assigned to the largest input, in effect it is a local alias. Lines 36 to 41 ensure that the destination is grown to
accomodate the result of the addition.
Similar to the implementation of mp\_copy this function uses the braced code and local aliases coding style. The three aliases that are on
-lines 55, 58 and 61 represent the two inputs and destination variables respectively. These aliases are used to ensure the
+lines 54, 57 and 60 represent the two inputs and destination variables respectively. These aliases are used to ensure the
compiler does not have to dereference $a$, $b$ or $c$ (respectively) to access the digits of the respective mp\_int.
-The initial carry $u$ is cleared on line 64, note that $u$ is of type mp\_digit which ensures type compatibility within the
-implementation. The initial addition loop begins on line 65 and ends on line 74. Similarly the conditional addition loop
-begins on line 80 and ends on line 90. The addition is finished with the final carry being stored in $tmpc$ on line 93.
-Note the ``++'' operator on the same line. After line 93 $tmpc$ will point to the $c.used$'th digit of the mp\_int $c$. This is useful
-for the next loop on lines 96 to 99 which set any old upper digits to zero.
+The initial carry $u$ is cleared on line 63, note that $u$ is of type mp\_digit which ensures type compatibility within the
+implementation. The initial addition loop begins on line 64 and ends on line 73. Similarly the conditional addition loop
+begins on line 79 and ends on line 89. The addition is finished with the final carry being stored in $tmpc$ on line 96.
+Note the ``++'' operator on the same line. After line 96 $tmpc$ will point to the $c.used$'th digit of the mp\_int $c$. This is useful
+for the next loop on lines 95 to 98 which set any old upper digits to zero.
\subsection{Low Level Subtraction}
The low level unsigned subtraction algorithm is very similar to the low level unsigned addition algorithm. The principle difference is that the
@@ -2251,91 +2273,90 @@ If $b$ has a smaller magnitude than $a$ then step 9 will force the carry and cop
\hspace{-5.1mm}{\bf File}: bn\_s\_mp\_sub.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* low level subtraction (assumes |a| > |b|), HAC pp.595 Algorithm 14.9 */
-018 int
-019 s_mp_sub (mp_int * a, mp_int * b, mp_int * c)
-020 \{
-021 int olduse, res, min, max;
-022
-023 /* find sizes */
-024 min = b->used;
-025 max = a->used;
-026
-027 /* init result */
-028 if (c->alloc < max) \{
-029 if ((res = mp_grow (c, max)) != MP_OKAY) \{
-030 return res;
-031 \}
-032 \}
-033 olduse = c->used;
-034 c->used = max;
-035
-036 \{
-037 register mp_digit u, *tmpa, *tmpb, *tmpc;
-038 register int i;
-039
-040 /* alias for digit pointers */
-041 tmpa = a->dp;
-042 tmpb = b->dp;
-043 tmpc = c->dp;
-044
-045 /* set carry to zero */
-046 u = 0;
-047 for (i = 0; i < min; i++) \{
-048 /* T[i] = A[i] - B[i] - U */
-049 *tmpc = *tmpa++ - *tmpb++ - u;
-050
-051 /* U = carry bit of T[i]
-052 * Note this saves performing an AND operation since
-053 * if a carry does occur it will propagate all the way to the
-054 * MSB. As a result a single shift is enough to get the carry
-055 */
-056 u = *tmpc >> ((mp_digit)(CHAR_BIT * sizeof (mp_digit) - 1));
-057
-058 /* Clear carry from T[i] */
-059 *tmpc++ &= MP_MASK;
-060 \}
-061
-062 /* now copy higher words if any, e.g. if A has more digits than B */
-063 for (; i < max; i++) \{
-064 /* T[i] = A[i] - U */
-065 *tmpc = *tmpa++ - u;
-066
-067 /* U = carry bit of T[i] */
-068 u = *tmpc >> ((mp_digit)(CHAR_BIT * sizeof (mp_digit) - 1));
-069
-070 /* Clear carry from T[i] */
-071 *tmpc++ &= MP_MASK;
-072 \}
-073
-074 /* clear digits above used (since we may not have grown result above) */
+016 /* low level subtraction (assumes |a| > |b|), HAC pp.595 Algorithm 14.9 */
+017 int
+018 s_mp_sub (mp_int * a, mp_int * b, mp_int * c)
+019 \{
+020 int olduse, res, min, max;
+021
+022 /* find sizes */
+023 min = b->used;
+024 max = a->used;
+025
+026 /* init result */
+027 if (c->alloc < max) \{
+028 if ((res = mp_grow (c, max)) != MP_OKAY) \{
+029 return res;
+030 \}
+031 \}
+032 olduse = c->used;
+033 c->used = max;
+034
+035 \{
+036 register mp_digit u, *tmpa, *tmpb, *tmpc;
+037 register int i;
+038
+039 /* alias for digit pointers */
+040 tmpa = a->dp;
+041 tmpb = b->dp;
+042 tmpc = c->dp;
+043
+044 /* set carry to zero */
+045 u = 0;
+046 for (i = 0; i < min; i++) \{
+047 /* T[i] = A[i] - B[i] - U */
+048 *tmpc = *tmpa++ - *tmpb++ - u;
+049
+050 /* U = carry bit of T[i]
+051 * Note this saves performing an AND operation since
+052 * if a carry does occur it will propagate all the way to the
+053 * MSB. As a result a single shift is enough to get the carry
+054 */
+055 u = *tmpc >> ((mp_digit)(CHAR_BIT * sizeof (mp_digit) - 1));
+056
+057 /* Clear carry from T[i] */
+058 *tmpc++ &= MP_MASK;
+059 \}
+060
+061 /* now copy higher words if any, e.g. if A has more digits than B */
+062 for (; i < max; i++) \{
+063 /* T[i] = A[i] - U */
+064 *tmpc = *tmpa++ - u;
+065
+066 /* U = carry bit of T[i] */
+067 u = *tmpc >> ((mp_digit)(CHAR_BIT * sizeof (mp_digit) - 1));
+068
+069 /* Clear carry from T[i] */
+070 *tmpc++ &= MP_MASK;
+071 \}
+072
+073 /* clear digits above used (since we may not have grown result above) */
-075 for (i = c->used; i < olduse; i++) \{
-076 *tmpc++ = 0;
-077 \}
-078 \}
-079
-080 mp_clamp (c);
-081 return MP_OKAY;
-082 \}
-083
+074 for (i = c->used; i < olduse; i++) \{
+075 *tmpc++ = 0;
+076 \}
+077 \}
+078
+079 mp_clamp (c);
+080 return MP_OKAY;
+081 \}
+082
\end{alltt}
\end{small}
-Line 24 and 25 perform the initial hardcoded sorting of the inputs. In reality the $min$ and $max$ variables are only aliases and are only
-used to make the source code easier to read. Again the pointer alias optimization is used within this algorithm. Lines 41, 42 and 43 initialize the aliases for
+Line 23 and 24 perform the initial hardcoded sorting of the inputs. In reality the $min$ and $max$ variables are only aliases and are only
+used to make the source code easier to read. Again the pointer alias optimization is used within this algorithm. Lines 40, 41 and 42 initialize the aliases for
$a$, $b$ and $c$ respectively.
-The first subtraction loop occurs on lines 46 through 60. The theory behind the subtraction loop is exactly the same as that for
+The first subtraction loop occurs on lines 45 through 59. The theory behind the subtraction loop is exactly the same as that for
the addition loop. As remarked earlier there is an implementation reason for using the ``awkward'' method of extracting the carry
-(\textit{see line 56}). The traditional method for extracting the carry would be to shift by $lg(\beta)$ positions and logically AND
+(\textit{see line 55}). The traditional method for extracting the carry would be to shift by $lg(\beta)$ positions and logically AND
the least significant bit. The AND operation is required because all of the bits above the $\lg(\beta)$'th bit will be set to one after a carry
occurs from subtraction. This carry extraction requires two relatively cheap operations to extract the carry. The other method is to simply
shift the most significant bit to the least significant bit thus extracting the carry with a single cheap operation. This optimization only works on
twos compliment machines which is a safe assumption to make.
-If $a$ has a larger magnitude than $b$ an additional loop (\textit{see lines 63 through 72}) is required to propagate the carry through
+If $a$ has a larger magnitude than $b$ an additional loop (\textit{see lines 62 through 71}) is required to propagate the carry through
$a$ and copy the result to $c$.
\subsection{High Level Addition}
@@ -2419,38 +2440,37 @@ within algorithm s\_mp\_add will force $-0$ to become $0$.
\hspace{-5.1mm}{\bf File}: bn\_mp\_add.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* high level addition (handles signs) */
-018 int mp_add (mp_int * a, mp_int * b, mp_int * c)
-019 \{
-020 int sa, sb, res;
-021
-022 /* get sign of both inputs */
-023 sa = a->sign;
-024 sb = b->sign;
-025
-026 /* handle two cases, not four */
-027 if (sa == sb) \{
-028 /* both positive or both negative */
-029 /* add their magnitudes, copy the sign */
-030 c->sign = sa;
-031 res = s_mp_add (a, b, c);
-032 \} else \{
-033 /* one positive, the other negative */
-034 /* subtract the one with the greater magnitude from */
-035 /* the one of the lesser magnitude. The result gets */
-036 /* the sign of the one with the greater magnitude. */
-037 if (mp_cmp_mag (a, b) == MP_LT) \{
-038 c->sign = sb;
-039 res = s_mp_sub (b, a, c);
-040 \} else \{
-041 c->sign = sa;
-042 res = s_mp_sub (a, b, c);
-043 \}
-044 \}
-045 return res;
-046 \}
-047
+016 /* high level addition (handles signs) */
+017 int mp_add (mp_int * a, mp_int * b, mp_int * c)
+018 \{
+019 int sa, sb, res;
+020
+021 /* get sign of both inputs */
+022 sa = a->sign;
+023 sb = b->sign;
+024
+025 /* handle two cases, not four */
+026 if (sa == sb) \{
+027 /* both positive or both negative */
+028 /* add their magnitudes, copy the sign */
+029 c->sign = sa;
+030 res = s_mp_add (a, b, c);
+031 \} else \{
+032 /* one positive, the other negative */
+033 /* subtract the one with the greater magnitude from */
+034 /* the one of the lesser magnitude. The result gets */
+035 /* the sign of the one with the greater magnitude. */
+036 if (mp_cmp_mag (a, b) == MP_LT) \{
+037 c->sign = sb;
+038 res = s_mp_sub (b, a, c);
+039 \} else \{
+040 c->sign = sa;
+041 res = s_mp_sub (a, b, c);
+042 \}
+043 \}
+044 return res;
+045 \}
+046
\end{alltt}
\end{small}
@@ -2524,49 +2544,48 @@ algorithm from producing $-a - -a = -0$ as a result.
\hspace{-5.1mm}{\bf File}: bn\_mp\_sub.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* high level subtraction (handles signs) */
-018 int
-019 mp_sub (mp_int * a, mp_int * b, mp_int * c)
-020 \{
-021 int sa, sb, res;
-022
-023 sa = a->sign;
-024 sb = b->sign;
-025
-026 if (sa != sb) \{
-027 /* subtract a negative from a positive, OR */
-028 /* subtract a positive from a negative. */
-029 /* In either case, ADD their magnitudes, */
-030 /* and use the sign of the first number. */
-031 c->sign = sa;
-032 res = s_mp_add (a, b, c);
-033 \} else \{
-034 /* subtract a positive from a positive, OR */
-035 /* subtract a negative from a negative. */
-036 /* First, take the difference between their */
-037 /* magnitudes, then... */
-038 if (mp_cmp_mag (a, b) != MP_LT) \{
-039 /* Copy the sign from the first */
-040 c->sign = sa;
-041 /* The first has a larger or equal magnitude */
-042 res = s_mp_sub (a, b, c);
-043 \} else \{
-044 /* The result has the *opposite* sign from */
-045 /* the first number. */
-046 c->sign = (sa == MP_ZPOS) ? MP_NEG : MP_ZPOS;
-047 /* The second has a larger magnitude */
-048 res = s_mp_sub (b, a, c);
-049 \}
-050 \}
-051 return res;
-052 \}
-053
+016 /* high level subtraction (handles signs) */
+017 int
+018 mp_sub (mp_int * a, mp_int * b, mp_int * c)
+019 \{
+020 int sa, sb, res;
+021
+022 sa = a->sign;
+023 sb = b->sign;
+024
+025 if (sa != sb) \{
+026 /* subtract a negative from a positive, OR */
+027 /* subtract a positive from a negative. */
+028 /* In either case, ADD their magnitudes, */
+029 /* and use the sign of the first number. */
+030 c->sign = sa;
+031 res = s_mp_add (a, b, c);
+032 \} else \{
+033 /* subtract a positive from a positive, OR */
+034 /* subtract a negative from a negative. */
+035 /* First, take the difference between their */
+036 /* magnitudes, then... */
+037 if (mp_cmp_mag (a, b) != MP_LT) \{
+038 /* Copy the sign from the first */
+039 c->sign = sa;
+040 /* The first has a larger or equal magnitude */
+041 res = s_mp_sub (a, b, c);
+042 \} else \{
+043 /* The result has the *opposite* sign from */
+044 /* the first number. */
+045 c->sign = (sa == MP_ZPOS) ? MP_NEG : MP_ZPOS;
+046 /* The second has a larger magnitude */
+047 res = s_mp_sub (b, a, c);
+048 \}
+049 \}
+050 return res;
+051 \}
+052
\end{alltt}
\end{small}
Much like the implementation of algorithm mp\_add the variable $res$ is used to catch the return code of the unsigned addition or subtraction operations
-and forward it to the end of the function. On line 38 the ``not equal to'' \textbf{MP\_LT} expression is used to emulate a
+and forward it to the end of the function. On line 37 the ``not equal to'' \textbf{MP\_LT} expression is used to emulate a
``greater than or equal to'' comparison.
\section{Bit and Digit Shifting}
@@ -2634,72 +2653,71 @@ Step 8 clears any leading digits of $b$ in case it originally had a larger magni
\hspace{-5.1mm}{\bf File}: bn\_mp\_mul\_2.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* b = a*2 */
-018 int mp_mul_2(mp_int * a, mp_int * b)
-019 \{
-020 int x, res, oldused;
-021
-022 /* grow to accomodate result */
-023 if (b->alloc < a->used + 1) \{
-024 if ((res = mp_grow (b, a->used + 1)) != MP_OKAY) \{
-025 return res;
-026 \}
-027 \}
-028
-029 oldused = b->used;
-030 b->used = a->used;
-031
-032 \{
-033 register mp_digit r, rr, *tmpa, *tmpb;
-034
-035 /* alias for source */
-036 tmpa = a->dp;
-037
-038 /* alias for dest */
-039 tmpb = b->dp;
-040
-041 /* carry */
-042 r = 0;
-043 for (x = 0; x < a->used; x++) \{
-044
-045 /* get what will be the *next* carry bit from the
-046 * MSB of the current digit
-047 */
-048 rr = *tmpa >> ((mp_digit)(DIGIT_BIT - 1));
-049
-050 /* now shift up this digit, add in the carry [from the previous] */
-051 *tmpb++ = ((*tmpa++ << ((mp_digit)1)) | r) & MP_MASK;
-052
-053 /* copy the carry that would be from the source
-054 * digit into the next iteration
-055 */
-056 r = rr;
-057 \}
-058
-059 /* new leading digit? */
-060 if (r != 0) \{
-061 /* add a MSB which is always 1 at this point */
-062 *tmpb = 1;
-063 ++(b->used);
-064 \}
-065
-066 /* now zero any excess digits on the destination
-067 * that we didn't write to
-068 */
-069 tmpb = b->dp + b->used;
-070 for (x = b->used; x < oldused; x++) \{
-071 *tmpb++ = 0;
-072 \}
-073 \}
-074 b->sign = a->sign;
-075 return MP_OKAY;
-076 \}
+016 /* b = a*2 */
+017 int mp_mul_2(mp_int * a, mp_int * b)
+018 \{
+019 int x, res, oldused;
+020
+021 /* grow to accomodate result */
+022 if (b->alloc < a->used + 1) \{
+023 if ((res = mp_grow (b, a->used + 1)) != MP_OKAY) \{
+024 return res;
+025 \}
+026 \}
+027
+028 oldused = b->used;
+029 b->used = a->used;
+030
+031 \{
+032 register mp_digit r, rr, *tmpa, *tmpb;
+033
+034 /* alias for source */
+035 tmpa = a->dp;
+036
+037 /* alias for dest */
+038 tmpb = b->dp;
+039
+040 /* carry */
+041 r = 0;
+042 for (x = 0; x < a->used; x++) \{
+043
+044 /* get what will be the *next* carry bit from the
+045 * MSB of the current digit
+046 */
+047 rr = *tmpa >> ((mp_digit)(DIGIT_BIT - 1));
+048
+049 /* now shift up this digit, add in the carry [from the previous] */
+050 *tmpb++ = ((*tmpa++ << ((mp_digit)1)) | r) & MP_MASK;
+051
+052 /* copy the carry that would be from the source
+053 * digit into the next iteration
+054 */
+055 r = rr;
+056 \}
+057
+058 /* new leading digit? */
+059 if (r != 0) \{
+060 /* add a MSB which is always 1 at this point */
+061 *tmpb = 1;
+062 ++(b->used);
+063 \}
+064
+065 /* now zero any excess digits on the destination
+066 * that we didn't write to
+067 */
+068 tmpb = b->dp + b->used;
+069 for (x = b->used; x < oldused; x++) \{
+070 *tmpb++ = 0;
+071 \}
+072 \}
+073 b->sign = a->sign;
+074 return MP_OKAY;
+075 \}
\end{alltt}
\end{small}
This implementation is essentially an optimized implementation of s\_mp\_add for the case of doubling an input. The only noteworthy difference
-is the use of the logical shift operator on line 51 to perform a single precision doubling.
+is the use of the logical shift operator on line 50 to perform a single precision doubling.
\subsection{Division by Two}
A division by two can just as easily be accomplished with a logical shift right as multiplication by two can be with a logical shift left.
@@ -2747,53 +2765,52 @@ least significant bit not the most significant bit.
\hspace{-5.1mm}{\bf File}: bn\_mp\_div\_2.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* b = a/2 */
-018 int mp_div_2(mp_int * a, mp_int * b)
-019 \{
-020 int x, res, oldused;
-021
-022 /* copy */
-023 if (b->alloc < a->used) \{
-024 if ((res = mp_grow (b, a->used)) != MP_OKAY) \{
-025 return res;
-026 \}
-027 \}
-028
-029 oldused = b->used;
-030 b->used = a->used;
-031 \{
-032 register mp_digit r, rr, *tmpa, *tmpb;
-033
-034 /* source alias */
-035 tmpa = a->dp + b->used - 1;
-036
-037 /* dest alias */
-038 tmpb = b->dp + b->used - 1;
-039
-040 /* carry */
-041 r = 0;
-042 for (x = b->used - 1; x >= 0; x--) \{
-043 /* get the carry for the next iteration */
-044 rr = *tmpa & 1;
-045
-046 /* shift the current digit, add in carry and store */
-047 *tmpb-- = (*tmpa-- >> 1) | (r << (DIGIT_BIT - 1));
-048
-049 /* forward carry to next iteration */
-050 r = rr;
-051 \}
-052
-053 /* zero excess digits */
-054 tmpb = b->dp + b->used;
-055 for (x = b->used; x < oldused; x++) \{
-056 *tmpb++ = 0;
-057 \}
-058 \}
-059 b->sign = a->sign;
-060 mp_clamp (b);
-061 return MP_OKAY;
-062 \}
+016 /* b = a/2 */
+017 int mp_div_2(mp_int * a, mp_int * b)
+018 \{
+019 int x, res, oldused;
+020
+021 /* copy */
+022 if (b->alloc < a->used) \{
+023 if ((res = mp_grow (b, a->used)) != MP_OKAY) \{
+024 return res;
+025 \}
+026 \}
+027
+028 oldused = b->used;
+029 b->used = a->used;
+030 \{
+031 register mp_digit r, rr, *tmpa, *tmpb;
+032
+033 /* source alias */
+034 tmpa = a->dp + b->used - 1;
+035
+036 /* dest alias */
+037 tmpb = b->dp + b->used - 1;
+038
+039 /* carry */
+040 r = 0;
+041 for (x = b->used - 1; x >= 0; x--) \{
+042 /* get the carry for the next iteration */
+043 rr = *tmpa & 1;
+044
+045 /* shift the current digit, add in carry and store */
+046 *tmpb-- = (*tmpa-- >> 1) | (r << (DIGIT_BIT - 1));
+047
+048 /* forward carry to next iteration */
+049 r = rr;
+050 \}
+051
+052 /* zero excess digits */
+053 tmpb = b->dp + b->used;
+054 for (x = b->used; x < oldused; x++) \{
+055 *tmpb++ = 0;
+056 \}
+057 \}
+058 b->sign = a->sign;
+059 mp_clamp (b);
+060 return MP_OKAY;
+061 \}
\end{alltt}
\end{small}
@@ -2867,58 +2884,57 @@ step 8 sets the lower $b$ digits to zero.
\hspace{-5.1mm}{\bf File}: bn\_mp\_lshd.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* shift left a certain amount of digits */
-018 int mp_lshd (mp_int * a, int b)
-019 \{
-020 int x, res;
-021
-022 /* if its less than zero return */
-023 if (b <= 0) \{
-024 return MP_OKAY;
-025 \}
-026
-027 /* grow to fit the new digits */
-028 if (a->alloc < a->used + b) \{
-029 if ((res = mp_grow (a, a->used + b)) != MP_OKAY) \{
-030 return res;
-031 \}
-032 \}
-033
-034 \{
-035 register mp_digit *top, *bottom;
-036
-037 /* increment the used by the shift amount then copy upwards */
-038 a->used += b;
-039
-040 /* top */
-041 top = a->dp + a->used - 1;
-042
-043 /* base */
-044 bottom = a->dp + a->used - 1 - b;
-045
-046 /* much like mp_rshd this is implemented using a sliding window
-047 * except the window goes the otherway around. Copying from
-048 * the bottom to the top. see bn_mp_rshd.c for more info.
-049 */
-050 for (x = a->used - 1; x >= b; x--) \{
-051 *top-- = *bottom--;
-052 \}
-053
-054 /* zero the lower digits */
-055 top = a->dp;
-056 for (x = 0; x < b; x++) \{
-057 *top++ = 0;
-058 \}
-059 \}
-060 return MP_OKAY;
-061 \}
+016 /* shift left a certain amount of digits */
+017 int mp_lshd (mp_int * a, int b)
+018 \{
+019 int x, res;
+020
+021 /* if its less than zero return */
+022 if (b <= 0) \{
+023 return MP_OKAY;
+024 \}
+025
+026 /* grow to fit the new digits */
+027 if (a->alloc < a->used + b) \{
+028 if ((res = mp_grow (a, a->used + b)) != MP_OKAY) \{
+029 return res;
+030 \}
+031 \}
+032
+033 \{
+034 register mp_digit *top, *bottom;
+035
+036 /* increment the used by the shift amount then copy upwards */
+037 a->used += b;
+038
+039 /* top */
+040 top = a->dp + a->used - 1;
+041
+042 /* base */
+043 bottom = a->dp + a->used - 1 - b;
+044
+045 /* much like mp_rshd this is implemented using a sliding window
+046 * except the window goes the otherway around. Copying from
+047 * the bottom to the top. see bn_mp_rshd.c for more info.
+048 */
+049 for (x = a->used - 1; x >= b; x--) \{
+050 *top-- = *bottom--;
+051 \}
+052
+053 /* zero the lower digits */
+054 top = a->dp;
+055 for (x = 0; x < b; x++) \{
+056 *top++ = 0;
+057 \}
+058 \}
+059 return MP_OKAY;
+060 \}
\end{alltt}
\end{small}
-The if statement on line 23 ensures that the $b$ variable is greater than zero. The \textbf{used} count is incremented by $b$ before
-the copy loop begins. This elminates the need for an additional variable in the for loop. The variable $top$ on line 41 is an alias
-for the leading digit while $bottom$ on line 44 is an alias for the trailing edge. The aliases form a window of exactly $b$ digits
+The if statement on line 22 ensures that the $b$ variable is greater than zero. The \textbf{used} count is incremented by $b$ before
+the copy loop begins. This elminates the need for an additional variable in the for loop. The variable $top$ on line 40 is an alias
+for the leading digit while $bottom$ on line 47 is an alias for the trailing edge. The aliases form a window of exactly $b$ digits
over the input.
\subsection{Division by $x$}
@@ -2971,57 +2987,56 @@ Once the window copy is complete the upper digits must be zeroed and the \textbf
\hspace{-5.1mm}{\bf File}: bn\_mp\_rshd.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* shift right a certain amount of digits */
-018 void mp_rshd (mp_int * a, int b)
-019 \{
-020 int x;
-021
-022 /* if b <= 0 then ignore it */
-023 if (b <= 0) \{
-024 return;
-025 \}
-026
-027 /* if b > used then simply zero it and return */
-028 if (a->used <= b) \{
-029 mp_zero (a);
-030 return;
-031 \}
-032
-033 \{
-034 register mp_digit *bottom, *top;
-035
-036 /* shift the digits down */
-037
-038 /* bottom */
-039 bottom = a->dp;
-040
-041 /* top [offset into digits] */
-042 top = a->dp + b;
-043
-044 /* this is implemented as a sliding window where
-045 * the window is b-digits long and digits from
-046 * the top of the window are copied to the bottom
-047 *
-048 * e.g.
-049
-050 b-2 | b-1 | b0 | b1 | b2 | ... | bb | ---->
-051 /\symbol{92} | ---->
-052 \symbol{92}-------------------/ ---->
-053 */
-054 for (x = 0; x < (a->used - b); x++) \{
-055 *bottom++ = *top++;
-056 \}
-057
-058 /* zero the top digits */
-059 for (; x < a->used; x++) \{
-060 *bottom++ = 0;
-061 \}
-062 \}
-063
-064 /* remove excess digits */
-065 a->used -= b;
-066 \}
+016 /* shift right a certain amount of digits */
+017 void mp_rshd (mp_int * a, int b)
+018 \{
+019 int x;
+020
+021 /* if b <= 0 then ignore it */
+022 if (b <= 0) \{
+023 return;
+024 \}
+025
+026 /* if b > used then simply zero it and return */
+027 if (a->used <= b) \{
+028 mp_zero (a);
+029 return;
+030 \}
+031
+032 \{
+033 register mp_digit *bottom, *top;
+034
+035 /* shift the digits down */
+036
+037 /* bottom */
+038 bottom = a->dp;
+039
+040 /* top [offset into digits] */
+041 top = a->dp + b;
+042
+043 /* this is implemented as a sliding window where
+044 * the window is b-digits long and digits from
+045 * the top of the window are copied to the bottom
+046 *
+047 * e.g.
+048
+049 b-2 | b-1 | b0 | b1 | b2 | ... | bb | ---->
+050 /\symbol{92} | ---->
+051 \symbol{92}-------------------/ ---->
+052 */
+053 for (x = 0; x < (a->used - b); x++) \{
+054 *bottom++ = *top++;
+055 \}
+056
+057 /* zero the top digits */
+058 for (; x < a->used; x++) \{
+059 *bottom++ = 0;
+060 \}
+061 \}
+062
+063 /* remove excess digits */
+064 a->used -= b;
+065 \}
\end{alltt}
\end{small}
@@ -3090,70 +3105,69 @@ complete. It is possible to optimize this algorithm down to a $O(n)$ algorithm
\hspace{-5.1mm}{\bf File}: bn\_mp\_mul\_2d.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* shift left by a certain bit count */
-018 int mp_mul_2d (mp_int * a, int b, mp_int * c)
-019 \{
-020 mp_digit d;
-021 int res;
-022
-023 /* copy */
-024 if (a != c) \{
-025 if ((res = mp_copy (a, c)) != MP_OKAY) \{
-026 return res;
-027 \}
-028 \}
-029
-030 if (c->alloc < (int)(c->used + b/DIGIT_BIT + 1)) \{
-031 if ((res = mp_grow (c, c->used + b / DIGIT_BIT + 1)) != MP_OKAY) \{
-032 return res;
-033 \}
-034 \}
-035
-036 /* shift by as many digits in the bit count */
-037 if (b >= (int)DIGIT_BIT) \{
-038 if ((res = mp_lshd (c, b / DIGIT_BIT)) != MP_OKAY) \{
-039 return res;
-040 \}
-041 \}
-042
-043 /* shift any bit count < DIGIT_BIT */
-044 d = (mp_digit) (b % DIGIT_BIT);
-045 if (d != 0) \{
-046 register mp_digit *tmpc, shift, mask, r, rr;
-047 register int x;
-048
-049 /* bitmask for carries */
-050 mask = (((mp_digit)1) << d) - 1;
-051
-052 /* shift for msbs */
-053 shift = DIGIT_BIT - d;
-054
-055 /* alias */
-056 tmpc = c->dp;
-057
-058 /* carry */
-059 r = 0;
-060 for (x = 0; x < c->used; x++) \{
-061 /* get the higher bits of the current word */
-062 rr = (*tmpc >> shift) & mask;
-063
-064 /* shift the current word and OR in the carry */
-065 *tmpc = ((*tmpc << d) | r) & MP_MASK;
-066 ++tmpc;
-067
-068 /* set the carry to the carry bits of the current word */
-069 r = rr;
-070 \}
-071
-072 /* set final carry */
-073 if (r != 0) \{
-074 c->dp[(c->used)++] = r;
-075 \}
-076 \}
-077 mp_clamp (c);
-078 return MP_OKAY;
-079 \}
+016 /* shift left by a certain bit count */
+017 int mp_mul_2d (mp_int * a, int b, mp_int * c)
+018 \{
+019 mp_digit d;
+020 int res;
+021
+022 /* copy */
+023 if (a != c) \{
+024 if ((res = mp_copy (a, c)) != MP_OKAY) \{
+025 return res;
+026 \}
+027 \}
+028
+029 if (c->alloc < (int)(c->used + b/DIGIT_BIT + 1)) \{
+030 if ((res = mp_grow (c, c->used + b / DIGIT_BIT + 1)) != MP_OKAY) \{
+031 return res;
+032 \}
+033 \}
+034
+035 /* shift by as many digits in the bit count */
+036 if (b >= (int)DIGIT_BIT) \{
+037 if ((res = mp_lshd (c, b / DIGIT_BIT)) != MP_OKAY) \{
+038 return res;
+039 \}
+040 \}
+041
+042 /* shift any bit count < DIGIT_BIT */
+043 d = (mp_digit) (b % DIGIT_BIT);
+044 if (d != 0) \{
+045 register mp_digit *tmpc, shift, mask, r, rr;
+046 register int x;
+047
+048 /* bitmask for carries */
+049 mask = (((mp_digit)1) << d) - 1;
+050
+051 /* shift for msbs */
+052 shift = DIGIT_BIT - d;
+053
+054 /* alias */
+055 tmpc = c->dp;
+056
+057 /* carry */
+058 r = 0;
+059 for (x = 0; x < c->used; x++) \{
+060 /* get the higher bits of the current word */
+061 rr = (*tmpc >> shift) & mask;
+062
+063 /* shift the current word and OR in the carry */
+064 *tmpc = ((*tmpc << d) | r) & MP_MASK;
+065 ++tmpc;
+066
+067 /* set the carry to the carry bits of the current word */
+068 r = rr;
+069 \}
+070
+071 /* set final carry */
+072 if (r != 0) \{
+073 c->dp[(c->used)++] = r;
+074 \}
+075 \}
+076 mp_clamp (c);
+077 return MP_OKAY;
+078 \}
\end{alltt}
\end{small}
@@ -3203,84 +3217,83 @@ by using algorithm mp\_mod\_2d.
\hspace{-5.1mm}{\bf File}: bn\_mp\_div\_2d.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* shift right by a certain bit count (store quotient in c, optional remaind
+016 /* shift right by a certain bit count (store quotient in c, optional remaind
er in d) */
-018 int mp_div_2d (mp_int * a, int b, mp_int * c, mp_int * d)
-019 \{
-020 mp_digit D, r, rr;
-021 int x, res;
-022 mp_int t;
+017 int mp_div_2d (mp_int * a, int b, mp_int * c, mp_int * d)
+018 \{
+019 mp_digit D, r, rr;
+020 int x, res;
+021 mp_int t;
+022
023
-024
-025 /* if the shift count is <= 0 then we do no work */
-026 if (b <= 0) \{
-027 res = mp_copy (a, c);
-028 if (d != NULL) \{
-029 mp_zero (d);
-030 \}
-031 return res;
-032 \}
-033
-034 if ((res = mp_init (&t)) != MP_OKAY) \{
-035 return res;
-036 \}
-037
-038 /* get the remainder */
-039 if (d != NULL) \{
-040 if ((res = mp_mod_2d (a, b, &t)) != MP_OKAY) \{
-041 mp_clear (&t);
-042 return res;
-043 \}
-044 \}
-045
-046 /* copy */
-047 if ((res = mp_copy (a, c)) != MP_OKAY) \{
-048 mp_clear (&t);
-049 return res;
-050 \}
-051
-052 /* shift by as many digits in the bit count */
-053 if (b >= (int)DIGIT_BIT) \{
-054 mp_rshd (c, b / DIGIT_BIT);
-055 \}
-056
-057 /* shift any bit count < DIGIT_BIT */
-058 D = (mp_digit) (b % DIGIT_BIT);
-059 if (D != 0) \{
-060 register mp_digit *tmpc, mask, shift;
-061
-062 /* mask */
-063 mask = (((mp_digit)1) << D) - 1;
-064
-065 /* shift for lsb */
-066 shift = DIGIT_BIT - D;
-067
-068 /* alias */
-069 tmpc = c->dp + (c->used - 1);
-070
-071 /* carry */
-072 r = 0;
-073 for (x = c->used - 1; x >= 0; x--) \{
-074 /* get the lower bits of this word in a temp */
-075 rr = *tmpc & mask;
-076
-077 /* shift the current word and mix in the carry bits from the previous
+024 /* if the shift count is <= 0 then we do no work */
+025 if (b <= 0) \{
+026 res = mp_copy (a, c);
+027 if (d != NULL) \{
+028 mp_zero (d);
+029 \}
+030 return res;
+031 \}
+032
+033 if ((res = mp_init (&t)) != MP_OKAY) \{
+034 return res;
+035 \}
+036
+037 /* get the remainder */
+038 if (d != NULL) \{
+039 if ((res = mp_mod_2d (a, b, &t)) != MP_OKAY) \{
+040 mp_clear (&t);
+041 return res;
+042 \}
+043 \}
+044
+045 /* copy */
+046 if ((res = mp_copy (a, c)) != MP_OKAY) \{
+047 mp_clear (&t);
+048 return res;
+049 \}
+050
+051 /* shift by as many digits in the bit count */
+052 if (b >= (int)DIGIT_BIT) \{
+053 mp_rshd (c, b / DIGIT_BIT);
+054 \}
+055
+056 /* shift any bit count < DIGIT_BIT */
+057 D = (mp_digit) (b % DIGIT_BIT);
+058 if (D != 0) \{
+059 register mp_digit *tmpc, mask, shift;
+060
+061 /* mask */
+062 mask = (((mp_digit)1) << D) - 1;
+063
+064 /* shift for lsb */
+065 shift = DIGIT_BIT - D;
+066
+067 /* alias */
+068 tmpc = c->dp + (c->used - 1);
+069
+070 /* carry */
+071 r = 0;
+072 for (x = c->used - 1; x >= 0; x--) \{
+073 /* get the lower bits of this word in a temp */
+074 rr = *tmpc & mask;
+075
+076 /* shift the current word and mix in the carry bits from the previous
word */
-078 *tmpc = (*tmpc >> D) | (r << shift);
-079 --tmpc;
-080
-081 /* set the carry to the carry bits of the current word found above */
-082 r = rr;
-083 \}
-084 \}
-085 mp_clamp (c);
-086 if (d != NULL) \{
-087 mp_exch (&t, d);
-088 \}
-089 mp_clear (&t);
-090 return MP_OKAY;
-091 \}
+077 *tmpc = (*tmpc >> D) | (r << shift);
+078 --tmpc;
+079
+080 /* set the carry to the carry bits of the current word found above */
+081 r = rr;
+082 \}
+083 \}
+084 mp_clamp (c);
+085 if (d != NULL) \{
+086 mp_exch (&t, d);
+087 \}
+088 mp_clear (&t);
+089 return MP_OKAY;
+090 \}
\end{alltt}
\end{small}
@@ -3334,42 +3347,41 @@ is copied to $b$, leading digits are removed and the remaining leading digit is
\hspace{-5.1mm}{\bf File}: bn\_mp\_mod\_2d.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* calc a value mod 2**b */
-018 int
-019 mp_mod_2d (mp_int * a, int b, mp_int * c)
-020 \{
-021 int x, res;
-022
-023 /* if b is <= 0 then zero the int */
-024 if (b <= 0) \{
-025 mp_zero (c);
-026 return MP_OKAY;
-027 \}
-028
-029 /* if the modulus is larger than the value than return */
-030 if (b > (int) (a->used * DIGIT_BIT)) \{
-031 res = mp_copy (a, c);
-032 return res;
-033 \}
-034
-035 /* copy */
-036 if ((res = mp_copy (a, c)) != MP_OKAY) \{
-037 return res;
-038 \}
-039
-040 /* zero digits above the last digit of the modulus */
-041 for (x = (b / DIGIT_BIT) + ((b % DIGIT_BIT) == 0 ? 0 : 1); x < c->used; x+
+016 /* calc a value mod 2**b */
+017 int
+018 mp_mod_2d (mp_int * a, int b, mp_int * c)
+019 \{
+020 int x, res;
+021
+022 /* if b is <= 0 then zero the int */
+023 if (b <= 0) \{
+024 mp_zero (c);
+025 return MP_OKAY;
+026 \}
+027
+028 /* if the modulus is larger than the value than return */
+029 if (b > (int) (a->used * DIGIT_BIT)) \{
+030 res = mp_copy (a, c);
+031 return res;
+032 \}
+033
+034 /* copy */
+035 if ((res = mp_copy (a, c)) != MP_OKAY) \{
+036 return res;
+037 \}
+038
+039 /* zero digits above the last digit of the modulus */
+040 for (x = (b / DIGIT_BIT) + ((b % DIGIT_BIT) == 0 ? 0 : 1); x < c->used; x+
+) \{
-042 c->dp[x] = 0;
-043 \}
-044 /* clear the digit that is not completely outside/inside the modulus */
-045 c->dp[b / DIGIT_BIT] &=
-046 (mp_digit) ((((mp_digit) 1) << (((mp_digit) b) % DIGIT_BIT)) - ((mp_digi
+041 c->dp[x] = 0;
+042 \}
+043 /* clear the digit that is not completely outside/inside the modulus */
+044 c->dp[b / DIGIT_BIT] &=
+045 (mp_digit) ((((mp_digit) 1) << (((mp_digit) b) % DIGIT_BIT)) - ((mp_digi
t) 1));
-047 mp_clamp (c);
-048 return MP_OKAY;
-049 \}
+046 mp_clamp (c);
+047 return MP_OKAY;
+048 \}
\end{alltt}
\end{small}
@@ -3533,86 +3545,85 @@ exceed the precision requested.
\hspace{-5.1mm}{\bf File}: bn\_s\_mp\_mul\_digs.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* multiplies |a| * |b| and only computes upto digs digits of result
-018 * HAC pp. 595, Algorithm 14.12 Modified so you can control how
-019 * many digits of output are created.
-020 */
-021 int
-022 s_mp_mul_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
-023 \{
-024 mp_int t;
-025 int res, pa, pb, ix, iy;
-026 mp_digit u;
-027 mp_word r;
-028 mp_digit tmpx, *tmpt, *tmpy;
-029
-030 /* can we use the fast multiplier? */
-031 if (((digs) < MP_WARRAY) &&
-032 MIN (a->used, b->used) <
-033 (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) \{
-034 return fast_s_mp_mul_digs (a, b, c, digs);
-035 \}
-036
-037 if ((res = mp_init_size (&t, digs)) != MP_OKAY) \{
-038 return res;
-039 \}
-040 t.used = digs;
-041
-042 /* compute the digits of the product directly */
-043 pa = a->used;
-044 for (ix = 0; ix < pa; ix++) \{
-045 /* set the carry to zero */
-046 u = 0;
-047
-048 /* limit ourselves to making digs digits of output */
-049 pb = MIN (b->used, digs - ix);
-050
-051 /* setup some aliases */
-052 /* copy of the digit from a used within the nested loop */
-053 tmpx = a->dp[ix];
-054
-055 /* an alias for the destination shifted ix places */
-056 tmpt = t.dp + ix;
-057
-058 /* an alias for the digits of b */
-059 tmpy = b->dp;
-060
-061 /* compute the columns of the output and propagate the carry */
-062 for (iy = 0; iy < pb; iy++) \{
-063 /* compute the column as a mp_word */
-064 r = ((mp_word)*tmpt) +
-065 ((mp_word)tmpx) * ((mp_word)*tmpy++) +
-066 ((mp_word) u);
-067
-068 /* the new column is the lower part of the result */
-069 *tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK));
-070
-071 /* get the carry word from the result */
-072 u = (mp_digit) (r >> ((mp_word) DIGIT_BIT));
-073 \}
-074 /* set carry if it is placed below digs */
-075 if (ix + iy < digs) \{
-076 *tmpt = u;
-077 \}
-078 \}
-079
-080 mp_clamp (&t);
-081 mp_exch (&t, c);
-082
-083 mp_clear (&t);
-084 return MP_OKAY;
-085 \}
+016 /* multiplies |a| * |b| and only computes upto digs digits of result
+017 * HAC pp. 595, Algorithm 14.12 Modified so you can control how
+018 * many digits of output are created.
+019 */
+020 int
+021 s_mp_mul_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
+022 \{
+023 mp_int t;
+024 int res, pa, pb, ix, iy;
+025 mp_digit u;
+026 mp_word r;
+027 mp_digit tmpx, *tmpt, *tmpy;
+028
+029 /* can we use the fast multiplier? */
+030 if (((digs) < MP_WARRAY) &&
+031 MIN (a->used, b->used) <
+032 (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) \{
+033 return fast_s_mp_mul_digs (a, b, c, digs);
+034 \}
+035
+036 if ((res = mp_init_size (&t, digs)) != MP_OKAY) \{
+037 return res;
+038 \}
+039 t.used = digs;
+040
+041 /* compute the digits of the product directly */
+042 pa = a->used;
+043 for (ix = 0; ix < pa; ix++) \{
+044 /* set the carry to zero */
+045 u = 0;
+046
+047 /* limit ourselves to making digs digits of output */
+048 pb = MIN (b->used, digs - ix);
+049
+050 /* setup some aliases */
+051 /* copy of the digit from a used within the nested loop */
+052 tmpx = a->dp[ix];
+053
+054 /* an alias for the destination shifted ix places */
+055 tmpt = t.dp + ix;
+056
+057 /* an alias for the digits of b */
+058 tmpy = b->dp;
+059
+060 /* compute the columns of the output and propagate the carry */
+061 for (iy = 0; iy < pb; iy++) \{
+062 /* compute the column as a mp_word */
+063 r = ((mp_word)*tmpt) +
+064 ((mp_word)tmpx) * ((mp_word)*tmpy++) +
+065 ((mp_word) u);
+066
+067 /* the new column is the lower part of the result */
+068 *tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK));
+069
+070 /* get the carry word from the result */
+071 u = (mp_digit) (r >> ((mp_word) DIGIT_BIT));
+072 \}
+073 /* set carry if it is placed below digs */
+074 if (ix + iy < digs) \{
+075 *tmpt = u;
+076 \}
+077 \}
+078
+079 mp_clamp (&t);
+080 mp_exch (&t, c);
+081
+082 mp_clear (&t);
+083 return MP_OKAY;
+084 \}
\end{alltt}
\end{small}
-Lines 31 to 35 determine if the Comba method can be used first. The conditions for using the Comba routine are that min$(a.used, b.used) < \delta$ and
+Lines 30 to 34 determine if the Comba method can be used first. The conditions for using the Comba routine are that min$(a.used, b.used) < \delta$ and
the number of digits of output is less than \textbf{MP\_WARRAY}. This new constant is used to control
the stack usage in the Comba routines. By default it is set to $\delta$ but can be reduced when memory is at a premium.
-Of particular importance is the calculation of the $ix+iy$'th column on lines 64, 65 and 66. Note how all of the
+Of particular importance is the calculation of the $ix+iy$'th column on lines 64, 65 and 65. Note how all of the
variables are cast to the type \textbf{mp\_word}, which is also the type of variable $\hat r$. That is to ensure that double precision operations
-are used instead of single precision. The multiplication on line 65 makes use of a specific GCC optimizer behaviour. On the outset it looks like
+are used instead of single precision. The multiplication on line 64 makes use of a specific GCC optimizer behaviour. On the outset it looks like
the compiler will have to use a double precision multiplication to produce the result required. Such an operation would be horribly slow on most
processors and drag this to a crawl. However, GCC is smart enough to realize that double wide output single precision multipliers can be used. For
example, the instruction ``MUL'' on the x86 processor can multiply two 32-bit values and produce a 64-bit result.
@@ -3786,129 +3797,128 @@ and addition operations in the nested loop in parallel.
\hspace{-5.1mm}{\bf File}: bn\_fast\_s\_mp\_mul\_digs.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* Fast (comba) multiplier
-018 *
-019 * This is the fast column-array [comba] multiplier. It is
-020 * designed to compute the columns of the product first
-021 * then handle the carries afterwards. This has the effect
-022 * of making the nested loops that compute the columns very
-023 * simple and schedulable on super-scalar processors.
-024 *
-025 * This has been modified to produce a variable number of
-026 * digits of output so if say only a half-product is required
-027 * you don't have to compute the upper half (a feature
-028 * required for fast Barrett reduction).
-029 *
-030 * Based on Algorithm 14.12 on pp.595 of HAC.
-031 *
-032 */
-033 int
-034 fast_s_mp_mul_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
-035 \{
-036 int olduse, res, pa, ix;
-037 mp_word W[MP_WARRAY];
-038
-039 /* grow the destination as required */
-040 if (c->alloc < digs) \{
-041 if ((res = mp_grow (c, digs)) != MP_OKAY) \{
-042 return res;
-043 \}
-044 \}
-045
-046 /* clear temp buf (the columns) */
-047 memset (W, 0, sizeof (mp_word) * digs);
-048
-049 /* calculate the columns */
-050 pa = a->used;
-051 for (ix = 0; ix < pa; ix++) \{
-052 /* this multiplier has been modified to allow you to
-053 * control how many digits of output are produced.
-054 * So at most we want to make upto "digs" digits of output.
-055 *
-056 * this adds products to distinct columns (at ix+iy) of W
-057 * note that each step through the loop is not dependent on
-058 * the previous which means the compiler can easily unroll
-059 * the loop without scheduling problems
-060 */
-061 \{
-062 register mp_digit tmpx, *tmpy;
-063 register mp_word *_W;
-064 register int iy, pb;
-065
-066 /* alias for the the word on the left e.g. A[ix] * A[iy] */
-067 tmpx = a->dp[ix];
-068
-069 /* alias for the right side */
-070 tmpy = b->dp;
-071
-072 /* alias for the columns, each step through the loop adds a new
-073 term to each column
-074 */
-075 _W = W + ix;
-076
-077 /* the number of digits is limited by their placement. E.g.
-078 we avoid multiplying digits that will end up above the # of
-079 digits of precision requested
-080 */
-081 pb = MIN (b->used, digs - ix);
-082
-083 for (iy = 0; iy < pb; iy++) \{
-084 *_W++ += ((mp_word)tmpx) * ((mp_word)*tmpy++);
-085 \}
-086 \}
-087
-088 \}
-089
-090 /* setup dest */
-091 olduse = c->used;
-092 c->used = digs;
-093
-094 \{
-095 register mp_digit *tmpc;
-096
-097 /* At this point W[] contains the sums of each column. To get the
-098 * correct result we must take the extra bits from each column and
-099 * carry them down
-100 *
-101 * Note that while this adds extra code to the multiplier it
-102 * saves time since the carry propagation is removed from the
-103 * above nested loop.This has the effect of reducing the work
-104 * from N*(N+N*c)==N**2 + c*N**2 to N**2 + N*c where c is the
-105 * cost of the shifting. On very small numbers this is slower
-106 * but on most cryptographic size numbers it is faster.
-107 *
-108 * In this particular implementation we feed the carries from
-109 * behind which means when the loop terminates we still have one
-110 * last digit to copy
-111 */
-112 tmpc = c->dp;
-113 for (ix = 1; ix < digs; ix++) \{
-114 /* forward the carry from the previous temp */
-115 W[ix] += (W[ix - 1] >> ((mp_word) DIGIT_BIT));
-116
-117 /* now extract the previous digit [below the carry] */
-118 *tmpc++ = (mp_digit) (W[ix - 1] & ((mp_word) MP_MASK));
-119 \}
-120 /* fetch the last digit */
-121 *tmpc++ = (mp_digit) (W[digs - 1] & ((mp_word) MP_MASK));
-122
-123 /* clear unused digits [that existed in the old copy of c] */
-124 for (; ix < olduse; ix++) \{
-125 *tmpc++ = 0;
-126 \}
-127 \}
-128 mp_clamp (c);
-129 return MP_OKAY;
-130 \}
+016 /* Fast (comba) multiplier
+017 *
+018 * This is the fast column-array [comba] multiplier. It is
+019 * designed to compute the columns of the product first
+020 * then handle the carries afterwards. This has the effect
+021 * of making the nested loops that compute the columns very
+022 * simple and schedulable on super-scalar processors.
+023 *
+024 * This has been modified to produce a variable number of
+025 * digits of output so if say only a half-product is required
+026 * you don't have to compute the upper half (a feature
+027 * required for fast Barrett reduction).
+028 *
+029 * Based on Algorithm 14.12 on pp.595 of HAC.
+030 *
+031 */
+032 int
+033 fast_s_mp_mul_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
+034 \{
+035 int olduse, res, pa, ix;
+036 mp_word W[MP_WARRAY];
+037
+038 /* grow the destination as required */
+039 if (c->alloc < digs) \{
+040 if ((res = mp_grow (c, digs)) != MP_OKAY) \{
+041 return res;
+042 \}
+043 \}
+044
+045 /* clear temp buf (the columns) */
+046 memset (W, 0, sizeof (mp_word) * digs);
+047
+048 /* calculate the columns */
+049 pa = a->used;
+050 for (ix = 0; ix < pa; ix++) \{
+051 /* this multiplier has been modified to allow you to
+052 * control how many digits of output are produced.
+053 * So at most we want to make upto "digs" digits of output.
+054 *
+055 * this adds products to distinct columns (at ix+iy) of W
+056 * note that each step through the loop is not dependent on
+057 * the previous which means the compiler can easily unroll
+058 * the loop without scheduling problems
+059 */
+060 \{
+061 register mp_digit tmpx, *tmpy;
+062 register mp_word *_W;
+063 register int iy, pb;
+064
+065 /* alias for the the word on the left e.g. A[ix] * A[iy] */
+066 tmpx = a->dp[ix];
+067
+068 /* alias for the right side */
+069 tmpy = b->dp;
+070
+071 /* alias for the columns, each step through the loop adds a new
+072 term to each column
+073 */
+074 _W = W + ix;
+075
+076 /* the number of digits is limited by their placement. E.g.
+077 we avoid multiplying digits that will end up above the # of
+078 digits of precision requested
+079 */
+080 pb = MIN (b->used, digs - ix);
+081
+082 for (iy = 0; iy < pb; iy++) \{
+083 *_W++ += ((mp_word)tmpx) * ((mp_word)*tmpy++);
+084 \}
+085 \}
+086
+087 \}
+088
+089 /* setup dest */
+090 olduse = c->used;
+091 c->used = digs;
+092
+093 \{
+094 register mp_digit *tmpc;
+095
+096 /* At this point W[] contains the sums of each column. To get the
+097 * correct result we must take the extra bits from each column and
+098 * carry them down
+099 *
+100 * Note that while this adds extra code to the multiplier it
+101 * saves time since the carry propagation is removed from the
+102 * above nested loop.This has the effect of reducing the work
+103 * from N*(N+N*c)==N**2 + c*N**2 to N**2 + N*c where c is the
+104 * cost of the shifting. On very small numbers this is slower
+105 * but on most cryptographic size numbers it is faster.
+106 *
+107 * In this particular implementation we feed the carries from
+108 * behind which means when the loop terminates we still have one
+109 * last digit to copy
+110 */
+111 tmpc = c->dp;
+112 for (ix = 1; ix < digs; ix++) \{
+113 /* forward the carry from the previous temp */
+114 W[ix] += (W[ix - 1] >> ((mp_word) DIGIT_BIT));
+115
+116 /* now extract the previous digit [below the carry] */
+117 *tmpc++ = (mp_digit) (W[ix - 1] & ((mp_word) MP_MASK));
+118 \}
+119 /* fetch the last digit */
+120 *tmpc++ = (mp_digit) (W[digs - 1] & ((mp_word) MP_MASK));
+121
+122 /* clear unused digits [that existed in the old copy of c] */
+123 for (; ix < olduse; ix++) \{
+124 *tmpc++ = 0;
+125 \}
+126 \}
+127 mp_clamp (c);
+128 return MP_OKAY;
+129 \}
\end{alltt}
\end{small}
-The memset on line 47 clears the initial $\hat W$ array to zero in a single step. Like the slower baseline multiplication
-implementation a series of aliases (\textit{lines 67, 70 and 75}) are used to simplify the inner $O(n^2)$ loop.
+The memset on line 46 clears the initial $\hat W$ array to zero in a single step. Like the slower baseline multiplication
+implementation a series of aliases (\textit{lines 66, 69 and 74}) are used to simplify the inner $O(n^2)$ loop.
In this case a new alias $\_\hat W$ has been added which refers to the double precision columns offset by $ix$ in each pass.
-The inner loop on lines 83, 84 and 85 is where the algorithm will spend the majority of the time, which is why it has been
+The inner loop on lines 82, 83 and 85 is where the algorithm will spend the majority of the time, which is why it has been
stripped to the bones of any extra baggage\footnote{Hence the pointer aliases.}. On x86 processors the multiplication and additions amount to at the
very least five instructions (\textit{two loads, two additions, one multiply}) while on the ARMv4 processors they amount to only three
(\textit{one load, one store, one multiply-add}). For both of the x86 and ARMv4 processors the GCC compiler performs a good job at unrolling the loop
@@ -4105,161 +4115,157 @@ The remaining steps 13 through 18 compute the Karatsuba polynomial through a var
\hspace{-5.1mm}{\bf File}: bn\_mp\_karatsuba\_mul.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* c = |a| * |b| using Karatsuba Multiplication using
-018 * three half size multiplications
-019 *
-020 * Let B represent the radix [e.g. 2**DIGIT_BIT] and
-021 * let n represent half of the number of digits in
-022 * the min(a,b)
-023 *
-024 * a = a1 * B**n + a0
-025 * b = b1 * B**n + b0
-026 *
-027 * Then, a * b =>
-028 a1b1 * B**2n + ((a1 - a0)(b1 - b0) + a0b0 + a1b1) * B + a0b0
-029 *
-030 * Note that a1b1 and a0b0 are used twice and only need to be
-031 * computed once. So in total three half size (half # of
-032 * digit) multiplications are performed, a0b0, a1b1 and
-033 * (a1-b1)(a0-b0)
-034 *
-035 * Note that a multiplication of half the digits requires
-036 * 1/4th the number of single precision multiplications so in
-037 * total after one call 25% of the single precision multiplications
-038 * are saved. Note also that the call to mp_mul can end up back
-039 * in this function if the a0, a1, b0, or b1 are above the threshold.
-040 * This is known as divide-and-conquer and leads to the famous
-041 * O(N**lg(3)) or O(N**1.584) work which is asymptopically lower than
-042 * the standard O(N**2) that the baseline/comba methods use.
-043 * Generally though the overhead of this method doesn't pay off
-044 * until a certain size (N ~ 80) is reached.
-045 */
-046 int mp_karatsuba_mul (mp_int * a, mp_int * b, mp_int * c)
-047 \{
-048 mp_int x0, x1, y0, y1, t1, x0y0, x1y1;
-049 int B, err;
-050
-051 /* default the return code to an error */
-052 err = MP_MEM;
-053
-054 /* min # of digits */
-055 B = MIN (a->used, b->used);
-056
-057 /* now divide in two */
-058 B = B >> 1;
-059
-060 /* init copy all the temps */
-061 if (mp_init_size (&x0, B) != MP_OKAY)
-062 goto ERR;
-063 if (mp_init_size (&x1, a->used - B) != MP_OKAY)
-064 goto X0;
-065 if (mp_init_size (&y0, B) != MP_OKAY)
-066 goto X1;
-067 if (mp_init_size (&y1, b->used - B) != MP_OKAY)
-068 goto Y0;
-069
-070 /* init temps */
-071 if (mp_init_size (&t1, B * 2) != MP_OKAY)
-072 goto Y1;
-073 if (mp_init_size (&x0y0, B * 2) != MP_OKAY)
-074 goto T1;
-075 if (mp_init_size (&x1y1, B * 2) != MP_OKAY)
-076 goto X0Y0;
-077
-078 /* now shift the digits */
-079 x0.sign = x1.sign = a->sign;
-080 y0.sign = y1.sign = b->sign;
+016 /* c = |a| * |b| using Karatsuba Multiplication using
+017 * three half size multiplications
+018 *
+019 * Let B represent the radix [e.g. 2**DIGIT_BIT] and
+020 * let n represent half of the number of digits in
+021 * the min(a,b)
+022 *
+023 * a = a1 * B**n + a0
+024 * b = b1 * B**n + b0
+025 *
+026 * Then, a * b =>
+027 a1b1 * B**2n + ((a1 - a0)(b1 - b0) + a0b0 + a1b1) * B + a0b0
+028 *
+029 * Note that a1b1 and a0b0 are used twice and only need to be
+030 * computed once. So in total three half size (half # of
+031 * digit) multiplications are performed, a0b0, a1b1 and
+032 * (a1-b1)(a0-b0)
+033 *
+034 * Note that a multiplication of half the digits requires
+035 * 1/4th the number of single precision multiplications so in
+036 * total after one call 25% of the single precision multiplications
+037 * are saved. Note also that the call to mp_mul can end up back
+038 * in this function if the a0, a1, b0, or b1 are above the threshold.
+039 * This is known as divide-and-conquer and leads to the famous
+040 * O(N**lg(3)) or O(N**1.584) work which is asymptopically lower than
+041 * the standard O(N**2) that the baseline/comba methods use.
+042 * Generally though the overhead of this method doesn't pay off
+043 * until a certain size (N ~ 80) is reached.
+044 */
+045 int mp_karatsuba_mul (mp_int * a, mp_int * b, mp_int * c)
+046 \{
+047 mp_int x0, x1, y0, y1, t1, x0y0, x1y1;
+048 int B, err;
+049
+050 /* default the return code to an error */
+051 err = MP_MEM;
+052
+053 /* min # of digits */
+054 B = MIN (a->used, b->used);
+055
+056 /* now divide in two */
+057 B = B >> 1;
+058
+059 /* init copy all the temps */
+060 if (mp_init_size (&x0, B) != MP_OKAY)
+061 goto ERR;
+062 if (mp_init_size (&x1, a->used - B) != MP_OKAY)
+063 goto X0;
+064 if (mp_init_size (&y0, B) != MP_OKAY)
+065 goto X1;
+066 if (mp_init_size (&y1, b->used - B) != MP_OKAY)
+067 goto Y0;
+068
+069 /* init temps */
+070 if (mp_init_size (&t1, B * 2) != MP_OKAY)
+071 goto Y1;
+072 if (mp_init_size (&x0y0, B * 2) != MP_OKAY)
+073 goto T1;
+074 if (mp_init_size (&x1y1, B * 2) != MP_OKAY)
+075 goto X0Y0;
+076
+077 /* now shift the digits */
+078 x0.used = y0.used = B;
+079 x1.used = a->used - B;
+080 y1.used = b->used - B;
081
-082 x0.used = y0.used = B;
-083 x1.used = a->used - B;
-084 y1.used = b->used - B;
+082 \{
+083 register int x;
+084 register mp_digit *tmpa, *tmpb, *tmpx, *tmpy;
085
-086 \{
-087 register int x;
-088 register mp_digit *tmpa, *tmpb, *tmpx, *tmpy;
-089
-090 /* we copy the digits directly instead of using higher level functions
-091 * since we also need to shift the digits
-092 */
-093 tmpa = a->dp;
-094 tmpb = b->dp;
-095
-096 tmpx = x0.dp;
-097 tmpy = y0.dp;
-098 for (x = 0; x < B; x++) \{
-099 *tmpx++ = *tmpa++;
-100 *tmpy++ = *tmpb++;
-101 \}
-102
-103 tmpx = x1.dp;
-104 for (x = B; x < a->used; x++) \{
-105 *tmpx++ = *tmpa++;
-106 \}
-107
-108 tmpy = y1.dp;
-109 for (x = B; x < b->used; x++) \{
-110 *tmpy++ = *tmpb++;
-111 \}
-112 \}
-113
-114 /* only need to clamp the lower words since by definition the
-115 * upper words x1/y1 must have a known number of digits
-116 */
-117 mp_clamp (&x0);
-118 mp_clamp (&y0);
-119
-120 /* now calc the products x0y0 and x1y1 */
-121 /* after this x0 is no longer required, free temp [x0==t2]! */
-122 if (mp_mul (&x0, &y0, &x0y0) != MP_OKAY)
-123 goto X1Y1; /* x0y0 = x0*y0 */
-124 if (mp_mul (&x1, &y1, &x1y1) != MP_OKAY)
-125 goto X1Y1; /* x1y1 = x1*y1 */
-126
-127 /* now calc x1-x0 and y1-y0 */
-128 if (mp_sub (&x1, &x0, &t1) != MP_OKAY)
-129 goto X1Y1; /* t1 = x1 - x0 */
-130 if (mp_sub (&y1, &y0, &x0) != MP_OKAY)
-131 goto X1Y1; /* t2 = y1 - y0 */
-132 if (mp_mul (&t1, &x0, &t1) != MP_OKAY)
-133 goto X1Y1; /* t1 = (x1 - x0) * (y1 - y0) */
-134
-135 /* add x0y0 */
-136 if (mp_add (&x0y0, &x1y1, &x0) != MP_OKAY)
-137 goto X1Y1; /* t2 = x0y0 + x1y1 */
-138 if (mp_sub (&x0, &t1, &t1) != MP_OKAY)
-139 goto X1Y1; /* t1 = x0y0 + x1y1 - (x1-x0)*(y1-y0) */
-140
-141 /* shift by B */
-142 if (mp_lshd (&t1, B) != MP_OKAY)
-143 goto X1Y1; /* t1 = (x0y0 + x1y1 - (x1-x0)*(y1-y0))<<B */
-144 if (mp_lshd (&x1y1, B * 2) != MP_OKAY)
-145 goto X1Y1; /* x1y1 = x1y1 << 2*B */
-146
-147 if (mp_add (&x0y0, &t1, &t1) != MP_OKAY)
-148 goto X1Y1; /* t1 = x0y0 + t1 */
-149 if (mp_add (&t1, &x1y1, c) != MP_OKAY)
-150 goto X1Y1; /* t1 = x0y0 + t1 + x1y1 */
-151
-152 /* Algorithm succeeded set the return code to MP_OKAY */
-153 err = MP_OKAY;
-154
-155 X1Y1:mp_clear (&x1y1);
-156 X0Y0:mp_clear (&x0y0);
-157 T1:mp_clear (&t1);
-158 Y1:mp_clear (&y1);
-159 Y0:mp_clear (&y0);
-160 X1:mp_clear (&x1);
-161 X0:mp_clear (&x0);
-162 ERR:
-163 return err;
-164 \}
+086 /* we copy the digits directly instead of using higher level functions
+087 * since we also need to shift the digits
+088 */
+089 tmpa = a->dp;
+090 tmpb = b->dp;
+091
+092 tmpx = x0.dp;
+093 tmpy = y0.dp;
+094 for (x = 0; x < B; x++) \{
+095 *tmpx++ = *tmpa++;
+096 *tmpy++ = *tmpb++;
+097 \}
+098
+099 tmpx = x1.dp;
+100 for (x = B; x < a->used; x++) \{
+101 *tmpx++ = *tmpa++;
+102 \}
+103
+104 tmpy = y1.dp;
+105 for (x = B; x < b->used; x++) \{
+106 *tmpy++ = *tmpb++;
+107 \}
+108 \}
+109
+110 /* only need to clamp the lower words since by definition the
+111 * upper words x1/y1 must have a known number of digits
+112 */
+113 mp_clamp (&x0);
+114 mp_clamp (&y0);
+115
+116 /* now calc the products x0y0 and x1y1 */
+117 /* after this x0 is no longer required, free temp [x0==t2]! */
+118 if (mp_mul (&x0, &y0, &x0y0) != MP_OKAY)
+119 goto X1Y1; /* x0y0 = x0*y0 */
+120 if (mp_mul (&x1, &y1, &x1y1) != MP_OKAY)
+121 goto X1Y1; /* x1y1 = x1*y1 */
+122
+123 /* now calc x1-x0 and y1-y0 */
+124 if (mp_sub (&x1, &x0, &t1) != MP_OKAY)
+125 goto X1Y1; /* t1 = x1 - x0 */
+126 if (mp_sub (&y1, &y0, &x0) != MP_OKAY)
+127 goto X1Y1; /* t2 = y1 - y0 */
+128 if (mp_mul (&t1, &x0, &t1) != MP_OKAY)
+129 goto X1Y1; /* t1 = (x1 - x0) * (y1 - y0) */
+130
+131 /* add x0y0 */
+132 if (mp_add (&x0y0, &x1y1, &x0) != MP_OKAY)
+133 goto X1Y1; /* t2 = x0y0 + x1y1 */
+134 if (mp_sub (&x0, &t1, &t1) != MP_OKAY)
+135 goto X1Y1; /* t1 = x0y0 + x1y1 - (x1-x0)*(y1-y0) */
+136
+137 /* shift by B */
+138 if (mp_lshd (&t1, B) != MP_OKAY)
+139 goto X1Y1; /* t1 = (x0y0 + x1y1 - (x1-x0)*(y1-y0))<<B */
+140 if (mp_lshd (&x1y1, B * 2) != MP_OKAY)
+141 goto X1Y1; /* x1y1 = x1y1 << 2*B */
+142
+143 if (mp_add (&x0y0, &t1, &t1) != MP_OKAY)
+144 goto X1Y1; /* t1 = x0y0 + t1 */
+145 if (mp_add (&t1, &x1y1, c) != MP_OKAY)
+146 goto X1Y1; /* t1 = x0y0 + t1 + x1y1 */
+147
+148 /* Algorithm succeeded set the return code to MP_OKAY */
+149 err = MP_OKAY;
+150
+151 X1Y1:mp_clear (&x1y1);
+152 X0Y0:mp_clear (&x0y0);
+153 T1:mp_clear (&t1);
+154 Y1:mp_clear (&y1);
+155 Y0:mp_clear (&y0);
+156 X1:mp_clear (&x1);
+157 X0:mp_clear (&x0);
+158 ERR:
+159 return err;
+160 \}
\end{alltt}
\end{small}
The new coding element in this routine, not seen in previous routines, is the usage of goto statements. The conventional
wisdom is that goto statements should be avoided. This is generally true, however when every single function call can fail, it makes sense
-to handle error recovery with a single piece of code. Lines 61 to 75 handle initializing all of the temporary variables
+to handle error recovery with a single piece of code. Lines 62 to 74 handle initializing all of the temporary variables
required. Note how each of the if statements goes to a different label in case of failure. This allows the routine to correctly free only
the temporaries that have been successfully allocated so far.
@@ -4269,13 +4275,13 @@ number of digits for the next section of code.
The first algebraic portion of the algorithm is to split the two inputs into their halves. However, instead of using mp\_mod\_2d and mp\_rshd
to extract the halves, the respective code has been placed inline within the body of the function. To initialize the halves, the \textbf{used} and
-\textbf{sign} members are copied first. The first for loop on line 98 copies the lower halves. Since they are both the same magnitude it
-is simpler to calculate both lower halves in a single loop. The for loop on lines 104 and 109 calculate the upper halves $x1$ and
+\textbf{sign} members are copied first. The first for loop on line 100 copies the lower halves. Since they are both the same magnitude it
+is simpler to calculate both lower halves in a single loop. The for loop on lines 105 and 105 calculate the upper halves $x1$ and
$y1$ respectively.
By inlining the calculation of the halves, the Karatsuba multiplier has a slightly lower overhead and can be used for smaller magnitude inputs.
-When line 153 is reached, the algorithm has completed succesfully. The ``error status'' variable $err$ is set to \textbf{MP\_OKAY} so that
+When line 149 is reached, the algorithm has completed succesfully. The ``error status'' variable $err$ is set to \textbf{MP\_OKAY} so that
the same code that handles errors can be used to clear the temporary variables and return.
\subsection{Toom-Cook $3$-Way Multiplication}
@@ -4393,270 +4399,269 @@ result $a \cdot b$ is produced.
\hspace{-5.1mm}{\bf File}: bn\_mp\_toom\_mul.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* multiplication using the Toom-Cook 3-way algorithm */
-018 int mp_toom_mul(mp_int *a, mp_int *b, mp_int *c)
-019 \{
-020 mp_int w0, w1, w2, w3, w4, tmp1, tmp2, a0, a1, a2, b0, b1, b2;
-021 int res, B;
-022
-023 /* init temps */
-024 if ((res = mp_init_multi(&w0, &w1, &w2, &w3, &w4,
-025 &a0, &a1, &a2, &b0, &b1,
-026 &b2, &tmp1, &tmp2, NULL)) != MP_OKAY) \{
-027 return res;
-028 \}
-029
-030 /* B */
-031 B = MIN(a->used, b->used) / 3;
-032
-033 /* a = a2 * B**2 + a1 * B + a0 */
-034 if ((res = mp_mod_2d(a, DIGIT_BIT * B, &a0)) != MP_OKAY) \{
-035 goto ERR;
-036 \}
-037
-038 if ((res = mp_copy(a, &a1)) != MP_OKAY) \{
-039 goto ERR;
-040 \}
-041 mp_rshd(&a1, B);
-042 mp_mod_2d(&a1, DIGIT_BIT * B, &a1);
-043
-044 if ((res = mp_copy(a, &a2)) != MP_OKAY) \{
-045 goto ERR;
-046 \}
-047 mp_rshd(&a2, B*2);
-048
-049 /* b = b2 * B**2 + b1 * B + b0 */
-050 if ((res = mp_mod_2d(b, DIGIT_BIT * B, &b0)) != MP_OKAY) \{
-051 goto ERR;
-052 \}
-053
-054 if ((res = mp_copy(b, &b1)) != MP_OKAY) \{
-055 goto ERR;
-056 \}
-057 mp_rshd(&b1, B);
-058 mp_mod_2d(&b1, DIGIT_BIT * B, &b1);
-059
-060 if ((res = mp_copy(b, &b2)) != MP_OKAY) \{
-061 goto ERR;
-062 \}
-063 mp_rshd(&b2, B*2);
-064
-065 /* w0 = a0*b0 */
-066 if ((res = mp_mul(&a0, &b0, &w0)) != MP_OKAY) \{
-067 goto ERR;
-068 \}
-069
-070 /* w4 = a2 * b2 */
-071 if ((res = mp_mul(&a2, &b2, &w4)) != MP_OKAY) \{
-072 goto ERR;
-073 \}
-074
-075 /* w1 = (a2 + 2(a1 + 2a0))(b2 + 2(b1 + 2b0)) */
-076 if ((res = mp_mul_2(&a0, &tmp1)) != MP_OKAY) \{
-077 goto ERR;
-078 \}
-079 if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) \{
-080 goto ERR;
-081 \}
-082 if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) \{
-083 goto ERR;
-084 \}
-085 if ((res = mp_add(&tmp1, &a2, &tmp1)) != MP_OKAY) \{
-086 goto ERR;
-087 \}
-088
-089 if ((res = mp_mul_2(&b0, &tmp2)) != MP_OKAY) \{
-090 goto ERR;
-091 \}
-092 if ((res = mp_add(&tmp2, &b1, &tmp2)) != MP_OKAY) \{
-093 goto ERR;
-094 \}
-095 if ((res = mp_mul_2(&tmp2, &tmp2)) != MP_OKAY) \{
-096 goto ERR;
-097 \}
-098 if ((res = mp_add(&tmp2, &b2, &tmp2)) != MP_OKAY) \{
-099 goto ERR;
-100 \}
-101
-102 if ((res = mp_mul(&tmp1, &tmp2, &w1)) != MP_OKAY) \{
-103 goto ERR;
-104 \}
-105
-106 /* w3 = (a0 + 2(a1 + 2a2))(b0 + 2(b1 + 2b2)) */
-107 if ((res = mp_mul_2(&a2, &tmp1)) != MP_OKAY) \{
-108 goto ERR;
-109 \}
-110 if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) \{
-111 goto ERR;
-112 \}
-113 if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) \{
-114 goto ERR;
-115 \}
-116 if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) \{
-117 goto ERR;
-118 \}
-119
-120 if ((res = mp_mul_2(&b2, &tmp2)) != MP_OKAY) \{
-121 goto ERR;
-122 \}
-123 if ((res = mp_add(&tmp2, &b1, &tmp2)) != MP_OKAY) \{
-124 goto ERR;
-125 \}
-126 if ((res = mp_mul_2(&tmp2, &tmp2)) != MP_OKAY) \{
-127 goto ERR;
-128 \}
-129 if ((res = mp_add(&tmp2, &b0, &tmp2)) != MP_OKAY) \{
-130 goto ERR;
-131 \}
-132
-133 if ((res = mp_mul(&tmp1, &tmp2, &w3)) != MP_OKAY) \{
-134 goto ERR;
-135 \}
-136
-137
-138 /* w2 = (a2 + a1 + a0)(b2 + b1 + b0) */
-139 if ((res = mp_add(&a2, &a1, &tmp1)) != MP_OKAY) \{
-140 goto ERR;
-141 \}
-142 if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) \{
-143 goto ERR;
-144 \}
-145 if ((res = mp_add(&b2, &b1, &tmp2)) != MP_OKAY) \{
-146 goto ERR;
-147 \}
-148 if ((res = mp_add(&tmp2, &b0, &tmp2)) != MP_OKAY) \{
-149 goto ERR;
-150 \}
-151 if ((res = mp_mul(&tmp1, &tmp2, &w2)) != MP_OKAY) \{
-152 goto ERR;
-153 \}
-154
-155 /* now solve the matrix
-156
-157 0 0 0 0 1
-158 1 2 4 8 16
-159 1 1 1 1 1
-160 16 8 4 2 1
-161 1 0 0 0 0
-162
-163 using 12 subtractions, 4 shifts,
-164 2 small divisions and 1 small multiplication
-165 */
-166
-167 /* r1 - r4 */
-168 if ((res = mp_sub(&w1, &w4, &w1)) != MP_OKAY) \{
-169 goto ERR;
-170 \}
-171 /* r3 - r0 */
-172 if ((res = mp_sub(&w3, &w0, &w3)) != MP_OKAY) \{
-173 goto ERR;
-174 \}
-175 /* r1/2 */
-176 if ((res = mp_div_2(&w1, &w1)) != MP_OKAY) \{
-177 goto ERR;
-178 \}
-179 /* r3/2 */
-180 if ((res = mp_div_2(&w3, &w3)) != MP_OKAY) \{
-181 goto ERR;
-182 \}
-183 /* r2 - r0 - r4 */
-184 if ((res = mp_sub(&w2, &w0, &w2)) != MP_OKAY) \{
-185 goto ERR;
-186 \}
-187 if ((res = mp_sub(&w2, &w4, &w2)) != MP_OKAY) \{
-188 goto ERR;
-189 \}
-190 /* r1 - r2 */
-191 if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) \{
-192 goto ERR;
-193 \}
-194 /* r3 - r2 */
-195 if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) \{
-196 goto ERR;
-197 \}
-198 /* r1 - 8r0 */
-199 if ((res = mp_mul_2d(&w0, 3, &tmp1)) != MP_OKAY) \{
-200 goto ERR;
-201 \}
-202 if ((res = mp_sub(&w1, &tmp1, &w1)) != MP_OKAY) \{
-203 goto ERR;
-204 \}
-205 /* r3 - 8r4 */
-206 if ((res = mp_mul_2d(&w4, 3, &tmp1)) != MP_OKAY) \{
-207 goto ERR;
-208 \}
-209 if ((res = mp_sub(&w3, &tmp1, &w3)) != MP_OKAY) \{
-210 goto ERR;
-211 \}
-212 /* 3r2 - r1 - r3 */
-213 if ((res = mp_mul_d(&w2, 3, &w2)) != MP_OKAY) \{
-214 goto ERR;
-215 \}
-216 if ((res = mp_sub(&w2, &w1, &w2)) != MP_OKAY) \{
-217 goto ERR;
-218 \}
-219 if ((res = mp_sub(&w2, &w3, &w2)) != MP_OKAY) \{
-220 goto ERR;
-221 \}
-222 /* r1 - r2 */
-223 if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) \{
-224 goto ERR;
-225 \}
-226 /* r3 - r2 */
-227 if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) \{
-228 goto ERR;
-229 \}
-230 /* r1/3 */
-231 if ((res = mp_div_3(&w1, &w1, NULL)) != MP_OKAY) \{
-232 goto ERR;
-233 \}
-234 /* r3/3 */
-235 if ((res = mp_div_3(&w3, &w3, NULL)) != MP_OKAY) \{
-236 goto ERR;
-237 \}
-238
-239 /* at this point shift W[n] by B*n */
-240 if ((res = mp_lshd(&w1, 1*B)) != MP_OKAY) \{
-241 goto ERR;
-242 \}
-243 if ((res = mp_lshd(&w2, 2*B)) != MP_OKAY) \{
-244 goto ERR;
-245 \}
-246 if ((res = mp_lshd(&w3, 3*B)) != MP_OKAY) \{
-247 goto ERR;
-248 \}
-249 if ((res = mp_lshd(&w4, 4*B)) != MP_OKAY) \{
-250 goto ERR;
-251 \}
-252
-253 if ((res = mp_add(&w0, &w1, c)) != MP_OKAY) \{
-254 goto ERR;
-255 \}
-256 if ((res = mp_add(&w2, &w3, &tmp1)) != MP_OKAY) \{
-257 goto ERR;
-258 \}
-259 if ((res = mp_add(&w4, &tmp1, &tmp1)) != MP_OKAY) \{
-260 goto ERR;
-261 \}
-262 if ((res = mp_add(&tmp1, c, c)) != MP_OKAY) \{
-263 goto ERR;
-264 \}
-265
-266 ERR:
-267 mp_clear_multi(&w0, &w1, &w2, &w3, &w4,
-268 &a0, &a1, &a2, &b0, &b1,
-269 &b2, &tmp1, &tmp2, NULL);
-270 return res;
-271 \}
-272
-\end{alltt}
-\end{small}
-
--- Comments to be added during editing phase.
-
-\subsection{Signed Multiplication}
-Now that algorithms to handle multiplications of every useful dimensions have been developed, a rather simple finishing touch is required. So far all
+016 /* multiplication using the Toom-Cook 3-way algorithm */
+017 int mp_toom_mul(mp_int *a, mp_int *b, mp_int *c)
+018 \{
+019 mp_int w0, w1, w2, w3, w4, tmp1, tmp2, a0, a1, a2, b0, b1, b2;
+020 int res, B;
+021
+022 /* init temps */
+023 if ((res = mp_init_multi(&w0, &w1, &w2, &w3, &w4,
+024 &a0, &a1, &a2, &b0, &b1,
+025 &b2, &tmp1, &tmp2, NULL)) != MP_OKAY) \{
+026 return res;
+027 \}
+028
+029 /* B */
+030 B = MIN(a->used, b->used) / 3;
+031
+032 /* a = a2 * B**2 + a1 * B + a0 */
+033 if ((res = mp_mod_2d(a, DIGIT_BIT * B, &a0)) != MP_OKAY) \{
+034 goto ERR;
+035 \}
+036
+037 if ((res = mp_copy(a, &a1)) != MP_OKAY) \{
+038 goto ERR;
+039 \}
+040 mp_rshd(&a1, B);
+041 mp_mod_2d(&a1, DIGIT_BIT * B, &a1);
+042
+043 if ((res = mp_copy(a, &a2)) != MP_OKAY) \{
+044 goto ERR;
+045 \}
+046 mp_rshd(&a2, B*2);
+047
+048 /* b = b2 * B**2 + b1 * B + b0 */
+049 if ((res = mp_mod_2d(b, DIGIT_BIT * B, &b0)) != MP_OKAY) \{
+050 goto ERR;
+051 \}
+052
+053 if ((res = mp_copy(b, &b1)) != MP_OKAY) \{
+054 goto ERR;
+055 \}
+056 mp_rshd(&b1, B);
+057 mp_mod_2d(&b1, DIGIT_BIT * B, &b1);
+058
+059 if ((res = mp_copy(b, &b2)) != MP_OKAY) \{
+060 goto ERR;
+061 \}
+062 mp_rshd(&b2, B*2);
+063
+064 /* w0 = a0*b0 */
+065 if ((res = mp_mul(&a0, &b0, &w0)) != MP_OKAY) \{
+066 goto ERR;
+067 \}
+068
+069 /* w4 = a2 * b2 */
+070 if ((res = mp_mul(&a2, &b2, &w4)) != MP_OKAY) \{
+071 goto ERR;
+072 \}
+073
+074 /* w1 = (a2 + 2(a1 + 2a0))(b2 + 2(b1 + 2b0)) */
+075 if ((res = mp_mul_2(&a0, &tmp1)) != MP_OKAY) \{
+076 goto ERR;
+077 \}
+078 if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) \{
+079 goto ERR;
+080 \}
+081 if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) \{
+082 goto ERR;
+083 \}
+084 if ((res = mp_add(&tmp1, &a2, &tmp1)) != MP_OKAY) \{
+085 goto ERR;
+086 \}
+087
+088 if ((res = mp_mul_2(&b0, &tmp2)) != MP_OKAY) \{
+089 goto ERR;
+090 \}
+091 if ((res = mp_add(&tmp2, &b1, &tmp2)) != MP_OKAY) \{
+092 goto ERR;
+093 \}
+094 if ((res = mp_mul_2(&tmp2, &tmp2)) != MP_OKAY) \{
+095 goto ERR;
+096 \}
+097 if ((res = mp_add(&tmp2, &b2, &tmp2)) != MP_OKAY) \{
+098 goto ERR;
+099 \}
+100
+101 if ((res = mp_mul(&tmp1, &tmp2, &w1)) != MP_OKAY) \{
+102 goto ERR;
+103 \}
+104
+105 /* w3 = (a0 + 2(a1 + 2a2))(b0 + 2(b1 + 2b2)) */
+106 if ((res = mp_mul_2(&a2, &tmp1)) != MP_OKAY) \{
+107 goto ERR;
+108 \}
+109 if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) \{
+110 goto ERR;
+111 \}
+112 if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) \{
+113 goto ERR;
+114 \}
+115 if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) \{
+116 goto ERR;
+117 \}
+118
+119 if ((res = mp_mul_2(&b2, &tmp2)) != MP_OKAY) \{
+120 goto ERR;
+121 \}
+122 if ((res = mp_add(&tmp2, &b1, &tmp2)) != MP_OKAY) \{
+123 goto ERR;
+124 \}
+125 if ((res = mp_mul_2(&tmp2, &tmp2)) != MP_OKAY) \{
+126 goto ERR;
+127 \}
+128 if ((res = mp_add(&tmp2, &b0, &tmp2)) != MP_OKAY) \{
+129 goto ERR;
+130 \}
+131
+132 if ((res = mp_mul(&tmp1, &tmp2, &w3)) != MP_OKAY) \{
+133 goto ERR;
+134 \}
+135
+136
+137 /* w2 = (a2 + a1 + a0)(b2 + b1 + b0) */
+138 if ((res = mp_add(&a2, &a1, &tmp1)) != MP_OKAY) \{
+139 goto ERR;
+140 \}
+141 if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) \{
+142 goto ERR;
+143 \}
+144 if ((res = mp_add(&b2, &b1, &tmp2)) != MP_OKAY) \{
+145 goto ERR;
+146 \}
+147 if ((res = mp_add(&tmp2, &b0, &tmp2)) != MP_OKAY) \{
+148 goto ERR;
+149 \}
+150 if ((res = mp_mul(&tmp1, &tmp2, &w2)) != MP_OKAY) \{
+151 goto ERR;
+152 \}
+153
+154 /* now solve the matrix
+155
+156 0 0 0 0 1
+157 1 2 4 8 16
+158 1 1 1 1 1
+159 16 8 4 2 1
+160 1 0 0 0 0
+161
+162 using 12 subtractions, 4 shifts,
+163 2 small divisions and 1 small multiplication
+164 */
+165
+166 /* r1 - r4 */
+167 if ((res = mp_sub(&w1, &w4, &w1)) != MP_OKAY) \{
+168 goto ERR;
+169 \}
+170 /* r3 - r0 */
+171 if ((res = mp_sub(&w3, &w0, &w3)) != MP_OKAY) \{
+172 goto ERR;
+173 \}
+174 /* r1/2 */
+175 if ((res = mp_div_2(&w1, &w1)) != MP_OKAY) \{
+176 goto ERR;
+177 \}
+178 /* r3/2 */
+179 if ((res = mp_div_2(&w3, &w3)) != MP_OKAY) \{
+180 goto ERR;
+181 \}
+182 /* r2 - r0 - r4 */
+183 if ((res = mp_sub(&w2, &w0, &w2)) != MP_OKAY) \{
+184 goto ERR;
+185 \}
+186 if ((res = mp_sub(&w2, &w4, &w2)) != MP_OKAY) \{
+187 goto ERR;
+188 \}
+189 /* r1 - r2 */
+190 if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) \{
+191 goto ERR;
+192 \}
+193 /* r3 - r2 */
+194 if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) \{
+195 goto ERR;
+196 \}
+197 /* r1 - 8r0 */
+198 if ((res = mp_mul_2d(&w0, 3, &tmp1)) != MP_OKAY) \{
+199 goto ERR;
+200 \}
+201 if ((res = mp_sub(&w1, &tmp1, &w1)) != MP_OKAY) \{
+202 goto ERR;
+203 \}
+204 /* r3 - 8r4 */
+205 if ((res = mp_mul_2d(&w4, 3, &tmp1)) != MP_OKAY) \{
+206 goto ERR;
+207 \}
+208 if ((res = mp_sub(&w3, &tmp1, &w3)) != MP_OKAY) \{
+209 goto ERR;
+210 \}
+211 /* 3r2 - r1 - r3 */
+212 if ((res = mp_mul_d(&w2, 3, &w2)) != MP_OKAY) \{
+213 goto ERR;
+214 \}
+215 if ((res = mp_sub(&w2, &w1, &w2)) != MP_OKAY) \{
+216 goto ERR;
+217 \}
+218 if ((res = mp_sub(&w2, &w3, &w2)) != MP_OKAY) \{
+219 goto ERR;
+220 \}
+221 /* r1 - r2 */
+222 if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) \{
+223 goto ERR;
+224 \}
+225 /* r3 - r2 */
+226 if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) \{
+227 goto ERR;
+228 \}
+229 /* r1/3 */
+230 if ((res = mp_div_3(&w1, &w1, NULL)) != MP_OKAY) \{
+231 goto ERR;
+232 \}
+233 /* r3/3 */
+234 if ((res = mp_div_3(&w3, &w3, NULL)) != MP_OKAY) \{
+235 goto ERR;
+236 \}
+237
+238 /* at this point shift W[n] by B*n */
+239 if ((res = mp_lshd(&w1, 1*B)) != MP_OKAY) \{
+240 goto ERR;
+241 \}
+242 if ((res = mp_lshd(&w2, 2*B)) != MP_OKAY) \{
+243 goto ERR;
+244 \}
+245 if ((res = mp_lshd(&w3, 3*B)) != MP_OKAY) \{
+246 goto ERR;
+247 \}
+248 if ((res = mp_lshd(&w4, 4*B)) != MP_OKAY) \{
+249 goto ERR;
+250 \}
+251
+252 if ((res = mp_add(&w0, &w1, c)) != MP_OKAY) \{
+253 goto ERR;
+254 \}
+255 if ((res = mp_add(&w2, &w3, &tmp1)) != MP_OKAY) \{
+256 goto ERR;
+257 \}
+258 if ((res = mp_add(&w4, &tmp1, &tmp1)) != MP_OKAY) \{
+259 goto ERR;
+260 \}
+261 if ((res = mp_add(&tmp1, c, c)) != MP_OKAY) \{
+262 goto ERR;
+263 \}
+264
+265 ERR:
+266 mp_clear_multi(&w0, &w1, &w2, &w3, &w4,
+267 &a0, &a1, &a2, &b0, &b1,
+268 &b2, &tmp1, &tmp2, NULL);
+269 return res;
+270 \}
+271
+\end{alltt}
+\end{small}
+
+-- Comments to be added during editing phase.
+
+\subsection{Signed Multiplication}
+Now that algorithms to handle multiplications of every useful dimensions have been developed, a rather simple finishing touch is required. So far all
of the multiplication algorithms have been unsigned multiplications which leaves only a signed multiplication algorithm to be established.
\newpage\begin{figure}[!here]
@@ -4699,44 +4704,43 @@ s\_mp\_mul\_digs will clear it.
\hspace{-5.1mm}{\bf File}: bn\_mp\_mul.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* high level multiplication (handles sign) */
-018 int mp_mul (mp_int * a, mp_int * b, mp_int * c)
-019 \{
-020 int res, neg;
-021 neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
-022
-023 /* use Toom-Cook? */
-024 if (MIN (a->used, b->used) >= TOOM_MUL_CUTOFF) \{
-025 res = mp_toom_mul(a, b, c);
-026 /* use Karatsuba? */
-027 \} else if (MIN (a->used, b->used) >= KARATSUBA_MUL_CUTOFF) \{
-028 res = mp_karatsuba_mul (a, b, c);
-029 \} else \{
-030 /* can we use the fast multiplier?
-031 *
-032 * The fast multiplier can be used if the output will
-033 * have less than MP_WARRAY digits and the number of
-034 * digits won't affect carry propagation
-035 */
-036 int digs = a->used + b->used + 1;
-037
-038 if ((digs < MP_WARRAY) &&
-039 MIN(a->used, b->used) <=
-040 (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) \{
-041 res = fast_s_mp_mul_digs (a, b, c, digs);
-042 \} else \{
-043 res = s_mp_mul (a, b, c);
-044 \}
-045 \}
-046 c->sign = neg;
-047 return res;
-048 \}
+016 /* high level multiplication (handles sign) */
+017 int mp_mul (mp_int * a, mp_int * b, mp_int * c)
+018 \{
+019 int res, neg;
+020 neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
+021
+022 /* use Toom-Cook? */
+023 if (MIN (a->used, b->used) >= TOOM_MUL_CUTOFF) \{
+024 res = mp_toom_mul(a, b, c);
+025 /* use Karatsuba? */
+026 \} else if (MIN (a->used, b->used) >= KARATSUBA_MUL_CUTOFF) \{
+027 res = mp_karatsuba_mul (a, b, c);
+028 \} else \{
+029 /* can we use the fast multiplier?
+030 *
+031 * The fast multiplier can be used if the output will
+032 * have less than MP_WARRAY digits and the number of
+033 * digits won't affect carry propagation
+034 */
+035 int digs = a->used + b->used + 1;
+036
+037 if ((digs < MP_WARRAY) &&
+038 MIN(a->used, b->used) <=
+039 (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) \{
+040 res = fast_s_mp_mul_digs (a, b, c, digs);
+041 \} else \{
+042 res = s_mp_mul (a, b, c);
+043 \}
+044 \}
+045 c->sign = (c->used > 0) ? neg : MP_ZPOS;
+046 return res;
+047 \}
\end{alltt}
\end{small}
-The implementation is rather simplistic and is not particularly noteworthy. Line 23 computes the sign of the result using the ``?''
-operator from the C programming language. Line 40 computes $\delta$ using the fact that $1 << k$ is equal to $2^k$.
+The implementation is rather simplistic and is not particularly noteworthy. Line 22 computes the sign of the result using the ``?''
+operator from the C programming language. Line 39 computes $\delta$ using the fact that $1 << k$ is equal to $2^k$.
\section{Squaring}
\label{sec:basesquare}
@@ -4837,76 +4841,75 @@ results calculated so far. This involves expensive carry propagation which will
\hspace{-5.1mm}{\bf File}: bn\_s\_mp\_sqr.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* low level squaring, b = a*a, HAC pp.596-597, Algorithm 14.16 */
-018 int
-019 s_mp_sqr (mp_int * a, mp_int * b)
-020 \{
-021 mp_int t;
-022 int res, ix, iy, pa;
-023 mp_word r;
-024 mp_digit u, tmpx, *tmpt;
-025
-026 pa = a->used;
-027 if ((res = mp_init_size (&t, 2*pa + 1)) != MP_OKAY) \{
-028 return res;
-029 \}
-030
-031 /* default used is maximum possible size */
-032 t.used = 2*pa + 1;
-033
-034 for (ix = 0; ix < pa; ix++) \{
-035 /* first calculate the digit at 2*ix */
-036 /* calculate double precision result */
-037 r = ((mp_word) t.dp[2*ix]) +
-038 ((mp_word)a->dp[ix])*((mp_word)a->dp[ix]);
-039
-040 /* store lower part in result */
-041 t.dp[ix+ix] = (mp_digit) (r & ((mp_word) MP_MASK));
-042
-043 /* get the carry */
-044 u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
-045
-046 /* left hand side of A[ix] * A[iy] */
-047 tmpx = a->dp[ix];
-048
-049 /* alias for where to store the results */
-050 tmpt = t.dp + (2*ix + 1);
-051
-052 for (iy = ix + 1; iy < pa; iy++) \{
-053 /* first calculate the product */
-054 r = ((mp_word)tmpx) * ((mp_word)a->dp[iy]);
-055
-056 /* now calculate the double precision result, note we use
-057 * addition instead of *2 since it's easier to optimize
-058 */
-059 r = ((mp_word) *tmpt) + r + r + ((mp_word) u);
-060
-061 /* store lower part */
-062 *tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK));
-063
-064 /* get carry */
-065 u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
-066 \}
-067 /* propagate upwards */
-068 while (u != ((mp_digit) 0)) \{
-069 r = ((mp_word) *tmpt) + ((mp_word) u);
-070 *tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK));
-071 u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
-072 \}
-073 \}
-074
-075 mp_clamp (&t);
-076 mp_exch (&t, b);
-077 mp_clear (&t);
-078 return MP_OKAY;
-079 \}
+016 /* low level squaring, b = a*a, HAC pp.596-597, Algorithm 14.16 */
+017 int
+018 s_mp_sqr (mp_int * a, mp_int * b)
+019 \{
+020 mp_int t;
+021 int res, ix, iy, pa;
+022 mp_word r;
+023 mp_digit u, tmpx, *tmpt;
+024
+025 pa = a->used;
+026 if ((res = mp_init_size (&t, 2*pa + 1)) != MP_OKAY) \{
+027 return res;
+028 \}
+029
+030 /* default used is maximum possible size */
+031 t.used = 2*pa + 1;
+032
+033 for (ix = 0; ix < pa; ix++) \{
+034 /* first calculate the digit at 2*ix */
+035 /* calculate double precision result */
+036 r = ((mp_word) t.dp[2*ix]) +
+037 ((mp_word)a->dp[ix])*((mp_word)a->dp[ix]);
+038
+039 /* store lower part in result */
+040 t.dp[ix+ix] = (mp_digit) (r & ((mp_word) MP_MASK));
+041
+042 /* get the carry */
+043 u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
+044
+045 /* left hand side of A[ix] * A[iy] */
+046 tmpx = a->dp[ix];
+047
+048 /* alias for where to store the results */
+049 tmpt = t.dp + (2*ix + 1);
+050
+051 for (iy = ix + 1; iy < pa; iy++) \{
+052 /* first calculate the product */
+053 r = ((mp_word)tmpx) * ((mp_word)a->dp[iy]);
+054
+055 /* now calculate the double precision result, note we use
+056 * addition instead of *2 since it's easier to optimize
+057 */
+058 r = ((mp_word) *tmpt) + r + r + ((mp_word) u);
+059
+060 /* store lower part */
+061 *tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK));
+062
+063 /* get carry */
+064 u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
+065 \}
+066 /* propagate upwards */
+067 while (u != ((mp_digit) 0)) \{
+068 r = ((mp_word) *tmpt) + ((mp_word) u);
+069 *tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK));
+070 u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
+071 \}
+072 \}
+073
+074 mp_clamp (&t);
+075 mp_exch (&t, b);
+076 mp_clear (&t);
+077 return MP_OKAY;
+078 \}
\end{alltt}
\end{small}
-Inside the outer loop (\textit{see line 34}) the square term is calculated on line 37. Line 44 extracts the carry from the square
-term. Aliases for $a_{ix}$ and $t_{ix+iy}$ are initialized on lines 47 and 50 respectively. The doubling is performed using two
-additions (\textit{see line 59}) since it is usually faster than shifting,if not at least as fast.
+Inside the outer loop (\textit{see line 33}) the square term is calculated on line 36. Line 43 extracts the carry from the square
+term. Aliases for $a_{ix}$ and $t_{ix+iy}$ are initialized on lines 46 and 49 respectively. The doubling is performed using two
+additions (\textit{see line 58}) since it is usually faster than shifting,if not at least as fast.
\subsection{Faster Squaring by the ``Comba'' Method}
A major drawback to the baseline method is the requirement for single precision shifting inside the $O(n^2)$ nested loop. Squaring has an additional
@@ -4985,130 +4988,129 @@ squares in place.
\hspace{-5.1mm}{\bf File}: bn\_fast\_s\_mp\_sqr.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* fast squaring
-018 *
-019 * This is the comba method where the columns of the product
-020 * are computed first then the carries are computed. This
-021 * has the effect of making a very simple inner loop that
-022 * is executed the most
-023 *
-024 * W2 represents the outer products and W the inner.
-025 *
-026 * A further optimizations is made because the inner
-027 * products are of the form "A * B * 2". The *2 part does
-028 * not need to be computed until the end which is good
-029 * because 64-bit shifts are slow!
-030 *
-031 * Based on Algorithm 14.16 on pp.597 of HAC.
-032 *
-033 */
-034 int fast_s_mp_sqr (mp_int * a, mp_int * b)
-035 \{
-036 int olduse, newused, res, ix, pa;
-037 mp_word W2[MP_WARRAY], W[MP_WARRAY];
-038
-039 /* calculate size of product and allocate as required */
-040 pa = a->used;
-041 newused = pa + pa + 1;
-042 if (b->alloc < newused) \{
-043 if ((res = mp_grow (b, newused)) != MP_OKAY) \{
-044 return res;
-045 \}
-046 \}
-047
-048 /* zero temp buffer (columns)
-049 * Note that there are two buffers. Since squaring requires
-050 * a outer and inner product and the inner product requires
-051 * computing a product and doubling it (a relatively expensive
-052 * op to perform n**2 times if you don't have to) the inner and
-053 * outer products are computed in different buffers. This way
-054 * the inner product can be doubled using n doublings instead of
-055 * n**2
-056 */
-057 memset (W, 0, newused * sizeof (mp_word));
-058 memset (W2, 0, newused * sizeof (mp_word));
-059
-060 /* This computes the inner product. To simplify the inner N**2 loop
-061 * the multiplication by two is done afterwards in the N loop.
-062 */
-063 for (ix = 0; ix < pa; ix++) \{
-064 /* compute the outer product
-065 *
-066 * Note that every outer product is computed
-067 * for a particular column only once which means that
-068 * there is no need todo a double precision addition
-069 * into the W2[] array.
-070 */
-071 W2[ix + ix] = ((mp_word)a->dp[ix]) * ((mp_word)a->dp[ix]);
-072
-073 \{
-074 register mp_digit tmpx, *tmpy;
-075 register mp_word *_W;
-076 register int iy;
-077
-078 /* copy of left side */
-079 tmpx = a->dp[ix];
-080
-081 /* alias for right side */
-082 tmpy = a->dp + (ix + 1);
-083
-084 /* the column to store the result in */
-085 _W = W + (ix + ix + 1);
-086
-087 /* inner products */
-088 for (iy = ix + 1; iy < pa; iy++) \{
-089 *_W++ += ((mp_word)tmpx) * ((mp_word)*tmpy++);
-090 \}
-091 \}
-092 \}
-093
-094 /* setup dest */
-095 olduse = b->used;
-096 b->used = newused;
-097
-098 /* now compute digits
-099 *
-100 * We have to double the inner product sums, add in the
-101 * outer product sums, propagate carries and convert
-102 * to single precision.
-103 */
-104 \{
-105 register mp_digit *tmpb;
-106
-107 /* double first value, since the inner products are
-108 * half of what they should be
-109 */
-110 W[0] += W[0] + W2[0];
-111
-112 tmpb = b->dp;
-113 for (ix = 1; ix < newused; ix++) \{
-114 /* double/add next digit */
-115 W[ix] += W[ix] + W2[ix];
-116
-117 /* propagate carry forwards [from the previous digit] */
-118 W[ix] = W[ix] + (W[ix - 1] >> ((mp_word) DIGIT_BIT));
-119
-120 /* store the current digit now that the carry isn't
-121 * needed
-122 */
-123 *tmpb++ = (mp_digit) (W[ix - 1] & ((mp_word) MP_MASK));
-124 \}
-125 /* set the last value. Note even if the carry is zero
-126 * this is required since the next step will not zero
-127 * it if b originally had a value at b->dp[2*a.used]
-128 */
-129 *tmpb++ = (mp_digit) (W[(newused) - 1] & ((mp_word) MP_MASK));
-130
-131 /* clear high digits of b if there were any originally */
-132 for (; ix < olduse; ix++) \{
-133 *tmpb++ = 0;
-134 \}
-135 \}
-136
-137 mp_clamp (b);
-138 return MP_OKAY;
-139 \}
+016 /* fast squaring
+017 *
+018 * This is the comba method where the columns of the product
+019 * are computed first then the carries are computed. This
+020 * has the effect of making a very simple inner loop that
+021 * is executed the most
+022 *
+023 * W2 represents the outer products and W the inner.
+024 *
+025 * A further optimizations is made because the inner
+026 * products are of the form "A * B * 2". The *2 part does
+027 * not need to be computed until the end which is good
+028 * because 64-bit shifts are slow!
+029 *
+030 * Based on Algorithm 14.16 on pp.597 of HAC.
+031 *
+032 */
+033 int fast_s_mp_sqr (mp_int * a, mp_int * b)
+034 \{
+035 int olduse, newused, res, ix, pa;
+036 mp_word W2[MP_WARRAY], W[MP_WARRAY];
+037
+038 /* calculate size of product and allocate as required */
+039 pa = a->used;
+040 newused = pa + pa + 1;
+041 if (b->alloc < newused) \{
+042 if ((res = mp_grow (b, newused)) != MP_OKAY) \{
+043 return res;
+044 \}
+045 \}
+046
+047 /* zero temp buffer (columns)
+048 * Note that there are two buffers. Since squaring requires
+049 * a outer and inner product and the inner product requires
+050 * computing a product and doubling it (a relatively expensive
+051 * op to perform n**2 times if you don't have to) the inner and
+052 * outer products are computed in different buffers. This way
+053 * the inner product can be doubled using n doublings instead of
+054 * n**2
+055 */
+056 memset (W, 0, newused * sizeof (mp_word));
+057 memset (W2, 0, newused * sizeof (mp_word));
+058
+059 /* This computes the inner product. To simplify the inner N**2 loop
+060 * the multiplication by two is done afterwards in the N loop.
+061 */
+062 for (ix = 0; ix < pa; ix++) \{
+063 /* compute the outer product
+064 *
+065 * Note that every outer product is computed
+066 * for a particular column only once which means that
+067 * there is no need todo a double precision addition
+068 * into the W2[] array.
+069 */
+070 W2[ix + ix] = ((mp_word)a->dp[ix]) * ((mp_word)a->dp[ix]);
+071
+072 \{
+073 register mp_digit tmpx, *tmpy;
+074 register mp_word *_W;
+075 register int iy;
+076
+077 /* copy of left side */
+078 tmpx = a->dp[ix];
+079
+080 /* alias for right side */
+081 tmpy = a->dp + (ix + 1);
+082
+083 /* the column to store the result in */
+084 _W = W + (ix + ix + 1);
+085
+086 /* inner products */
+087 for (iy = ix + 1; iy < pa; iy++) \{
+088 *_W++ += ((mp_word)tmpx) * ((mp_word)*tmpy++);
+089 \}
+090 \}
+091 \}
+092
+093 /* setup dest */
+094 olduse = b->used;
+095 b->used = newused;
+096
+097 /* now compute digits
+098 *
+099 * We have to double the inner product sums, add in the
+100 * outer product sums, propagate carries and convert
+101 * to single precision.
+102 */
+103 \{
+104 register mp_digit *tmpb;
+105
+106 /* double first value, since the inner products are
+107 * half of what they should be
+108 */
+109 W[0] += W[0] + W2[0];
+110
+111 tmpb = b->dp;
+112 for (ix = 1; ix < newused; ix++) \{
+113 /* double/add next digit */
+114 W[ix] += W[ix] + W2[ix];
+115
+116 /* propagate carry forwards [from the previous digit] */
+117 W[ix] = W[ix] + (W[ix - 1] >> ((mp_word) DIGIT_BIT));
+118
+119 /* store the current digit now that the carry isn't
+120 * needed
+121 */
+122 *tmpb++ = (mp_digit) (W[ix - 1] & ((mp_word) MP_MASK));
+123 \}
+124 /* set the last value. Note even if the carry is zero
+125 * this is required since the next step will not zero
+126 * it if b originally had a value at b->dp[2*a.used]
+127 */
+128 *tmpb++ = (mp_digit) (W[(newused) - 1] & ((mp_word) MP_MASK));
+129
+130 /* clear high digits of b if there were any originally */
+131 for (; ix < olduse; ix++) \{
+132 *tmpb++ = 0;
+133 \}
+134 \}
+135
+136 mp_clamp (b);
+137 return MP_OKAY;
+138 \}
\end{alltt}
\end{small}
@@ -5217,111 +5219,110 @@ ratio of 1:7. } than simpler operations such as addition.
\hspace{-5.1mm}{\bf File}: bn\_mp\_karatsuba\_sqr.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* Karatsuba squaring, computes b = a*a using three
-018 * half size squarings
-019 *
-020 * See comments of mp_karatsuba_mul for details. It
-021 * is essentially the same algorithm but merely
-022 * tuned to perform recursive squarings.
-023 */
-024 int mp_karatsuba_sqr (mp_int * a, mp_int * b)
-025 \{
-026 mp_int x0, x1, t1, t2, x0x0, x1x1;
-027 int B, err;
-028
-029 err = MP_MEM;
-030
-031 /* min # of digits */
-032 B = a->used;
-033
-034 /* now divide in two */
-035 B = B >> 1;
-036
-037 /* init copy all the temps */
-038 if (mp_init_size (&x0, B) != MP_OKAY)
-039 goto ERR;
-040 if (mp_init_size (&x1, a->used - B) != MP_OKAY)
-041 goto X0;
-042
-043 /* init temps */
-044 if (mp_init_size (&t1, a->used * 2) != MP_OKAY)
-045 goto X1;
-046 if (mp_init_size (&t2, a->used * 2) != MP_OKAY)
-047 goto T1;
-048 if (mp_init_size (&x0x0, B * 2) != MP_OKAY)
-049 goto T2;
-050 if (mp_init_size (&x1x1, (a->used - B) * 2) != MP_OKAY)
-051 goto X0X0;
-052
-053 \{
-054 register int x;
-055 register mp_digit *dst, *src;
-056
-057 src = a->dp;
-058
-059 /* now shift the digits */
-060 dst = x0.dp;
-061 for (x = 0; x < B; x++) \{
-062 *dst++ = *src++;
-063 \}
-064
-065 dst = x1.dp;
-066 for (x = B; x < a->used; x++) \{
-067 *dst++ = *src++;
-068 \}
-069 \}
-070
-071 x0.used = B;
-072 x1.used = a->used - B;
-073
-074 mp_clamp (&x0);
-075
-076 /* now calc the products x0*x0 and x1*x1 */
-077 if (mp_sqr (&x0, &x0x0) != MP_OKAY)
-078 goto X1X1; /* x0x0 = x0*x0 */
-079 if (mp_sqr (&x1, &x1x1) != MP_OKAY)
-080 goto X1X1; /* x1x1 = x1*x1 */
-081
-082 /* now calc (x1-x0)**2 */
-083 if (mp_sub (&x1, &x0, &t1) != MP_OKAY)
-084 goto X1X1; /* t1 = x1 - x0 */
-085 if (mp_sqr (&t1, &t1) != MP_OKAY)
-086 goto X1X1; /* t1 = (x1 - x0) * (x1 - x0) */
-087
-088 /* add x0y0 */
-089 if (s_mp_add (&x0x0, &x1x1, &t2) != MP_OKAY)
-090 goto X1X1; /* t2 = x0x0 + x1x1 */
-091 if (mp_sub (&t2, &t1, &t1) != MP_OKAY)
-092 goto X1X1; /* t1 = x0x0 + x1x1 - (x1-x0)*(x1-x0) */
-093
-094 /* shift by B */
-095 if (mp_lshd (&t1, B) != MP_OKAY)
-096 goto X1X1; /* t1 = (x0x0 + x1x1 - (x1-x0)*(x1-x0))<<B */
-097 if (mp_lshd (&x1x1, B * 2) != MP_OKAY)
-098 goto X1X1; /* x1x1 = x1x1 << 2*B */
-099
-100 if (mp_add (&x0x0, &t1, &t1) != MP_OKAY)
-101 goto X1X1; /* t1 = x0x0 + t1 */
-102 if (mp_add (&t1, &x1x1, b) != MP_OKAY)
-103 goto X1X1; /* t1 = x0x0 + t1 + x1x1 */
-104
-105 err = MP_OKAY;
-106
-107 X1X1:mp_clear (&x1x1);
-108 X0X0:mp_clear (&x0x0);
-109 T2:mp_clear (&t2);
-110 T1:mp_clear (&t1);
-111 X1:mp_clear (&x1);
-112 X0:mp_clear (&x0);
-113 ERR:
-114 return err;
-115 \}
+016 /* Karatsuba squaring, computes b = a*a using three
+017 * half size squarings
+018 *
+019 * See comments of mp_karatsuba_mul for details. It
+020 * is essentially the same algorithm but merely
+021 * tuned to perform recursive squarings.
+022 */
+023 int mp_karatsuba_sqr (mp_int * a, mp_int * b)
+024 \{
+025 mp_int x0, x1, t1, t2, x0x0, x1x1;
+026 int B, err;
+027
+028 err = MP_MEM;
+029
+030 /* min # of digits */
+031 B = a->used;
+032
+033 /* now divide in two */
+034 B = B >> 1;
+035
+036 /* init copy all the temps */
+037 if (mp_init_size (&x0, B) != MP_OKAY)
+038 goto ERR;
+039 if (mp_init_size (&x1, a->used - B) != MP_OKAY)
+040 goto X0;
+041
+042 /* init temps */
+043 if (mp_init_size (&t1, a->used * 2) != MP_OKAY)
+044 goto X1;
+045 if (mp_init_size (&t2, a->used * 2) != MP_OKAY)
+046 goto T1;
+047 if (mp_init_size (&x0x0, B * 2) != MP_OKAY)
+048 goto T2;
+049 if (mp_init_size (&x1x1, (a->used - B) * 2) != MP_OKAY)
+050 goto X0X0;
+051
+052 \{
+053 register int x;
+054 register mp_digit *dst, *src;
+055
+056 src = a->dp;
+057
+058 /* now shift the digits */
+059 dst = x0.dp;
+060 for (x = 0; x < B; x++) \{
+061 *dst++ = *src++;
+062 \}
+063
+064 dst = x1.dp;
+065 for (x = B; x < a->used; x++) \{
+066 *dst++ = *src++;
+067 \}
+068 \}
+069
+070 x0.used = B;
+071 x1.used = a->used - B;
+072
+073 mp_clamp (&x0);
+074
+075 /* now calc the products x0*x0 and x1*x1 */
+076 if (mp_sqr (&x0, &x0x0) != MP_OKAY)
+077 goto X1X1; /* x0x0 = x0*x0 */
+078 if (mp_sqr (&x1, &x1x1) != MP_OKAY)
+079 goto X1X1; /* x1x1 = x1*x1 */
+080
+081 /* now calc (x1-x0)**2 */
+082 if (mp_sub (&x1, &x0, &t1) != MP_OKAY)
+083 goto X1X1; /* t1 = x1 - x0 */
+084 if (mp_sqr (&t1, &t1) != MP_OKAY)
+085 goto X1X1; /* t1 = (x1 - x0) * (x1 - x0) */
+086
+087 /* add x0y0 */
+088 if (s_mp_add (&x0x0, &x1x1, &t2) != MP_OKAY)
+089 goto X1X1; /* t2 = x0x0 + x1x1 */
+090 if (mp_sub (&t2, &t1, &t1) != MP_OKAY)
+091 goto X1X1; /* t1 = x0x0 + x1x1 - (x1-x0)*(x1-x0) */
+092
+093 /* shift by B */
+094 if (mp_lshd (&t1, B) != MP_OKAY)
+095 goto X1X1; /* t1 = (x0x0 + x1x1 - (x1-x0)*(x1-x0))<<B */
+096 if (mp_lshd (&x1x1, B * 2) != MP_OKAY)
+097 goto X1X1; /* x1x1 = x1x1 << 2*B */
+098
+099 if (mp_add (&x0x0, &t1, &t1) != MP_OKAY)
+100 goto X1X1; /* t1 = x0x0 + t1 */
+101 if (mp_add (&t1, &x1x1, b) != MP_OKAY)
+102 goto X1X1; /* t1 = x0x0 + t1 + x1x1 */
+103
+104 err = MP_OKAY;
+105
+106 X1X1:mp_clear (&x1x1);
+107 X0X0:mp_clear (&x0x0);
+108 T2:mp_clear (&t2);
+109 T1:mp_clear (&t1);
+110 X1:mp_clear (&x1);
+111 X0:mp_clear (&x0);
+112 ERR:
+113 return err;
+114 \}
\end{alltt}
\end{small}
This implementation is largely based on the implementation of algorithm mp\_karatsuba\_mul. It uses the same inline style to copy and
-shift the input into the two halves. The loop from line 53 to line 69 has been modified since only one input exists. The \textbf{used}
+shift the input into the two halves. The loop from line 52 to line 68 has been modified since only one input exists. The \textbf{used}
count of both $x0$ and $x1$ is fixed up and $x0$ is clamped before the calculations begin. At this point $x1$ and $x0$ are valid equivalents
to the respective halves as if mp\_rshd and mp\_mod\_2d had been used.
@@ -5376,32 +5377,31 @@ neither of the polynomial basis algorithms should be used then either the Comba
\hspace{-5.1mm}{\bf File}: bn\_mp\_sqr.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* computes b = a*a */
-018 int
-019 mp_sqr (mp_int * a, mp_int * b)
-020 \{
-021 int res;
-022
-023 /* use Toom-Cook? */
-024 if (a->used >= TOOM_SQR_CUTOFF) \{
-025 res = mp_toom_sqr(a, b);
-026 /* Karatsuba? */
-027 \} else if (a->used >= KARATSUBA_SQR_CUTOFF) \{
-028 res = mp_karatsuba_sqr (a, b);
-029 \} else \{
-030 /* can we use the fast comba multiplier? */
-031 if ((a->used * 2 + 1) < MP_WARRAY &&
-032 a->used <
-033 (1 << (sizeof(mp_word) * CHAR_BIT - 2*DIGIT_BIT - 1))) \{
-034 res = fast_s_mp_sqr (a, b);
-035 \} else \{
-036 res = s_mp_sqr (a, b);
-037 \}
-038 \}
-039 b->sign = MP_ZPOS;
-040 return res;
-041 \}
+016 /* computes b = a*a */
+017 int
+018 mp_sqr (mp_int * a, mp_int * b)
+019 \{
+020 int res;
+021
+022 /* use Toom-Cook? */
+023 if (a->used >= TOOM_SQR_CUTOFF) \{
+024 res = mp_toom_sqr(a, b);
+025 /* Karatsuba? */
+026 \} else if (a->used >= KARATSUBA_SQR_CUTOFF) \{
+027 res = mp_karatsuba_sqr (a, b);
+028 \} else \{
+029 /* can we use the fast comba multiplier? */
+030 if ((a->used * 2 + 1) < MP_WARRAY &&
+031 a->used <
+032 (1 << (sizeof(mp_word) * CHAR_BIT - 2*DIGIT_BIT - 1))) \{
+033 res = fast_s_mp_sqr (a, b);
+034 \} else \{
+035 res = s_mp_sqr (a, b);
+036 \}
+037 \}
+038 b->sign = MP_ZPOS;
+039 return res;
+040 \}
\end{alltt}
\end{small}
@@ -5650,81 +5650,80 @@ performed at most twice, and on average once. However, if $a \ge b^2$ than it wi
\hspace{-5.1mm}{\bf File}: bn\_mp\_reduce.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* reduces x mod m, assumes 0 < x < m**2, mu is
-018 * precomputed via mp_reduce_setup.
-019 * From HAC pp.604 Algorithm 14.42
-020 */
-021 int
-022 mp_reduce (mp_int * x, mp_int * m, mp_int * mu)
-023 \{
-024 mp_int q;
-025 int res, um = m->used;
-026
-027 /* q = x */
-028 if ((res = mp_init_copy (&q, x)) != MP_OKAY) \{
-029 return res;
-030 \}
-031
-032 /* q1 = x / b**(k-1) */
-033 mp_rshd (&q, um - 1);
-034
-035 /* according to HAC this optimization is ok */
-036 if (((unsigned long) um) > (((mp_digit)1) << (DIGIT_BIT - 1))) \{
-037 if ((res = mp_mul (&q, mu, &q)) != MP_OKAY) \{
-038 goto CLEANUP;
-039 \}
-040 \} else \{
-041 if ((res = s_mp_mul_high_digs (&q, mu, &q, um - 1)) != MP_OKAY) \{
-042 goto CLEANUP;
-043 \}
-044 \}
-045
-046 /* q3 = q2 / b**(k+1) */
-047 mp_rshd (&q, um + 1);
-048
-049 /* x = x mod b**(k+1), quick (no division) */
-050 if ((res = mp_mod_2d (x, DIGIT_BIT * (um + 1), x)) != MP_OKAY) \{
-051 goto CLEANUP;
-052 \}
-053
-054 /* q = q * m mod b**(k+1), quick (no division) */
-055 if ((res = s_mp_mul_digs (&q, m, &q, um + 1)) != MP_OKAY) \{
-056 goto CLEANUP;
-057 \}
-058
-059 /* x = x - q */
-060 if ((res = mp_sub (x, &q, x)) != MP_OKAY) \{
-061 goto CLEANUP;
-062 \}
-063
-064 /* If x < 0, add b**(k+1) to it */
-065 if (mp_cmp_d (x, 0) == MP_LT) \{
-066 mp_set (&q, 1);
-067 if ((res = mp_lshd (&q, um + 1)) != MP_OKAY)
-068 goto CLEANUP;
-069 if ((res = mp_add (x, &q, x)) != MP_OKAY)
-070 goto CLEANUP;
-071 \}
-072
-073 /* Back off if it's too big */
-074 while (mp_cmp (x, m) != MP_LT) \{
-075 if ((res = s_mp_sub (x, m, x)) != MP_OKAY) \{
-076 goto CLEANUP;
-077 \}
-078 \}
-079
-080 CLEANUP:
-081 mp_clear (&q);
-082
-083 return res;
-084 \}
+016 /* reduces x mod m, assumes 0 < x < m**2, mu is
+017 * precomputed via mp_reduce_setup.
+018 * From HAC pp.604 Algorithm 14.42
+019 */
+020 int
+021 mp_reduce (mp_int * x, mp_int * m, mp_int * mu)
+022 \{
+023 mp_int q;
+024 int res, um = m->used;
+025
+026 /* q = x */
+027 if ((res = mp_init_copy (&q, x)) != MP_OKAY) \{
+028 return res;
+029 \}
+030
+031 /* q1 = x / b**(k-1) */
+032 mp_rshd (&q, um - 1);
+033
+034 /* according to HAC this optimization is ok */
+035 if (((unsigned long) um) > (((mp_digit)1) << (DIGIT_BIT - 1))) \{
+036 if ((res = mp_mul (&q, mu, &q)) != MP_OKAY) \{
+037 goto CLEANUP;
+038 \}
+039 \} else \{
+040 if ((res = s_mp_mul_high_digs (&q, mu, &q, um - 1)) != MP_OKAY) \{
+041 goto CLEANUP;
+042 \}
+043 \}
+044
+045 /* q3 = q2 / b**(k+1) */
+046 mp_rshd (&q, um + 1);
+047
+048 /* x = x mod b**(k+1), quick (no division) */
+049 if ((res = mp_mod_2d (x, DIGIT_BIT * (um + 1), x)) != MP_OKAY) \{
+050 goto CLEANUP;
+051 \}
+052
+053 /* q = q * m mod b**(k+1), quick (no division) */
+054 if ((res = s_mp_mul_digs (&q, m, &q, um + 1)) != MP_OKAY) \{
+055 goto CLEANUP;
+056 \}
+057
+058 /* x = x - q */
+059 if ((res = mp_sub (x, &q, x)) != MP_OKAY) \{
+060 goto CLEANUP;
+061 \}
+062
+063 /* If x < 0, add b**(k+1) to it */
+064 if (mp_cmp_d (x, 0) == MP_LT) \{
+065 mp_set (&q, 1);
+066 if ((res = mp_lshd (&q, um + 1)) != MP_OKAY)
+067 goto CLEANUP;
+068 if ((res = mp_add (x, &q, x)) != MP_OKAY)
+069 goto CLEANUP;
+070 \}
+071
+072 /* Back off if it's too big */
+073 while (mp_cmp (x, m) != MP_LT) \{
+074 if ((res = s_mp_sub (x, m, x)) != MP_OKAY) \{
+075 goto CLEANUP;
+076 \}
+077 \}
+078
+079 CLEANUP:
+080 mp_clear (&q);
+081
+082 return res;
+083 \}
\end{alltt}
\end{small}
The first multiplication that determines the quotient can be performed by only producing the digits from $m - 1$ and up. This essentially halves
the number of single precision multiplications required. However, the optimization is only safe if $\beta$ is much larger than the number of digits
-in the modulus. In the source code this is evaluated on lines 36 to 44 where algorithm s\_mp\_mul\_high\_digs is used when it is
+in the modulus. In the source code this is evaluated on lines 36 to 43 where algorithm s\_mp\_mul\_high\_digs is used when it is
safe to do so.
\subsection{The Barrett Setup Algorithm}
@@ -5757,20 +5756,19 @@ is equivalent and much faster. The final value is computed by taking the intege
\hspace{-5.1mm}{\bf File}: bn\_mp\_reduce\_setup.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* pre-calculate the value required for Barrett reduction
-018 * For a given modulus "b" it calulates the value required in "a"
-019 */
-020 int
-021 mp_reduce_setup (mp_int * a, mp_int * b)
-022 \{
-023 int res;
-024
-025 if ((res = mp_2expt (a, b->used * 2 * DIGIT_BIT)) != MP_OKAY) \{
-026 return res;
-027 \}
-028 return mp_div (a, b, a, NULL);
-029 \}
+016 /* pre-calculate the value required for Barrett reduction
+017 * For a given modulus "b" it calulates the value required in "a"
+018 */
+019 int
+020 mp_reduce_setup (mp_int * a, mp_int * b)
+021 \{
+022 int res;
+023
+024 if ((res = mp_2expt (a, b->used * 2 * DIGIT_BIT)) != MP_OKAY) \{
+025 return res;
+026 \}
+027 return mp_div (a, b, a, NULL);
+028 \}
\end{alltt}
\end{small}
@@ -6028,108 +6026,107 @@ multiplications.
\hspace{-5.1mm}{\bf File}: bn\_mp\_montgomery\_reduce.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* computes xR**-1 == x (mod N) via Montgomery Reduction */
-018 int
-019 mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho)
-020 \{
-021 int ix, res, digs;
-022 mp_digit mu;
-023
-024 /* can the fast reduction [comba] method be used?
-025 *
-026 * Note that unlike in mp_mul you're safely allowed *less*
-027 * than the available columns [255 per default] since carries
-028 * are fixed up in the inner loop.
-029 */
-030 digs = n->used * 2 + 1;
-031 if ((digs < MP_WARRAY) &&
-032 n->used <
-033 (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) \{
-034 return fast_mp_montgomery_reduce (x, n, rho);
-035 \}
-036
-037 /* grow the input as required */
-038 if (x->alloc < digs) \{
-039 if ((res = mp_grow (x, digs)) != MP_OKAY) \{
-040 return res;
-041 \}
-042 \}
-043 x->used = digs;
-044
-045 for (ix = 0; ix < n->used; ix++) \{
-046 /* mu = ai * rho mod b
-047 *
-048 * The value of rho must be precalculated via
-049 * bn_mp_montgomery_setup() such that
-050 * it equals -1/n0 mod b this allows the
-051 * following inner loop to reduce the
-052 * input one digit at a time
-053 */
-054 mu = (mp_digit) (((mp_word)x->dp[ix]) * ((mp_word)rho) & MP_MASK);
-055
-056 /* a = a + mu * m * b**i */
-057 \{
-058 register int iy;
-059 register mp_digit *tmpn, *tmpx, u;
-060 register mp_word r;
-061
-062 /* alias for digits of the modulus */
-063 tmpn = n->dp;
-064
-065 /* alias for the digits of x [the input] */
-066 tmpx = x->dp + ix;
-067
-068 /* set the carry to zero */
-069 u = 0;
-070
-071 /* Multiply and add in place */
-072 for (iy = 0; iy < n->used; iy++) \{
-073 /* compute product and sum */
-074 r = ((mp_word)mu) * ((mp_word)*tmpn++) +
-075 ((mp_word) u) + ((mp_word) * tmpx);
-076
-077 /* get carry */
-078 u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
-079
-080 /* fix digit */
-081 *tmpx++ = (mp_digit)(r & ((mp_word) MP_MASK));
-082 \}
-083 /* At this point the ix'th digit of x should be zero */
+016 /* computes xR**-1 == x (mod N) via Montgomery Reduction */
+017 int
+018 mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho)
+019 \{
+020 int ix, res, digs;
+021 mp_digit mu;
+022
+023 /* can the fast reduction [comba] method be used?
+024 *
+025 * Note that unlike in mp_mul you're safely allowed *less*
+026 * than the available columns [255 per default] since carries
+027 * are fixed up in the inner loop.
+028 */
+029 digs = n->used * 2 + 1;
+030 if ((digs < MP_WARRAY) &&
+031 n->used <
+032 (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) \{
+033 return fast_mp_montgomery_reduce (x, n, rho);
+034 \}
+035
+036 /* grow the input as required */
+037 if (x->alloc < digs) \{
+038 if ((res = mp_grow (x, digs)) != MP_OKAY) \{
+039 return res;
+040 \}
+041 \}
+042 x->used = digs;
+043
+044 for (ix = 0; ix < n->used; ix++) \{
+045 /* mu = ai * rho mod b
+046 *
+047 * The value of rho must be precalculated via
+048 * bn_mp_montgomery_setup() such that
+049 * it equals -1/n0 mod b this allows the
+050 * following inner loop to reduce the
+051 * input one digit at a time
+052 */
+053 mu = (mp_digit) (((mp_word)x->dp[ix]) * ((mp_word)rho) & MP_MASK);
+054
+055 /* a = a + mu * m * b**i */
+056 \{
+057 register int iy;
+058 register mp_digit *tmpn, *tmpx, u;
+059 register mp_word r;
+060
+061 /* alias for digits of the modulus */
+062 tmpn = n->dp;
+063
+064 /* alias for the digits of x [the input] */
+065 tmpx = x->dp + ix;
+066
+067 /* set the carry to zero */
+068 u = 0;
+069
+070 /* Multiply and add in place */
+071 for (iy = 0; iy < n->used; iy++) \{
+072 /* compute product and sum */
+073 r = ((mp_word)mu) * ((mp_word)*tmpn++) +
+074 ((mp_word) u) + ((mp_word) * tmpx);
+075
+076 /* get carry */
+077 u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
+078
+079 /* fix digit */
+080 *tmpx++ = (mp_digit)(r & ((mp_word) MP_MASK));
+081 \}
+082 /* At this point the ix'th digit of x should be zero */
+083
084
-085
-086 /* propagate carries upwards as required*/
-087 while (u) \{
-088 *tmpx += u;
-089 u = *tmpx >> DIGIT_BIT;
-090 *tmpx++ &= MP_MASK;
-091 \}
-092 \}
-093 \}
-094
-095 /* at this point the n.used'th least
-096 * significant digits of x are all zero
-097 * which means we can shift x to the
-098 * right by n.used digits and the
-099 * residue is unchanged.
-100 */
-101
-102 /* x = x/b**n.used */
-103 mp_clamp(x);
-104 mp_rshd (x, n->used);
-105
-106 /* if x >= n then x = x - n */
-107 if (mp_cmp_mag (x, n) != MP_LT) \{
-108 return s_mp_sub (x, n, x);
-109 \}
-110
-111 return MP_OKAY;
-112 \}
+085 /* propagate carries upwards as required*/
+086 while (u) \{
+087 *tmpx += u;
+088 u = *tmpx >> DIGIT_BIT;
+089 *tmpx++ &= MP_MASK;
+090 \}
+091 \}
+092 \}
+093
+094 /* at this point the n.used'th least
+095 * significant digits of x are all zero
+096 * which means we can shift x to the
+097 * right by n.used digits and the
+098 * residue is unchanged.
+099 */
+100
+101 /* x = x/b**n.used */
+102 mp_clamp(x);
+103 mp_rshd (x, n->used);
+104
+105 /* if x >= n then x = x - n */
+106 if (mp_cmp_mag (x, n) != MP_LT) \{
+107 return s_mp_sub (x, n, x);
+108 \}
+109
+110 return MP_OKAY;
+111 \}
\end{alltt}
\end{small}
-This is the baseline implementation of the Montgomery reduction algorithm. Lines 30 to 35 determine if the Comba based
-routine can be used instead. Line 48 computes the value of $\mu$ for that particular iteration of the outer loop.
+This is the baseline implementation of the Montgomery reduction algorithm. Lines 30 to 34 determine if the Comba based
+routine can be used instead. Line 47 computes the value of $\mu$ for that particular iteration of the outer loop.
The multiplication $\mu n \beta^{ix}$ is performed in one step in the inner loop. The alias $tmpx$ refers to the $ix$'th digit of $x$ and
the alias $tmpn$ refers to the modulus $n$.
@@ -6217,169 +6214,168 @@ stored in the destination $x$.
\hspace{-5.1mm}{\bf File}: bn\_fast\_mp\_montgomery\_reduce.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* computes xR**-1 == x (mod N) via Montgomery Reduction
-018 *
-019 * This is an optimized implementation of mp_montgomery_reduce
-020 * which uses the comba method to quickly calculate the columns of the
-021 * reduction.
-022 *
-023 * Based on Algorithm 14.32 on pp.601 of HAC.
-024 */
-025 int
-026 fast_mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho)
-027 \{
-028 int ix, res, olduse;
-029 mp_word W[MP_WARRAY];
-030
-031 /* get old used count */
-032 olduse = x->used;
-033
-034 /* grow a as required */
-035 if (x->alloc < n->used + 1) \{
-036 if ((res = mp_grow (x, n->used + 1)) != MP_OKAY) \{
-037 return res;
-038 \}
-039 \}
-040
-041 /* first we have to get the digits of the input into
-042 * an array of double precision words W[...]
-043 */
-044 \{
-045 register mp_word *_W;
-046 register mp_digit *tmpx;
-047
-048 /* alias for the W[] array */
-049 _W = W;
-050
-051 /* alias for the digits of x*/
-052 tmpx = x->dp;
-053
-054 /* copy the digits of a into W[0..a->used-1] */
-055 for (ix = 0; ix < x->used; ix++) \{
-056 *_W++ = *tmpx++;
-057 \}
-058
-059 /* zero the high words of W[a->used..m->used*2] */
-060 for (; ix < n->used * 2 + 1; ix++) \{
-061 *_W++ = 0;
-062 \}
-063 \}
-064
-065 /* now we proceed to zero successive digits
-066 * from the least significant upwards
-067 */
-068 for (ix = 0; ix < n->used; ix++) \{
-069 /* mu = ai * m' mod b
-070 *
-071 * We avoid a double precision multiplication (which isn't required)
-072 * by casting the value down to a mp_digit. Note this requires
-073 * that W[ix-1] have the carry cleared (see after the inner loop)
-074 */
-075 register mp_digit mu;
-076 mu = (mp_digit) (((W[ix] & MP_MASK) * rho) & MP_MASK);
-077
-078 /* a = a + mu * m * b**i
-079 *
-080 * This is computed in place and on the fly. The multiplication
-081 * by b**i is handled by offseting which columns the results
-082 * are added to.
-083 *
-084 * Note the comba method normally doesn't handle carries in the
-085 * inner loop In this case we fix the carry from the previous
-086 * column since the Montgomery reduction requires digits of the
-087 * result (so far) [see above] to work. This is
-088 * handled by fixing up one carry after the inner loop. The
-089 * carry fixups are done in order so after these loops the
-090 * first m->used words of W[] have the carries fixed
-091 */
-092 \{
-093 register int iy;
-094 register mp_digit *tmpn;
-095 register mp_word *_W;
-096
-097 /* alias for the digits of the modulus */
-098 tmpn = n->dp;
-099
-100 /* Alias for the columns set by an offset of ix */
-101 _W = W + ix;
-102
-103 /* inner loop */
-104 for (iy = 0; iy < n->used; iy++) \{
-105 *_W++ += ((mp_word)mu) * ((mp_word)*tmpn++);
-106 \}
-107 \}
-108
-109 /* now fix carry for next digit, W[ix+1] */
-110 W[ix + 1] += W[ix] >> ((mp_word) DIGIT_BIT);
-111 \}
-112
-113 /* now we have to propagate the carries and
-114 * shift the words downward [all those least
-115 * significant digits we zeroed].
-116 */
-117 \{
-118 register mp_digit *tmpx;
-119 register mp_word *_W, *_W1;
-120
-121 /* nox fix rest of carries */
-122
-123 /* alias for current word */
-124 _W1 = W + ix;
-125
-126 /* alias for next word, where the carry goes */
-127 _W = W + ++ix;
-128
-129 for (; ix <= n->used * 2 + 1; ix++) \{
-130 *_W++ += *_W1++ >> ((mp_word) DIGIT_BIT);
-131 \}
-132
-133 /* copy out, A = A/b**n
-134 *
-135 * The result is A/b**n but instead of converting from an
-136 * array of mp_word to mp_digit than calling mp_rshd
-137 * we just copy them in the right order
-138 */
-139
-140 /* alias for destination word */
-141 tmpx = x->dp;
-142
-143 /* alias for shifted double precision result */
-144 _W = W + n->used;
-145
-146 for (ix = 0; ix < n->used + 1; ix++) \{
-147 *tmpx++ = (mp_digit)(*_W++ & ((mp_word) MP_MASK));
-148 \}
-149
-150 /* zero oldused digits, if the input a was larger than
-151 * m->used+1 we'll have to clear the digits
-152 */
-153 for (; ix < olduse; ix++) \{
-154 *tmpx++ = 0;
-155 \}
-156 \}
-157
-158 /* set the max used and clamp */
-159 x->used = n->used + 1;
-160 mp_clamp (x);
-161
-162 /* if A >= m then A = A - m */
-163 if (mp_cmp_mag (x, n) != MP_LT) \{
-164 return s_mp_sub (x, n, x);
-165 \}
-166 return MP_OKAY;
-167 \}
+016 /* computes xR**-1 == x (mod N) via Montgomery Reduction
+017 *
+018 * This is an optimized implementation of mp_montgomery_reduce
+019 * which uses the comba method to quickly calculate the columns of the
+020 * reduction.
+021 *
+022 * Based on Algorithm 14.32 on pp.601 of HAC.
+023 */
+024 int
+025 fast_mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho)
+026 \{
+027 int ix, res, olduse;
+028 mp_word W[MP_WARRAY];
+029
+030 /* get old used count */
+031 olduse = x->used;
+032
+033 /* grow a as required */
+034 if (x->alloc < n->used + 1) \{
+035 if ((res = mp_grow (x, n->used + 1)) != MP_OKAY) \{
+036 return res;
+037 \}
+038 \}
+039
+040 /* first we have to get the digits of the input into
+041 * an array of double precision words W[...]
+042 */
+043 \{
+044 register mp_word *_W;
+045 register mp_digit *tmpx;
+046
+047 /* alias for the W[] array */
+048 _W = W;
+049
+050 /* alias for the digits of x*/
+051 tmpx = x->dp;
+052
+053 /* copy the digits of a into W[0..a->used-1] */
+054 for (ix = 0; ix < x->used; ix++) \{
+055 *_W++ = *tmpx++;
+056 \}
+057
+058 /* zero the high words of W[a->used..m->used*2] */
+059 for (; ix < n->used * 2 + 1; ix++) \{
+060 *_W++ = 0;
+061 \}
+062 \}
+063
+064 /* now we proceed to zero successive digits
+065 * from the least significant upwards
+066 */
+067 for (ix = 0; ix < n->used; ix++) \{
+068 /* mu = ai * m' mod b
+069 *
+070 * We avoid a double precision multiplication (which isn't required)
+071 * by casting the value down to a mp_digit. Note this requires
+072 * that W[ix-1] have the carry cleared (see after the inner loop)
+073 */
+074 register mp_digit mu;
+075 mu = (mp_digit) (((W[ix] & MP_MASK) * rho) & MP_MASK);
+076
+077 /* a = a + mu * m * b**i
+078 *
+079 * This is computed in place and on the fly. The multiplication
+080 * by b**i is handled by offseting which columns the results
+081 * are added to.
+082 *
+083 * Note the comba method normally doesn't handle carries in the
+084 * inner loop In this case we fix the carry from the previous
+085 * column since the Montgomery reduction requires digits of the
+086 * result (so far) [see above] to work. This is
+087 * handled by fixing up one carry after the inner loop. The
+088 * carry fixups are done in order so after these loops the
+089 * first m->used words of W[] have the carries fixed
+090 */
+091 \{
+092 register int iy;
+093 register mp_digit *tmpn;
+094 register mp_word *_W;
+095
+096 /* alias for the digits of the modulus */
+097 tmpn = n->dp;
+098
+099 /* Alias for the columns set by an offset of ix */
+100 _W = W + ix;
+101
+102 /* inner loop */
+103 for (iy = 0; iy < n->used; iy++) \{
+104 *_W++ += ((mp_word)mu) * ((mp_word)*tmpn++);
+105 \}
+106 \}
+107
+108 /* now fix carry for next digit, W[ix+1] */
+109 W[ix + 1] += W[ix] >> ((mp_word) DIGIT_BIT);
+110 \}
+111
+112 /* now we have to propagate the carries and
+113 * shift the words downward [all those least
+114 * significant digits we zeroed].
+115 */
+116 \{
+117 register mp_digit *tmpx;
+118 register mp_word *_W, *_W1;
+119
+120 /* nox fix rest of carries */
+121
+122 /* alias for current word */
+123 _W1 = W + ix;
+124
+125 /* alias for next word, where the carry goes */
+126 _W = W + ++ix;
+127
+128 for (; ix <= n->used * 2 + 1; ix++) \{
+129 *_W++ += *_W1++ >> ((mp_word) DIGIT_BIT);
+130 \}
+131
+132 /* copy out, A = A/b**n
+133 *
+134 * The result is A/b**n but instead of converting from an
+135 * array of mp_word to mp_digit than calling mp_rshd
+136 * we just copy them in the right order
+137 */
+138
+139 /* alias for destination word */
+140 tmpx = x->dp;
+141
+142 /* alias for shifted double precision result */
+143 _W = W + n->used;
+144
+145 for (ix = 0; ix < n->used + 1; ix++) \{
+146 *tmpx++ = (mp_digit)(*_W++ & ((mp_word) MP_MASK));
+147 \}
+148
+149 /* zero oldused digits, if the input a was larger than
+150 * m->used+1 we'll have to clear the digits
+151 */
+152 for (; ix < olduse; ix++) \{
+153 *tmpx++ = 0;
+154 \}
+155 \}
+156
+157 /* set the max used and clamp */
+158 x->used = n->used + 1;
+159 mp_clamp (x);
+160
+161 /* if A >= m then A = A - m */
+162 if (mp_cmp_mag (x, n) != MP_LT) \{
+163 return s_mp_sub (x, n, x);
+164 \}
+165 return MP_OKAY;
+166 \}
\end{alltt}
\end{small}
-The $\hat W$ array is first filled with digits of $x$ on line 48 then the rest of the digits are zeroed on line 55. Both loops share
+The $\hat W$ array is first filled with digits of $x$ on line 50 then the rest of the digits are zeroed on line 54. Both loops share
the same alias variables to make the code easier to read.
The value of $\mu$ is calculated in an interesting fashion. First the value $\hat W_{ix}$ is reduced modulo $\beta$ and cast to a mp\_digit. This
-forces the compiler to use a single precision multiplication and prevents any concerns about loss of precision. Line 110 fixes the carry
+forces the compiler to use a single precision multiplication and prevents any concerns about loss of precision. Line 109 fixes the carry
for the next iteration of the loop by propagating the carry from $\hat W_{ix}$ to $\hat W_{ix+1}$.
-The for loop on line 109 propagates the rest of the carries upwards through the columns. The for loop on line 126 reduces the columns
+The for loop on line 108 propagates the rest of the carries upwards through the columns. The for loop on line 125 reduces the columns
modulo $\beta$ and shifts them $k$ places at the same time. The alias $\_ \hat W$ actually refers to the array $\hat W$ starting at the $n.used$'th
digit, that is $\_ \hat W_{t} = \hat W_{n.used + t}$.
@@ -6416,44 +6412,43 @@ to calculate $1/n_0$ when $\beta$ is a power of two.
\hspace{-5.1mm}{\bf File}: bn\_mp\_montgomery\_setup.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* setups the montgomery reduction stuff */
-018 int
-019 mp_montgomery_setup (mp_int * n, mp_digit * rho)
-020 \{
-021 mp_digit x, b;
-022
-023 /* fast inversion mod 2**k
-024 *
-025 * Based on the fact that
-026 *
-027 * XA = 1 (mod 2**n) => (X(2-XA)) A = 1 (mod 2**2n)
-028 * => 2*X*A - X*X*A*A = 1
-029 * => 2*(1) - (1) = 1
-030 */
-031 b = n->dp[0];
-032
-033 if ((b & 1) == 0) \{
-034 return MP_VAL;
-035 \}
-036
-037 x = (((b + 2) & 4) << 1) + b; /* here x*a==1 mod 2**4 */
-038 x *= 2 - b * x; /* here x*a==1 mod 2**8 */
-039 #if !defined(MP_8BIT)
-040 x *= 2 - b * x; /* here x*a==1 mod 2**16 */
-041 #endif
-042 #if defined(MP_64BIT) || !(defined(MP_8BIT) || defined(MP_16BIT))
-043 x *= 2 - b * x; /* here x*a==1 mod 2**32 */
-044 #endif
-045 #ifdef MP_64BIT
-046 x *= 2 - b * x; /* here x*a==1 mod 2**64 */
-047 #endif
-048
-049 /* rho = -1/m mod b */
-050 *rho = (((mp_digit) 1 << ((mp_digit) DIGIT_BIT)) - x) & MP_MASK;
-051
-052 return MP_OKAY;
-053 \}
+016 /* setups the montgomery reduction stuff */
+017 int
+018 mp_montgomery_setup (mp_int * n, mp_digit * rho)
+019 \{
+020 mp_digit x, b;
+021
+022 /* fast inversion mod 2**k
+023 *
+024 * Based on the fact that
+025 *
+026 * XA = 1 (mod 2**n) => (X(2-XA)) A = 1 (mod 2**2n)
+027 * => 2*X*A - X*X*A*A = 1
+028 * => 2*(1) - (1) = 1
+029 */
+030 b = n->dp[0];
+031
+032 if ((b & 1) == 0) \{
+033 return MP_VAL;
+034 \}
+035
+036 x = (((b + 2) & 4) << 1) + b; /* here x*a==1 mod 2**4 */
+037 x *= 2 - b * x; /* here x*a==1 mod 2**8 */
+038 #if !defined(MP_8BIT)
+039 x *= 2 - b * x; /* here x*a==1 mod 2**16 */
+040 #endif
+041 #if defined(MP_64BIT) || !(defined(MP_8BIT) || defined(MP_16BIT))
+042 x *= 2 - b * x; /* here x*a==1 mod 2**32 */
+043 #endif
+044 #ifdef MP_64BIT
+045 x *= 2 - b * x; /* here x*a==1 mod 2**64 */
+046 #endif
+047
+048 /* rho = -1/m mod b */
+049 *rho = (((mp_digit) 1 << ((mp_digit) DIGIT_BIT)) - x) & MP_MASK;
+050
+051 return MP_OKAY;
+052 \}
\end{alltt}
\end{small}
@@ -6646,95 +6641,94 @@ at step 3.
\hspace{-5.1mm}{\bf File}: bn\_mp\_dr\_reduce.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* reduce "x" in place modulo "n" using the Diminished Radix algorithm.
-018 *
-019 * Based on algorithm from the paper
-020 *
-021 * "Generating Efficient Primes for Discrete Log Cryptosystems"
-022 * Chae Hoon Lim, Pil Loong Lee,
-023 * POSTECH Information Research Laboratories
-024 *
-025 * The modulus must be of a special format [see manual]
-026 *
-027 * Has been modified to use algorithm 7.10 from the LTM book instead
-028 *
-029 * Input x must be in the range 0 <= x <= (n-1)**2
-030 */
-031 int
-032 mp_dr_reduce (mp_int * x, mp_int * n, mp_digit k)
-033 \{
-034 int err, i, m;
-035 mp_word r;
-036 mp_digit mu, *tmpx1, *tmpx2;
-037
-038 /* m = digits in modulus */
-039 m = n->used;
-040
-041 /* ensure that "x" has at least 2m digits */
-042 if (x->alloc < m + m) \{
-043 if ((err = mp_grow (x, m + m)) != MP_OKAY) \{
-044 return err;
-045 \}
-046 \}
-047
-048 /* top of loop, this is where the code resumes if
-049 * another reduction pass is required.
-050 */
-051 top:
-052 /* aliases for digits */
-053 /* alias for lower half of x */
-054 tmpx1 = x->dp;
-055
-056 /* alias for upper half of x, or x/B**m */
-057 tmpx2 = x->dp + m;
-058
-059 /* set carry to zero */
-060 mu = 0;
-061
-062 /* compute (x mod B**m) + k * [x/B**m] inline and inplace */
-063 for (i = 0; i < m; i++) \{
-064 r = ((mp_word)*tmpx2++) * ((mp_word)k) + *tmpx1 + mu;
-065 *tmpx1++ = (mp_digit)(r & MP_MASK);
-066 mu = (mp_digit)(r >> ((mp_word)DIGIT_BIT));
-067 \}
-068
-069 /* set final carry */
-070 *tmpx1++ = mu;
-071
-072 /* zero words above m */
-073 for (i = m + 1; i < x->used; i++) \{
-074 *tmpx1++ = 0;
-075 \}
-076
-077 /* clamp, sub and return */
-078 mp_clamp (x);
-079
-080 /* if x >= n then subtract and reduce again
-081 * Each successive "recursion" makes the input smaller and smaller.
-082 */
-083 if (mp_cmp_mag (x, n) != MP_LT) \{
-084 s_mp_sub(x, n, x);
-085 goto top;
-086 \}
-087 return MP_OKAY;
-088 \}
+016 /* reduce "x" in place modulo "n" using the Diminished Radix algorithm.
+017 *
+018 * Based on algorithm from the paper
+019 *
+020 * "Generating Efficient Primes for Discrete Log Cryptosystems"
+021 * Chae Hoon Lim, Pil Loong Lee,
+022 * POSTECH Information Research Laboratories
+023 *
+024 * The modulus must be of a special format [see manual]
+025 *
+026 * Has been modified to use algorithm 7.10 from the LTM book instead
+027 *
+028 * Input x must be in the range 0 <= x <= (n-1)**2
+029 */
+030 int
+031 mp_dr_reduce (mp_int * x, mp_int * n, mp_digit k)
+032 \{
+033 int err, i, m;
+034 mp_word r;
+035 mp_digit mu, *tmpx1, *tmpx2;
+036
+037 /* m = digits in modulus */
+038 m = n->used;
+039
+040 /* ensure that "x" has at least 2m digits */
+041 if (x->alloc < m + m) \{
+042 if ((err = mp_grow (x, m + m)) != MP_OKAY) \{
+043 return err;
+044 \}
+045 \}
+046
+047 /* top of loop, this is where the code resumes if
+048 * another reduction pass is required.
+049 */
+050 top:
+051 /* aliases for digits */
+052 /* alias for lower half of x */
+053 tmpx1 = x->dp;
+054
+055 /* alias for upper half of x, or x/B**m */
+056 tmpx2 = x->dp + m;
+057
+058 /* set carry to zero */
+059 mu = 0;
+060
+061 /* compute (x mod B**m) + k * [x/B**m] inline and inplace */
+062 for (i = 0; i < m; i++) \{
+063 r = ((mp_word)*tmpx2++) * ((mp_word)k) + *tmpx1 + mu;
+064 *tmpx1++ = (mp_digit)(r & MP_MASK);
+065 mu = (mp_digit)(r >> ((mp_word)DIGIT_BIT));
+066 \}
+067
+068 /* set final carry */
+069 *tmpx1++ = mu;
+070
+071 /* zero words above m */
+072 for (i = m + 1; i < x->used; i++) \{
+073 *tmpx1++ = 0;
+074 \}
+075
+076 /* clamp, sub and return */
+077 mp_clamp (x);
+078
+079 /* if x >= n then subtract and reduce again
+080 * Each successive "recursion" makes the input smaller and smaller.
+081 */
+082 if (mp_cmp_mag (x, n) != MP_LT) \{
+083 s_mp_sub(x, n, x);
+084 goto top;
+085 \}
+086 return MP_OKAY;
+087 \}
\end{alltt}
\end{small}
-The first step is to grow $x$ as required to $2m$ digits since the reduction is performed in place on $x$. The label on line 51 is where
+The first step is to grow $x$ as required to $2m$ digits since the reduction is performed in place on $x$. The label on line 50 is where
the algorithm will resume if further reduction passes are required. In theory it could be placed at the top of the function however, the size of
the modulus and question of whether $x$ is large enough are invariant after the first pass meaning that it would be a waste of time.
The aliases $tmpx1$ and $tmpx2$ refer to the digits of $x$ where the latter is offset by $m$ digits. By reading digits from $x$ offset by $m$ digits
-a division by $\beta^m$ can be simulated virtually for free. The loop on line 63 performs the bulk of the work (\textit{corresponds to step 4 of algorithm 7.11})
+a division by $\beta^m$ can be simulated virtually for free. The loop on line 62 performs the bulk of the work (\textit{corresponds to step 4 of algorithm 7.11})
in this algorithm.
-By line 70 the pointer $tmpx1$ points to the $m$'th digit of $x$ which is where the final carry will be placed. Similarly by line 73 the
+By line 69 the pointer $tmpx1$ points to the $m$'th digit of $x$ which is where the final carry will be placed. Similarly by line 72 the
same pointer will point to the $m+1$'th digit where the zeroes will be placed.
Since the algorithm is only valid if both $x$ and $n$ are greater than zero an unsigned comparison suffices to determine if another pass is required.
-With the same logic at line 84 the value of $x$ is known to be greater than or equal to $n$ meaning that an unsigned subtraction can be used
+With the same logic at line 83 the value of $x$ is known to be greater than or equal to $n$ meaning that an unsigned subtraction can be used
as well. Since the destination of the subtraction is the larger of the inputs the call to algorithm s\_mp\_sub cannot fail and the return code
does not need to be checked.
@@ -6762,17 +6756,16 @@ completeness.
\hspace{-5.1mm}{\bf File}: bn\_mp\_dr\_setup.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* determines the setup value */
-018 void mp_dr_setup(mp_int *a, mp_digit *d)
-019 \{
-020 /* the casts are required if DIGIT_BIT is one less than
-021 * the number of bits in a mp_digit [e.g. DIGIT_BIT==31]
-022 */
-023 *d = (mp_digit)((((mp_word)1) << ((mp_word)DIGIT_BIT)) -
-024 ((mp_word)a->dp[0]));
-025 \}
-026
+016 /* determines the setup value */
+017 void mp_dr_setup(mp_int *a, mp_digit *d)
+018 \{
+019 /* the casts are required if DIGIT_BIT is one less than
+020 * the number of bits in a mp_digit [e.g. DIGIT_BIT==31]
+021 */
+022 *d = (mp_digit)((((mp_word)1) << ((mp_word)DIGIT_BIT)) -
+023 ((mp_word)a->dp[0]));
+024 \}
+025
\end{alltt}
\end{small}
@@ -6808,28 +6801,27 @@ step 3 then $n$ must be of Diminished Radix form.
\hspace{-5.1mm}{\bf File}: bn\_mp\_dr\_is\_modulus.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* determines if a number is a valid DR modulus */
-018 int mp_dr_is_modulus(mp_int *a)
-019 \{
-020 int ix;
-021
-022 /* must be at least two digits */
-023 if (a->used < 2) \{
-024 return 0;
-025 \}
-026
-027 /* must be of the form b**k - a [a <= b] so all
-028 * but the first digit must be equal to -1 (mod b).
-029 */
-030 for (ix = 1; ix < a->used; ix++) \{
-031 if (a->dp[ix] != MP_MASK) \{
-032 return 0;
-033 \}
-034 \}
-035 return 1;
-036 \}
-037
+016 /* determines if a number is a valid DR modulus */
+017 int mp_dr_is_modulus(mp_int *a)
+018 \{
+019 int ix;
+020
+021 /* must be at least two digits */
+022 if (a->used < 2) \{
+023 return 0;
+024 \}
+025
+026 /* must be of the form b**k - a [a <= b] so all
+027 * but the first digit must be equal to -1 (mod b).
+028 */
+029 for (ix = 1; ix < a->used; ix++) \{
+030 if (a->dp[ix] != MP_MASK) \{
+031 return 0;
+032 \}
+033 \}
+034 return 1;
+035 \}
+036
\end{alltt}
\end{small}
@@ -6873,52 +6865,51 @@ shift which makes the algorithm fairly inexpensive to use.
\hspace{-5.1mm}{\bf File}: bn\_mp\_reduce\_2k.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* reduces a modulo n where n is of the form 2**p - d */
-018 int
-019 mp_reduce_2k(mp_int *a, mp_int *n, mp_digit d)
-020 \{
-021 mp_int q;
-022 int p, res;
-023
-024 if ((res = mp_init(&q)) != MP_OKAY) \{
-025 return res;
-026 \}
-027
-028 p = mp_count_bits(n);
-029 top:
-030 /* q = a/2**p, a = a mod 2**p */
-031 if ((res = mp_div_2d(a, p, &q, a)) != MP_OKAY) \{
-032 goto ERR;
-033 \}
-034
-035 if (d != 1) \{
-036 /* q = q * d */
-037 if ((res = mp_mul_d(&q, d, &q)) != MP_OKAY) \{
-038 goto ERR;
-039 \}
-040 \}
-041
-042 /* a = a + q */
-043 if ((res = s_mp_add(a, &q, a)) != MP_OKAY) \{
-044 goto ERR;
-045 \}
-046
-047 if (mp_cmp_mag(a, n) != MP_LT) \{
-048 s_mp_sub(a, n, a);
-049 goto top;
-050 \}
-051
-052 ERR:
-053 mp_clear(&q);
-054 return res;
-055 \}
-056
+016 /* reduces a modulo n where n is of the form 2**p - d */
+017 int
+018 mp_reduce_2k(mp_int *a, mp_int *n, mp_digit d)
+019 \{
+020 mp_int q;
+021 int p, res;
+022
+023 if ((res = mp_init(&q)) != MP_OKAY) \{
+024 return res;
+025 \}
+026
+027 p = mp_count_bits(n);
+028 top:
+029 /* q = a/2**p, a = a mod 2**p */
+030 if ((res = mp_div_2d(a, p, &q, a)) != MP_OKAY) \{
+031 goto ERR;
+032 \}
+033
+034 if (d != 1) \{
+035 /* q = q * d */
+036 if ((res = mp_mul_d(&q, d, &q)) != MP_OKAY) \{
+037 goto ERR;
+038 \}
+039 \}
+040
+041 /* a = a + q */
+042 if ((res = s_mp_add(a, &q, a)) != MP_OKAY) \{
+043 goto ERR;
+044 \}
+045
+046 if (mp_cmp_mag(a, n) != MP_LT) \{
+047 s_mp_sub(a, n, a);
+048 goto top;
+049 \}
+050
+051 ERR:
+052 mp_clear(&q);
+053 return res;
+054 \}
+055
\end{alltt}
\end{small}
The algorithm mp\_count\_bits calculates the number of bits in an mp\_int which is used to find the initial value of $p$. The call to mp\_div\_2d
-on line 31 calculates both the quotient $q$ and the remainder $a$ required. By doing both in a single function call the code size
+on line 30 calculates both the quotient $q$ and the remainder $a$ required. By doing both in a single function call the code size
is kept fairly small. The multiplication by $k$ is only performed if $k > 1$. This allows reductions modulo $2^p - 1$ to be performed without
any multiplications.
@@ -6956,33 +6947,32 @@ is sufficient to solve for $k$. Alternatively if $n$ has more than one digit th
\hspace{-5.1mm}{\bf File}: bn\_mp\_reduce\_2k\_setup.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* determines the setup value */
-018 int
-019 mp_reduce_2k_setup(mp_int *a, mp_digit *d)
-020 \{
-021 int res, p;
-022 mp_int tmp;
-023
-024 if ((res = mp_init(&tmp)) != MP_OKAY) \{
-025 return res;
-026 \}
-027
-028 p = mp_count_bits(a);
-029 if ((res = mp_2expt(&tmp, p)) != MP_OKAY) \{
-030 mp_clear(&tmp);
-031 return res;
-032 \}
-033
-034 if ((res = s_mp_sub(&tmp, a, &tmp)) != MP_OKAY) \{
-035 mp_clear(&tmp);
-036 return res;
-037 \}
-038
-039 *d = tmp.dp[0];
-040 mp_clear(&tmp);
-041 return MP_OKAY;
-042 \}
+016 /* determines the setup value */
+017 int
+018 mp_reduce_2k_setup(mp_int *a, mp_digit *d)
+019 \{
+020 int res, p;
+021 mp_int tmp;
+022
+023 if ((res = mp_init(&tmp)) != MP_OKAY) \{
+024 return res;
+025 \}
+026
+027 p = mp_count_bits(a);
+028 if ((res = mp_2expt(&tmp, p)) != MP_OKAY) \{
+029 mp_clear(&tmp);
+030 return res;
+031 \}
+032
+033 if ((res = s_mp_sub(&tmp, a, &tmp)) != MP_OKAY) \{
+034 mp_clear(&tmp);
+035 return res;
+036 \}
+037
+038 *d = tmp.dp[0];
+039 mp_clear(&tmp);
+040 return MP_OKAY;
+041 \}
\end{alltt}
\end{small}
@@ -7027,11 +7017,11 @@ This algorithm quickly determines if a modulus is of the form required for algor
\hspace{-5.1mm}{\bf File}: bn\_mp\_reduce\_is\_2k.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* determines if mp_reduce_2k can be used */
-018 int mp_reduce_is_2k(mp_int *a)
-019 \{
-020 int ix, iy, iz, iw;
+016 /* determines if mp_reduce_2k can be used */
+017 int mp_reduce_is_2k(mp_int *a)
+018 \{
+019 int ix, iy, iw;
+020 mp_digit iz;
021
022 if (a->used == 0) \{
023 return 0;
@@ -7048,7 +7038,7 @@ This algorithm quickly determines if a modulus is of the form required for algor
034 return 0;
035 \}
036 iz <<= 1;
-037 if (iz > (int)MP_MASK) \{
+037 if (iz > (mp_digit)MP_MASK) \{
038 ++iw;
039 iz = 1;
040 \}
@@ -7229,49 +7219,48 @@ iteration of the loop moves the bits of the exponent $b$ upwards to the most sig
\hspace{-5.1mm}{\bf File}: bn\_mp\_expt\_d.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* calculate c = a**b using a square-multiply algorithm */
-018 int mp_expt_d (mp_int * a, mp_digit b, mp_int * c)
-019 \{
-020 int res, x;
-021 mp_int g;
-022
-023 if ((res = mp_init_copy (&g, a)) != MP_OKAY) \{
-024 return res;
-025 \}
-026
-027 /* set initial result */
-028 mp_set (c, 1);
-029
-030 for (x = 0; x < (int) DIGIT_BIT; x++) \{
-031 /* square */
-032 if ((res = mp_sqr (c, c)) != MP_OKAY) \{
-033 mp_clear (&g);
-034 return res;
-035 \}
-036
-037 /* if the bit is set multiply */
-038 if ((b & (mp_digit) (((mp_digit)1) << (DIGIT_BIT - 1))) != 0) \{
-039 if ((res = mp_mul (c, &g, c)) != MP_OKAY) \{
-040 mp_clear (&g);
-041 return res;
-042 \}
-043 \}
-044
-045 /* shift to next bit */
-046 b <<= 1;
-047 \}
-048
-049 mp_clear (&g);
-050 return MP_OKAY;
-051 \}
+016 /* calculate c = a**b using a square-multiply algorithm */
+017 int mp_expt_d (mp_int * a, mp_digit b, mp_int * c)
+018 \{
+019 int res, x;
+020 mp_int g;
+021
+022 if ((res = mp_init_copy (&g, a)) != MP_OKAY) \{
+023 return res;
+024 \}
+025
+026 /* set initial result */
+027 mp_set (c, 1);
+028
+029 for (x = 0; x < (int) DIGIT_BIT; x++) \{
+030 /* square */
+031 if ((res = mp_sqr (c, c)) != MP_OKAY) \{
+032 mp_clear (&g);
+033 return res;
+034 \}
+035
+036 /* if the bit is set multiply */
+037 if ((b & (mp_digit) (((mp_digit)1) << (DIGIT_BIT - 1))) != 0) \{
+038 if ((res = mp_mul (c, &g, c)) != MP_OKAY) \{
+039 mp_clear (&g);
+040 return res;
+041 \}
+042 \}
+043
+044 /* shift to next bit */
+045 b <<= 1;
+046 \}
+047
+048 mp_clear (&g);
+049 return MP_OKAY;
+050 \}
\end{alltt}
\end{small}
-Line 28 sets the initial value of the result to $1$. Next the loop on line 30 steps through each bit of the exponent starting from
-the most significant down towards the least significant. The invariant squaring operation placed on line 32 is performed first. After
+Line 27 sets the initial value of the result to $1$. Next the loop on line 29 steps through each bit of the exponent starting from
+the most significant down towards the least significant. The invariant squaring operation placed on line 31 is performed first. After
the squaring the result $c$ is multiplied by the base $g$ if and only if the most significant bit of the exponent is set. The shift on line
-46 moves all of the bits of the exponent upwards towards the most significant location.
+45 moves all of the bits of the exponent upwards towards the most significant location.
\section{$k$-ary Exponentiation}
When calculating an exponentiation the most time consuming bottleneck is the multiplications which are in general a small factor
@@ -7453,78 +7442,77 @@ algorithm since their arguments are essentially the same (\textit{two mp\_ints a
\vspace{-3mm}
\begin{alltt}
016
-017
-018 /* this is a shell function that calls either the normal or Montgomery
-019 * exptmod functions. Originally the call to the montgomery code was
-020 * embedded in the normal function but that wasted alot of stack space
-021 * for nothing (since 99% of the time the Montgomery code would be called)
-022 */
-023 int mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
-024 \{
-025 int dr;
-026
-027 /* modulus P must be positive */
-028 if (P->sign == MP_NEG) \{
-029 return MP_VAL;
-030 \}
-031
-032 /* if exponent X is negative we have to recurse */
-033 if (X->sign == MP_NEG) \{
-034 mp_int tmpG, tmpX;
-035 int err;
-036
-037 /* first compute 1/G mod P */
-038 if ((err = mp_init(&tmpG)) != MP_OKAY) \{
-039 return err;
-040 \}
-041 if ((err = mp_invmod(G, P, &tmpG)) != MP_OKAY) \{
-042 mp_clear(&tmpG);
-043 return err;
-044 \}
-045
-046 /* now get |X| */
-047 if ((err = mp_init(&tmpX)) != MP_OKAY) \{
-048 mp_clear(&tmpG);
-049 return err;
-050 \}
-051 if ((err = mp_abs(X, &tmpX)) != MP_OKAY) \{
-052 mp_clear_multi(&tmpG, &tmpX, NULL);
-053 return err;
-054 \}
-055
-056 /* and now compute (1/G)**|X| instead of G**X [X < 0] */
-057 err = mp_exptmod(&tmpG, &tmpX, P, Y);
-058 mp_clear_multi(&tmpG, &tmpX, NULL);
-059 return err;
-060 \}
-061
-062 /* is it a DR modulus? */
-063 dr = mp_dr_is_modulus(P);
-064
-065 /* if not, is it a uDR modulus? */
-066 if (dr == 0) \{
-067 dr = mp_reduce_is_2k(P) << 1;
-068 \}
-069
-070 /* if the modulus is odd or dr != 0 use the fast method */
-071 if (mp_isodd (P) == 1 || dr != 0) \{
-072 return mp_exptmod_fast (G, X, P, Y, dr);
-073 \} else \{
-074 /* otherwise use the generic Barrett reduction technique */
-075 return s_mp_exptmod (G, X, P, Y);
-076 \}
-077 \}
-078
+017 /* this is a shell function that calls either the normal or Montgomery
+018 * exptmod functions. Originally the call to the montgomery code was
+019 * embedded in the normal function but that wasted alot of stack space
+020 * for nothing (since 99% of the time the Montgomery code would be called)
+021 */
+022 int mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
+023 \{
+024 int dr;
+025
+026 /* modulus P must be positive */
+027 if (P->sign == MP_NEG) \{
+028 return MP_VAL;
+029 \}
+030
+031 /* if exponent X is negative we have to recurse */
+032 if (X->sign == MP_NEG) \{
+033 mp_int tmpG, tmpX;
+034 int err;
+035
+036 /* first compute 1/G mod P */
+037 if ((err = mp_init(&tmpG)) != MP_OKAY) \{
+038 return err;
+039 \}
+040 if ((err = mp_invmod(G, P, &tmpG)) != MP_OKAY) \{
+041 mp_clear(&tmpG);
+042 return err;
+043 \}
+044
+045 /* now get |X| */
+046 if ((err = mp_init(&tmpX)) != MP_OKAY) \{
+047 mp_clear(&tmpG);
+048 return err;
+049 \}
+050 if ((err = mp_abs(X, &tmpX)) != MP_OKAY) \{
+051 mp_clear_multi(&tmpG, &tmpX, NULL);
+052 return err;
+053 \}
+054
+055 /* and now compute (1/G)**|X| instead of G**X [X < 0] */
+056 err = mp_exptmod(&tmpG, &tmpX, P, Y);
+057 mp_clear_multi(&tmpG, &tmpX, NULL);
+058 return err;
+059 \}
+060
+061 /* is it a DR modulus? */
+062 dr = mp_dr_is_modulus(P);
+063
+064 /* if not, is it a uDR modulus? */
+065 if (dr == 0) \{
+066 dr = mp_reduce_is_2k(P) << 1;
+067 \}
+068
+069 /* if the modulus is odd or dr != 0 use the fast method */
+070 if (mp_isodd (P) == 1 || dr != 0) \{
+071 return mp_exptmod_fast (G, X, P, Y, dr);
+072 \} else \{
+073 /* otherwise use the generic Barrett reduction technique */
+074 return s_mp_exptmod (G, X, P, Y);
+075 \}
+076 \}
+077
\end{alltt}
\end{small}
-In order to keep the algorithms in a known state the first step on line 28 is to reject any negative modulus as input. If the exponent is
+In order to keep the algorithms in a known state the first step on line 31 is to reject any negative modulus as input. If the exponent is
negative the algorithm tries to perform a modular exponentiation with the modular inverse of the base $G$. The temporary variable $tmpG$ is assigned
the modular inverse of $G$ and $tmpX$ is assigned the absolute value of $X$. The algorithm will recuse with these new values with a positive
exponent.
-If the exponent is positive the algorithm resumes the exponentiation. Line 63 determines if the modulus is of the restricted Diminished Radix
-form. If it is not line 67 attempts to determine if it is of a unrestricted Diminished Radix form. The integer $dr$ will take on one
+If the exponent is positive the algorithm resumes the exponentiation. Line 62 determines if the modulus is of the restricted Diminished Radix
+form. If it is not line 66 attempts to determine if it is of a unrestricted Diminished Radix form. The integer $dr$ will take on one
of three values.
\begin{enumerate}
@@ -7533,7 +7521,7 @@ of three values.
\item $dr = 2$ means that the modulus is of unrestricted Diminished Radix form.
\end{enumerate}
-Line 70 determines if the fast modular exponentiation algorithm can be used. It is allowed if $dr \ne 0$ or if the modulus is odd. Otherwise,
+Line 69 determines if the fast modular exponentiation algorithm can be used. It is allowed if $dr \ne 0$ or if the modulus is odd. Otherwise,
the slower s\_mp\_exptmod algorithm is used which uses Barrett reduction.
\subsection{Barrett Modular Exponentiation}
@@ -7694,236 +7682,235 @@ a Left-to-Right algorithm is used to process the remaining few bits.
\hspace{-5.1mm}{\bf File}: bn\_s\_mp\_exptmod.c
\vspace{-3mm}
\begin{alltt}
-016
-017 #ifdef MP_LOW_MEM
-018 #define TAB_SIZE 32
-019 #else
-020 #define TAB_SIZE 256
-021 #endif
-022
-023 int s_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
-024 \{
-025 mp_int M[TAB_SIZE], res, mu;
-026 mp_digit buf;
-027 int err, bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize;
-028
-029 /* find window size */
-030 x = mp_count_bits (X);
-031 if (x <= 7) \{
-032 winsize = 2;
-033 \} else if (x <= 36) \{
-034 winsize = 3;
-035 \} else if (x <= 140) \{
-036 winsize = 4;
-037 \} else if (x <= 450) \{
-038 winsize = 5;
-039 \} else if (x <= 1303) \{
-040 winsize = 6;
-041 \} else if (x <= 3529) \{
-042 winsize = 7;
-043 \} else \{
-044 winsize = 8;
-045 \}
-046
-047 #ifdef MP_LOW_MEM
-048 if (winsize > 5) \{
-049 winsize = 5;
-050 \}
-051 #endif
-052
-053 /* init M array */
-054 /* init first cell */
-055 if ((err = mp_init(&M[1])) != MP_OKAY) \{
-056 return err;
-057 \}
-058
-059 /* now init the second half of the array */
-060 for (x = 1<<(winsize-1); x < (1 << winsize); x++) \{
-061 if ((err = mp_init(&M[x])) != MP_OKAY) \{
-062 for (y = 1<<(winsize-1); y < x; y++) \{
-063 mp_clear (&M[y]);
-064 \}
-065 mp_clear(&M[1]);
-066 return err;
-067 \}
-068 \}
-069
-070 /* create mu, used for Barrett reduction */
-071 if ((err = mp_init (&mu)) != MP_OKAY) \{
-072 goto __M;
-073 \}
-074 if ((err = mp_reduce_setup (&mu, P)) != MP_OKAY) \{
-075 goto __MU;
-076 \}
-077
-078 /* create M table
-079 *
-080 * The M table contains powers of the base,
-081 * e.g. M[x] = G**x mod P
-082 *
-083 * The first half of the table is not
-084 * computed though accept for M[0] and M[1]
-085 */
-086 if ((err = mp_mod (G, P, &M[1])) != MP_OKAY) \{
-087 goto __MU;
-088 \}
-089
-090 /* compute the value at M[1<<(winsize-1)] by squaring
-091 * M[1] (winsize-1) times
-092 */
-093 if ((err = mp_copy (&M[1], &M[1 << (winsize - 1)])) != MP_OKAY) \{
-094 goto __MU;
-095 \}
-096
-097 for (x = 0; x < (winsize - 1); x++) \{
-098 if ((err = mp_sqr (&M[1 << (winsize - 1)],
-099 &M[1 << (winsize - 1)])) != MP_OKAY) \{
-100 goto __MU;
-101 \}
-102 if ((err = mp_reduce (&M[1 << (winsize - 1)], P, &mu)) != MP_OKAY) \{
-103 goto __MU;
-104 \}
-105 \}
-106
-107 /* create upper table, that is M[x] = M[x-1] * M[1] (mod P)
-108 * for x = (2**(winsize - 1) + 1) to (2**winsize - 1)
-109 */
-110 for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) \{
-111 if ((err = mp_mul (&M[x - 1], &M[1], &M[x])) != MP_OKAY) \{
-112 goto __MU;
-113 \}
-114 if ((err = mp_reduce (&M[x], P, &mu)) != MP_OKAY) \{
-115 goto __MU;
-116 \}
-117 \}
-118
-119 /* setup result */
-120 if ((err = mp_init (&res)) != MP_OKAY) \{
-121 goto __MU;
-122 \}
-123 mp_set (&res, 1);
-124
-125 /* set initial mode and bit cnt */
-126 mode = 0;
-127 bitcnt = 1;
-128 buf = 0;
-129 digidx = X->used - 1;
-130 bitcpy = 0;
-131 bitbuf = 0;
-132
-133 for (;;) \{
-134 /* grab next digit as required */
-135 if (--bitcnt == 0) \{
-136 /* if digidx == -1 we are out of digits */
-137 if (digidx == -1) \{
-138 break;
-139 \}
-140 /* read next digit and reset the bitcnt */
-141 buf = X->dp[digidx--];
-142 bitcnt = (int) DIGIT_BIT;
-143 \}
-144
-145 /* grab the next msb from the exponent */
-146 y = (buf >> (mp_digit)(DIGIT_BIT - 1)) & 1;
-147 buf <<= (mp_digit)1;
-148
-149 /* if the bit is zero and mode == 0 then we ignore it
-150 * These represent the leading zero bits before the first 1 bit
-151 * in the exponent. Technically this opt is not required but it
-152 * does lower the # of trivial squaring/reductions used
-153 */
-154 if (mode == 0 && y == 0) \{
-155 continue;
-156 \}
-157
-158 /* if the bit is zero and mode == 1 then we square */
-159 if (mode == 1 && y == 0) \{
-160 if ((err = mp_sqr (&res, &res)) != MP_OKAY) \{
-161 goto __RES;
-162 \}
-163 if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
-164 goto __RES;
-165 \}
-166 continue;
-167 \}
-168
-169 /* else we add it to the window */
-170 bitbuf |= (y << (winsize - ++bitcpy));
-171 mode = 2;
-172
-173 if (bitcpy == winsize) \{
-174 /* ok window is filled so square as required and multiply */
-175 /* square first */
-176 for (x = 0; x < winsize; x++) \{
-177 if ((err = mp_sqr (&res, &res)) != MP_OKAY) \{
-178 goto __RES;
-179 \}
-180 if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
-181 goto __RES;
-182 \}
-183 \}
-184
-185 /* then multiply */
-186 if ((err = mp_mul (&res, &M[bitbuf], &res)) != MP_OKAY) \{
-187 goto __RES;
-188 \}
-189 if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
-190 goto __RES;
-191 \}
-192
-193 /* empty window and reset */
-194 bitcpy = 0;
-195 bitbuf = 0;
-196 mode = 1;
-197 \}
-198 \}
-199
-200 /* if bits remain then square/multiply */
-201 if (mode == 2 && bitcpy > 0) \{
-202 /* square then multiply if the bit is set */
-203 for (x = 0; x < bitcpy; x++) \{
-204 if ((err = mp_sqr (&res, &res)) != MP_OKAY) \{
-205 goto __RES;
-206 \}
-207 if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
-208 goto __RES;
-209 \}
-210
-211 bitbuf <<= 1;
-212 if ((bitbuf & (1 << winsize)) != 0) \{
-213 /* then multiply */
-214 if ((err = mp_mul (&res, &M[1], &res)) != MP_OKAY) \{
-215 goto __RES;
-216 \}
-217 if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
-218 goto __RES;
-219 \}
-220 \}
-221 \}
-222 \}
-223
-224 mp_exch (&res, Y);
-225 err = MP_OKAY;
-226 __RES:mp_clear (&res);
-227 __MU:mp_clear (&mu);
-228 __M:
-229 mp_clear(&M[1]);
-230 for (x = 1<<(winsize-1); x < (1 << winsize); x++) \{
-231 mp_clear (&M[x]);
-232 \}
-233 return err;
-234 \}
+016 #ifdef MP_LOW_MEM
+017 #define TAB_SIZE 32
+018 #else
+019 #define TAB_SIZE 256
+020 #endif
+021
+022 int s_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
+023 \{
+024 mp_int M[TAB_SIZE], res, mu;
+025 mp_digit buf;
+026 int err, bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize;
+027
+028 /* find window size */
+029 x = mp_count_bits (X);
+030 if (x <= 7) \{
+031 winsize = 2;
+032 \} else if (x <= 36) \{
+033 winsize = 3;
+034 \} else if (x <= 140) \{
+035 winsize = 4;
+036 \} else if (x <= 450) \{
+037 winsize = 5;
+038 \} else if (x <= 1303) \{
+039 winsize = 6;
+040 \} else if (x <= 3529) \{
+041 winsize = 7;
+042 \} else \{
+043 winsize = 8;
+044 \}
+045
+046 #ifdef MP_LOW_MEM
+047 if (winsize > 5) \{
+048 winsize = 5;
+049 \}
+050 #endif
+051
+052 /* init M array */
+053 /* init first cell */
+054 if ((err = mp_init(&M[1])) != MP_OKAY) \{
+055 return err;
+056 \}
+057
+058 /* now init the second half of the array */
+059 for (x = 1<<(winsize-1); x < (1 << winsize); x++) \{
+060 if ((err = mp_init(&M[x])) != MP_OKAY) \{
+061 for (y = 1<<(winsize-1); y < x; y++) \{
+062 mp_clear (&M[y]);
+063 \}
+064 mp_clear(&M[1]);
+065 return err;
+066 \}
+067 \}
+068
+069 /* create mu, used for Barrett reduction */
+070 if ((err = mp_init (&mu)) != MP_OKAY) \{
+071 goto __M;
+072 \}
+073 if ((err = mp_reduce_setup (&mu, P)) != MP_OKAY) \{
+074 goto __MU;
+075 \}
+076
+077 /* create M table
+078 *
+079 * The M table contains powers of the base,
+080 * e.g. M[x] = G**x mod P
+081 *
+082 * The first half of the table is not
+083 * computed though accept for M[0] and M[1]
+084 */
+085 if ((err = mp_mod (G, P, &M[1])) != MP_OKAY) \{
+086 goto __MU;
+087 \}
+088
+089 /* compute the value at M[1<<(winsize-1)] by squaring
+090 * M[1] (winsize-1) times
+091 */
+092 if ((err = mp_copy (&M[1], &M[1 << (winsize - 1)])) != MP_OKAY) \{
+093 goto __MU;
+094 \}
+095
+096 for (x = 0; x < (winsize - 1); x++) \{
+097 if ((err = mp_sqr (&M[1 << (winsize - 1)],
+098 &M[1 << (winsize - 1)])) != MP_OKAY) \{
+099 goto __MU;
+100 \}
+101 if ((err = mp_reduce (&M[1 << (winsize - 1)], P, &mu)) != MP_OKAY) \{
+102 goto __MU;
+103 \}
+104 \}
+105
+106 /* create upper table, that is M[x] = M[x-1] * M[1] (mod P)
+107 * for x = (2**(winsize - 1) + 1) to (2**winsize - 1)
+108 */
+109 for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) \{
+110 if ((err = mp_mul (&M[x - 1], &M[1], &M[x])) != MP_OKAY) \{
+111 goto __MU;
+112 \}
+113 if ((err = mp_reduce (&M[x], P, &mu)) != MP_OKAY) \{
+114 goto __MU;
+115 \}
+116 \}
+117
+118 /* setup result */
+119 if ((err = mp_init (&res)) != MP_OKAY) \{
+120 goto __MU;
+121 \}
+122 mp_set (&res, 1);
+123
+124 /* set initial mode and bit cnt */
+125 mode = 0;
+126 bitcnt = 1;
+127 buf = 0;
+128 digidx = X->used - 1;
+129 bitcpy = 0;
+130 bitbuf = 0;
+131
+132 for (;;) \{
+133 /* grab next digit as required */
+134 if (--bitcnt == 0) \{
+135 /* if digidx == -1 we are out of digits */
+136 if (digidx == -1) \{
+137 break;
+138 \}
+139 /* read next digit and reset the bitcnt */
+140 buf = X->dp[digidx--];
+141 bitcnt = (int) DIGIT_BIT;
+142 \}
+143
+144 /* grab the next msb from the exponent */
+145 y = (buf >> (mp_digit)(DIGIT_BIT - 1)) & 1;
+146 buf <<= (mp_digit)1;
+147
+148 /* if the bit is zero and mode == 0 then we ignore it
+149 * These represent the leading zero bits before the first 1 bit
+150 * in the exponent. Technically this opt is not required but it
+151 * does lower the # of trivial squaring/reductions used
+152 */
+153 if (mode == 0 && y == 0) \{
+154 continue;
+155 \}
+156
+157 /* if the bit is zero and mode == 1 then we square */
+158 if (mode == 1 && y == 0) \{
+159 if ((err = mp_sqr (&res, &res)) != MP_OKAY) \{
+160 goto __RES;
+161 \}
+162 if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
+163 goto __RES;
+164 \}
+165 continue;
+166 \}
+167
+168 /* else we add it to the window */
+169 bitbuf |= (y << (winsize - ++bitcpy));
+170 mode = 2;
+171
+172 if (bitcpy == winsize) \{
+173 /* ok window is filled so square as required and multiply */
+174 /* square first */
+175 for (x = 0; x < winsize; x++) \{
+176 if ((err = mp_sqr (&res, &res)) != MP_OKAY) \{
+177 goto __RES;
+178 \}
+179 if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
+180 goto __RES;
+181 \}
+182 \}
+183
+184 /* then multiply */
+185 if ((err = mp_mul (&res, &M[bitbuf], &res)) != MP_OKAY) \{
+186 goto __RES;
+187 \}
+188 if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
+189 goto __RES;
+190 \}
+191
+192 /* empty window and reset */
+193 bitcpy = 0;
+194 bitbuf = 0;
+195 mode = 1;
+196 \}
+197 \}
+198
+199 /* if bits remain then square/multiply */
+200 if (mode == 2 && bitcpy > 0) \{
+201 /* square then multiply if the bit is set */
+202 for (x = 0; x < bitcpy; x++) \{
+203 if ((err = mp_sqr (&res, &res)) != MP_OKAY) \{
+204 goto __RES;
+205 \}
+206 if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
+207 goto __RES;
+208 \}
+209
+210 bitbuf <<= 1;
+211 if ((bitbuf & (1 << winsize)) != 0) \{
+212 /* then multiply */
+213 if ((err = mp_mul (&res, &M[1], &res)) != MP_OKAY) \{
+214 goto __RES;
+215 \}
+216 if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
+217 goto __RES;
+218 \}
+219 \}
+220 \}
+221 \}
+222
+223 mp_exch (&res, Y);
+224 err = MP_OKAY;
+225 __RES:mp_clear (&res);
+226 __MU:mp_clear (&mu);
+227 __M:
+228 mp_clear(&M[1]);
+229 for (x = 1<<(winsize-1); x < (1 << winsize); x++) \{
+230 mp_clear (&M[x]);
+231 \}
+232 return err;
+233 \}
\end{alltt}
\end{small}
-Lines 31 through 41 determine the optimal window size based on the length of the exponent in bits. The window divisions are sorted
+Lines 30 through 40 determine the optimal window size based on the length of the exponent in bits. The window divisions are sorted
from smallest to greatest so that in each \textbf{if} statement only one condition must be tested. For example, by the \textbf{if} statement
-on line 33 the value of $x$ is already known to be greater than $140$.
+on line 32 the value of $x$ is already known to be greater than $140$.
-The conditional piece of code beginning on line 47 allows the window size to be restricted to five bits. This logic is used to ensure
+The conditional piece of code beginning on line 46 allows the window size to be restricted to five bits. This logic is used to ensure
the table of precomputed powers of $G$ remains relatively small.
-The for loop on line 60 initializes the $M$ array while lines 61 and 74 compute the value of $\mu$ required for
+The for loop on line 59 initializes the $M$ array while lines 60 and 73 compute the value of $\mu$ required for
Barrett reduction.
-- More later.
@@ -7958,33 +7945,32 @@ equivalent to $m \cdot 2^k$. By this logic when $m = 1$ a quick power of two ca
\hspace{-5.1mm}{\bf File}: bn\_mp\_2expt.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* computes a = 2**b
-018 *
-019 * Simple algorithm which zeroes the int, grows it then just sets one bit
-020 * as required.
-021 */
-022 int
-023 mp_2expt (mp_int * a, int b)
-024 \{
-025 int res;
-026
-027 /* zero a as per default */
-028 mp_zero (a);
-029
-030 /* grow a to accomodate the single bit */
-031 if ((res = mp_grow (a, b / DIGIT_BIT + 1)) != MP_OKAY) \{
-032 return res;
-033 \}
-034
-035 /* set the used count of where the bit will go */
-036 a->used = b / DIGIT_BIT + 1;
-037
-038 /* put the single bit in its place */
-039 a->dp[b / DIGIT_BIT] = 1 << (b % DIGIT_BIT);
-040
-041 return MP_OKAY;
-042 \}
+016 /* computes a = 2**b
+017 *
+018 * Simple algorithm which zeroes the int, grows it then just sets one bit
+019 * as required.
+020 */
+021 int
+022 mp_2expt (mp_int * a, int b)
+023 \{
+024 int res;
+025
+026 /* zero a as per default */
+027 mp_zero (a);
+028
+029 /* grow a to accomodate the single bit */
+030 if ((res = mp_grow (a, b / DIGIT_BIT + 1)) != MP_OKAY) \{
+031 return res;
+032 \}
+033
+034 /* set the used count of where the bit will go */
+035 a->used = b / DIGIT_BIT + 1;
+036
+037 /* put the single bit in its place */
+038 a->dp[b / DIGIT_BIT] = ((mp_digit)1) << (b % DIGIT_BIT);
+039
+040 return MP_OKAY;
+041 \}
\end{alltt}
\end{small}
@@ -8233,202 +8219,201 @@ respectively be replaced with a zero.
\hspace{-5.1mm}{\bf File}: bn\_mp\_div.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* integer signed division.
-018 * c*b + d == a [e.g. a/b, c=quotient, d=remainder]
-019 * HAC pp.598 Algorithm 14.20
-020 *
-021 * Note that the description in HAC is horribly
-022 * incomplete. For example, it doesn't consider
-023 * the case where digits are removed from 'x' in
-024 * the inner loop. It also doesn't consider the
-025 * case that y has fewer than three digits, etc..
-026 *
-027 * The overall algorithm is as described as
-028 * 14.20 from HAC but fixed to treat these cases.
-029 */
-030 int mp_div (mp_int * a, mp_int * b, mp_int * c, mp_int * d)
-031 \{
-032 mp_int q, x, y, t1, t2;
-033 int res, n, t, i, norm, neg;
-034
-035 /* is divisor zero ? */
-036 if (mp_iszero (b) == 1) \{
-037 return MP_VAL;
-038 \}
-039
-040 /* if a < b then q=0, r = a */
-041 if (mp_cmp_mag (a, b) == MP_LT) \{
-042 if (d != NULL) \{
-043 res = mp_copy (a, d);
-044 \} else \{
-045 res = MP_OKAY;
-046 \}
-047 if (c != NULL) \{
-048 mp_zero (c);
-049 \}
-050 return res;
-051 \}
-052
-053 if ((res = mp_init_size (&q, a->used + 2)) != MP_OKAY) \{
-054 return res;
-055 \}
-056 q.used = a->used + 2;
-057
-058 if ((res = mp_init (&t1)) != MP_OKAY) \{
-059 goto __Q;
-060 \}
-061
-062 if ((res = mp_init (&t2)) != MP_OKAY) \{
-063 goto __T1;
-064 \}
-065
-066 if ((res = mp_init_copy (&x, a)) != MP_OKAY) \{
-067 goto __T2;
-068 \}
-069
-070 if ((res = mp_init_copy (&y, b)) != MP_OKAY) \{
-071 goto __X;
-072 \}
-073
-074 /* fix the sign */
-075 neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
-076 x.sign = y.sign = MP_ZPOS;
-077
-078 /* normalize both x and y, ensure that y >= b/2, [b == 2**DIGIT_BIT] */
-079 norm = mp_count_bits(&y) % DIGIT_BIT;
-080 if (norm < (int)(DIGIT_BIT-1)) \{
-081 norm = (DIGIT_BIT-1) - norm;
-082 if ((res = mp_mul_2d (&x, norm, &x)) != MP_OKAY) \{
-083 goto __Y;
-084 \}
-085 if ((res = mp_mul_2d (&y, norm, &y)) != MP_OKAY) \{
-086 goto __Y;
-087 \}
-088 \} else \{
-089 norm = 0;
-090 \}
-091
-092 /* note hac does 0 based, so if used==5 then its 0,1,2,3,4, e.g. use 4 */
-093 n = x.used - 1;
-094 t = y.used - 1;
-095
-096 /* while (x >= y*b**n-t) do \{ q[n-t] += 1; x -= y*b**\{n-t\} \} */
-097 if ((res = mp_lshd (&y, n - t)) != MP_OKAY) \{ /* y = y*b**\{n-t\} */
-098 goto __Y;
-099 \}
-100
-101 while (mp_cmp (&x, &y) != MP_LT) \{
-102 ++(q.dp[n - t]);
-103 if ((res = mp_sub (&x, &y, &x)) != MP_OKAY) \{
-104 goto __Y;
-105 \}
-106 \}
-107
-108 /* reset y by shifting it back down */
-109 mp_rshd (&y, n - t);
-110
-111 /* step 3. for i from n down to (t + 1) */
-112 for (i = n; i >= (t + 1); i--) \{
-113 if (i > x.used) \{
-114 continue;
-115 \}
-116
-117 /* step 3.1 if xi == yt then set q\{i-t-1\} to b-1,
-118 * otherwise set q\{i-t-1\} to (xi*b + x\{i-1\})/yt */
-119 if (x.dp[i] == y.dp[t]) \{
-120 q.dp[i - t - 1] = ((((mp_digit)1) << DIGIT_BIT) - 1);
-121 \} else \{
-122 mp_word tmp;
-123 tmp = ((mp_word) x.dp[i]) << ((mp_word) DIGIT_BIT);
-124 tmp |= ((mp_word) x.dp[i - 1]);
-125 tmp /= ((mp_word) y.dp[t]);
-126 if (tmp > (mp_word) MP_MASK)
-127 tmp = MP_MASK;
-128 q.dp[i - t - 1] = (mp_digit) (tmp & (mp_word) (MP_MASK));
-129 \}
-130
-131 /* while (q\{i-t-1\} * (yt * b + y\{t-1\})) >
-132 xi * b**2 + xi-1 * b + xi-2
-133
-134 do q\{i-t-1\} -= 1;
-135 */
-136 q.dp[i - t - 1] = (q.dp[i - t - 1] + 1) & MP_MASK;
-137 do \{
-138 q.dp[i - t - 1] = (q.dp[i - t - 1] - 1) & MP_MASK;
-139
-140 /* find left hand */
-141 mp_zero (&t1);
-142 t1.dp[0] = (t - 1 < 0) ? 0 : y.dp[t - 1];
-143 t1.dp[1] = y.dp[t];
-144 t1.used = 2;
-145 if ((res = mp_mul_d (&t1, q.dp[i - t - 1], &t1)) != MP_OKAY) \{
-146 goto __Y;
-147 \}
-148
-149 /* find right hand */
-150 t2.dp[0] = (i - 2 < 0) ? 0 : x.dp[i - 2];
-151 t2.dp[1] = (i - 1 < 0) ? 0 : x.dp[i - 1];
-152 t2.dp[2] = x.dp[i];
-153 t2.used = 3;
-154 \} while (mp_cmp_mag(&t1, &t2) == MP_GT);
-155
-156 /* step 3.3 x = x - q\{i-t-1\} * y * b**\{i-t-1\} */
-157 if ((res = mp_mul_d (&y, q.dp[i - t - 1], &t1)) != MP_OKAY) \{
-158 goto __Y;
-159 \}
-160
-161 if ((res = mp_lshd (&t1, i - t - 1)) != MP_OKAY) \{
-162 goto __Y;
-163 \}
-164
-165 if ((res = mp_sub (&x, &t1, &x)) != MP_OKAY) \{
-166 goto __Y;
-167 \}
-168
-169 /* if x < 0 then \{ x = x + y*b**\{i-t-1\}; q\{i-t-1\} -= 1; \} */
-170 if (x.sign == MP_NEG) \{
-171 if ((res = mp_copy (&y, &t1)) != MP_OKAY) \{
-172 goto __Y;
-173 \}
-174 if ((res = mp_lshd (&t1, i - t - 1)) != MP_OKAY) \{
-175 goto __Y;
-176 \}
-177 if ((res = mp_add (&x, &t1, &x)) != MP_OKAY) \{
-178 goto __Y;
-179 \}
-180
-181 q.dp[i - t - 1] = (q.dp[i - t - 1] - 1UL) & MP_MASK;
-182 \}
-183 \}
-184
-185 /* now q is the quotient and x is the remainder
-186 * [which we have to normalize]
-187 */
-188
-189 /* get sign before writing to c */
-190 x.sign = a->sign;
-191
-192 if (c != NULL) \{
-193 mp_clamp (&q);
-194 mp_exch (&q, c);
-195 c->sign = neg;
-196 \}
-197
-198 if (d != NULL) \{
-199 mp_div_2d (&x, norm, &x, NULL);
-200 mp_exch (&x, d);
-201 \}
-202
-203 res = MP_OKAY;
-204
-205 __Y:mp_clear (&y);
-206 __X:mp_clear (&x);
-207 __T2:mp_clear (&t2);
-208 __T1:mp_clear (&t1);
-209 __Q:mp_clear (&q);
-210 return res;
-211 \}
+016 /* integer signed division.
+017 * c*b + d == a [e.g. a/b, c=quotient, d=remainder]
+018 * HAC pp.598 Algorithm 14.20
+019 *
+020 * Note that the description in HAC is horribly
+021 * incomplete. For example, it doesn't consider
+022 * the case where digits are removed from 'x' in
+023 * the inner loop. It also doesn't consider the
+024 * case that y has fewer than three digits, etc..
+025 *
+026 * The overall algorithm is as described as
+027 * 14.20 from HAC but fixed to treat these cases.
+028 */
+029 int mp_div (mp_int * a, mp_int * b, mp_int * c, mp_int * d)
+030 \{
+031 mp_int q, x, y, t1, t2;
+032 int res, n, t, i, norm, neg;
+033
+034 /* is divisor zero ? */
+035 if (mp_iszero (b) == 1) \{
+036 return MP_VAL;
+037 \}
+038
+039 /* if a < b then q=0, r = a */
+040 if (mp_cmp_mag (a, b) == MP_LT) \{
+041 if (d != NULL) \{
+042 res = mp_copy (a, d);
+043 \} else \{
+044 res = MP_OKAY;
+045 \}
+046 if (c != NULL) \{
+047 mp_zero (c);
+048 \}
+049 return res;
+050 \}
+051
+052 if ((res = mp_init_size (&q, a->used + 2)) != MP_OKAY) \{
+053 return res;
+054 \}
+055 q.used = a->used + 2;
+056
+057 if ((res = mp_init (&t1)) != MP_OKAY) \{
+058 goto __Q;
+059 \}
+060
+061 if ((res = mp_init (&t2)) != MP_OKAY) \{
+062 goto __T1;
+063 \}
+064
+065 if ((res = mp_init_copy (&x, a)) != MP_OKAY) \{
+066 goto __T2;
+067 \}
+068
+069 if ((res = mp_init_copy (&y, b)) != MP_OKAY) \{
+070 goto __X;
+071 \}
+072
+073 /* fix the sign */
+074 neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
+075 x.sign = y.sign = MP_ZPOS;
+076
+077 /* normalize both x and y, ensure that y >= b/2, [b == 2**DIGIT_BIT] */
+078 norm = mp_count_bits(&y) % DIGIT_BIT;
+079 if (norm < (int)(DIGIT_BIT-1)) \{
+080 norm = (DIGIT_BIT-1) - norm;
+081 if ((res = mp_mul_2d (&x, norm, &x)) != MP_OKAY) \{
+082 goto __Y;
+083 \}
+084 if ((res = mp_mul_2d (&y, norm, &y)) != MP_OKAY) \{
+085 goto __Y;
+086 \}
+087 \} else \{
+088 norm = 0;
+089 \}
+090
+091 /* note hac does 0 based, so if used==5 then its 0,1,2,3,4, e.g. use 4 */
+092 n = x.used - 1;
+093 t = y.used - 1;
+094
+095 /* while (x >= y*b**n-t) do \{ q[n-t] += 1; x -= y*b**\{n-t\} \} */
+096 if ((res = mp_lshd (&y, n - t)) != MP_OKAY) \{ /* y = y*b**\{n-t\} */
+097 goto __Y;
+098 \}
+099
+100 while (mp_cmp (&x, &y) != MP_LT) \{
+101 ++(q.dp[n - t]);
+102 if ((res = mp_sub (&x, &y, &x)) != MP_OKAY) \{
+103 goto __Y;
+104 \}
+105 \}
+106
+107 /* reset y by shifting it back down */
+108 mp_rshd (&y, n - t);
+109
+110 /* step 3. for i from n down to (t + 1) */
+111 for (i = n; i >= (t + 1); i--) \{
+112 if (i > x.used) \{
+113 continue;
+114 \}
+115
+116 /* step 3.1 if xi == yt then set q\{i-t-1\} to b-1,
+117 * otherwise set q\{i-t-1\} to (xi*b + x\{i-1\})/yt */
+118 if (x.dp[i] == y.dp[t]) \{
+119 q.dp[i - t - 1] = ((((mp_digit)1) << DIGIT_BIT) - 1);
+120 \} else \{
+121 mp_word tmp;
+122 tmp = ((mp_word) x.dp[i]) << ((mp_word) DIGIT_BIT);
+123 tmp |= ((mp_word) x.dp[i - 1]);
+124 tmp /= ((mp_word) y.dp[t]);
+125 if (tmp > (mp_word) MP_MASK)
+126 tmp = MP_MASK;
+127 q.dp[i - t - 1] = (mp_digit) (tmp & (mp_word) (MP_MASK));
+128 \}
+129
+130 /* while (q\{i-t-1\} * (yt * b + y\{t-1\})) >
+131 xi * b**2 + xi-1 * b + xi-2
+132
+133 do q\{i-t-1\} -= 1;
+134 */
+135 q.dp[i - t - 1] = (q.dp[i - t - 1] + 1) & MP_MASK;
+136 do \{
+137 q.dp[i - t - 1] = (q.dp[i - t - 1] - 1) & MP_MASK;
+138
+139 /* find left hand */
+140 mp_zero (&t1);
+141 t1.dp[0] = (t - 1 < 0) ? 0 : y.dp[t - 1];
+142 t1.dp[1] = y.dp[t];
+143 t1.used = 2;
+144 if ((res = mp_mul_d (&t1, q.dp[i - t - 1], &t1)) != MP_OKAY) \{
+145 goto __Y;
+146 \}
+147
+148 /* find right hand */
+149 t2.dp[0] = (i - 2 < 0) ? 0 : x.dp[i - 2];
+150 t2.dp[1] = (i - 1 < 0) ? 0 : x.dp[i - 1];
+151 t2.dp[2] = x.dp[i];
+152 t2.used = 3;
+153 \} while (mp_cmp_mag(&t1, &t2) == MP_GT);
+154
+155 /* step 3.3 x = x - q\{i-t-1\} * y * b**\{i-t-1\} */
+156 if ((res = mp_mul_d (&y, q.dp[i - t - 1], &t1)) != MP_OKAY) \{
+157 goto __Y;
+158 \}
+159
+160 if ((res = mp_lshd (&t1, i - t - 1)) != MP_OKAY) \{
+161 goto __Y;
+162 \}
+163
+164 if ((res = mp_sub (&x, &t1, &x)) != MP_OKAY) \{
+165 goto __Y;
+166 \}
+167
+168 /* if x < 0 then \{ x = x + y*b**\{i-t-1\}; q\{i-t-1\} -= 1; \} */
+169 if (x.sign == MP_NEG) \{
+170 if ((res = mp_copy (&y, &t1)) != MP_OKAY) \{
+171 goto __Y;
+172 \}
+173 if ((res = mp_lshd (&t1, i - t - 1)) != MP_OKAY) \{
+174 goto __Y;
+175 \}
+176 if ((res = mp_add (&x, &t1, &x)) != MP_OKAY) \{
+177 goto __Y;
+178 \}
+179
+180 q.dp[i - t - 1] = (q.dp[i - t - 1] - 1UL) & MP_MASK;
+181 \}
+182 \}
+183
+184 /* now q is the quotient and x is the remainder
+185 * [which we have to normalize]
+186 */
+187
+188 /* get sign before writing to c */
+189 x.sign = x.used == 0 ? MP_ZPOS : a->sign;
+190
+191 if (c != NULL) \{
+192 mp_clamp (&q);
+193 mp_exch (&q, c);
+194 c->sign = neg;
+195 \}
+196
+197 if (d != NULL) \{
+198 mp_div_2d (&x, norm, &x, NULL);
+199 mp_exch (&x, d);
+200 \}
+201
+202 res = MP_OKAY;
+203
+204 __Y:mp_clear (&y);
+205 __X:mp_clear (&x);
+206 __T2:mp_clear (&t2);
+207 __T1:mp_clear (&t1);
+208 __Q:mp_clear (&q);
+209 return res;
+210 \}
\end{alltt}
\end{small}
@@ -8440,9 +8425,9 @@ algorithm with only the quotient is
mp_div(&a, &b, &c, NULL); /* c = [a/b] */
\end{verbatim}
-Lines 36 and 42 handle the two trivial cases of inputs which are division by zero and dividend smaller than the divisor
-respectively. After the two trivial cases all of the temporary variables are initialized. Line 75 determines the sign of
-the quotient and line 76 ensures that both $x$ and $y$ are positive.
+Lines 39 and 41 handle the two trivial cases of inputs which are division by zero and dividend smaller than the divisor
+respectively. After the two trivial cases all of the temporary variables are initialized. Line 74 determines the sign of
+the quotient and line 75 ensures that both $x$ and $y$ are positive.
The number of bits in the leading digit is calculated on line 80. Implictly an mp\_int with $r$ digits will require $lg(\beta)(r-1) + k$ bits
of precision which when reduced modulo $lg(\beta)$ produces the value of $k$. In this case $k$ is the number of bits in the leading digit which is
@@ -8450,9 +8435,9 @@ exactly what is required. For the algorithm to operate $k$ must equal $lg(\beta
them to the left by $lg(\beta) - 1 - k$ bits.
Throughout the variables $n$ and $t$ will represent the highest digit of $x$ and $y$ respectively. These are first used to produce the
-leading digit of the quotient. The loop beginning on line 112 will produce the remainder of the quotient digits.
+leading digit of the quotient. The loop beginning on line 111 will produce the remainder of the quotient digits.
-The conditional ``continue'' on line 113 is used to prevent the algorithm from reading past the leading edge of $x$ which can occur when the
+The conditional ``continue'' on line 116 is used to prevent the algorithm from reading past the leading edge of $x$ which can occur when the
algorithm eliminates multiple non-zero digits in a single iteration. This ensures that $x_i$ is always non-zero since by definition the digits
above the $i$'th position $x$ must be zero in order for the quotient to be precise\footnote{Precise as far as integer division is concerned.}.
@@ -8494,94 +8479,93 @@ This algorithm initiates a temporary mp\_int with the value of the single digit
\hspace{-5.1mm}{\bf File}: bn\_mp\_add\_d.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* single digit addition */
-018 int
-019 mp_add_d (mp_int * a, mp_digit b, mp_int * c)
-020 \{
-021 int res, ix, oldused;
-022 mp_digit *tmpa, *tmpc, mu;
-023
-024 /* grow c as required */
-025 if (c->alloc < a->used + 1) \{
-026 if ((res = mp_grow(c, a->used + 1)) != MP_OKAY) \{
-027 return res;
-028 \}
-029 \}
-030
-031 /* if a is negative and |a| >= b, call c = |a| - b */
-032 if (a->sign == MP_NEG && (a->used > 1 || a->dp[0] >= b)) \{
-033 /* temporarily fix sign of a */
-034 a->sign = MP_ZPOS;
-035
-036 /* c = |a| - b */
-037 res = mp_sub_d(a, b, c);
-038
-039 /* fix sign */
-040 a->sign = c->sign = MP_NEG;
-041
-042 return res;
-043 \}
-044
-045 /* old number of used digits in c */
-046 oldused = c->used;
-047
-048 /* sign always positive */
-049 c->sign = MP_ZPOS;
-050
-051 /* source alias */
-052 tmpa = a->dp;
-053
-054 /* destination alias */
-055 tmpc = c->dp;
-056
-057 /* if a is positive */
-058 if (a->sign == MP_ZPOS) \{
-059 /* add digit, after this we're propagating
-060 * the carry.
-061 */
-062 *tmpc = *tmpa++ + b;
-063 mu = *tmpc >> DIGIT_BIT;
-064 *tmpc++ &= MP_MASK;
-065
-066 /* now handle rest of the digits */
-067 for (ix = 1; ix < a->used; ix++) \{
-068 *tmpc = *tmpa++ + mu;
-069 mu = *tmpc >> DIGIT_BIT;
-070 *tmpc++ &= MP_MASK;
-071 \}
-072 /* set final carry */
-073 ix++;
-074 *tmpc++ = mu;
-075
-076 /* setup size */
-077 c->used = a->used + 1;
-078 \} else \{
-079 /* a was negative and |a| < b */
-080 c->used = 1;
-081
-082 /* the result is a single digit */
-083 if (a->used == 1) \{
-084 *tmpc++ = b - a->dp[0];
-085 \} else \{
-086 *tmpc++ = b;
-087 \}
-088
-089 /* setup count so the clearing of oldused
-090 * can fall through correctly
-091 */
-092 ix = 1;
-093 \}
-094
-095 /* now zero to oldused */
-096 while (ix++ < oldused) \{
-097 *tmpc++ = 0;
-098 \}
-099 mp_clamp(c);
-100
-101 return MP_OKAY;
-102 \}
-103
+016 /* single digit addition */
+017 int
+018 mp_add_d (mp_int * a, mp_digit b, mp_int * c)
+019 \{
+020 int res, ix, oldused;
+021 mp_digit *tmpa, *tmpc, mu;
+022
+023 /* grow c as required */
+024 if (c->alloc < a->used + 1) \{
+025 if ((res = mp_grow(c, a->used + 1)) != MP_OKAY) \{
+026 return res;
+027 \}
+028 \}
+029
+030 /* if a is negative and |a| >= b, call c = |a| - b */
+031 if (a->sign == MP_NEG && (a->used > 1 || a->dp[0] >= b)) \{
+032 /* temporarily fix sign of a */
+033 a->sign = MP_ZPOS;
+034
+035 /* c = |a| - b */
+036 res = mp_sub_d(a, b, c);
+037
+038 /* fix sign */
+039 a->sign = c->sign = MP_NEG;
+040
+041 return res;
+042 \}
+043
+044 /* old number of used digits in c */
+045 oldused = c->used;
+046
+047 /* sign always positive */
+048 c->sign = MP_ZPOS;
+049
+050 /* source alias */
+051 tmpa = a->dp;
+052
+053 /* destination alias */
+054 tmpc = c->dp;
+055
+056 /* if a is positive */
+057 if (a->sign == MP_ZPOS) \{
+058 /* add digit, after this we're propagating
+059 * the carry.
+060 */
+061 *tmpc = *tmpa++ + b;
+062 mu = *tmpc >> DIGIT_BIT;
+063 *tmpc++ &= MP_MASK;
+064
+065 /* now handle rest of the digits */
+066 for (ix = 1; ix < a->used; ix++) \{
+067 *tmpc = *tmpa++ + mu;
+068 mu = *tmpc >> DIGIT_BIT;
+069 *tmpc++ &= MP_MASK;
+070 \}
+071 /* set final carry */
+072 ix++;
+073 *tmpc++ = mu;
+074
+075 /* setup size */
+076 c->used = a->used + 1;
+077 \} else \{
+078 /* a was negative and |a| < b */
+079 c->used = 1;
+080
+081 /* the result is a single digit */
+082 if (a->used == 1) \{
+083 *tmpc++ = b - a->dp[0];
+084 \} else \{
+085 *tmpc++ = b;
+086 \}
+087
+088 /* setup count so the clearing of oldused
+089 * can fall through correctly
+090 */
+091 ix = 1;
+092 \}
+093
+094 /* now zero to oldused */
+095 while (ix++ < oldused) \{
+096 *tmpc++ = 0;
+097 \}
+098 mp_clamp(c);
+099
+100 return MP_OKAY;
+101 \}
+102
\end{alltt}
\end{small}
@@ -8632,63 +8616,62 @@ Unlike the full multiplication algorithms this algorithm does not require any si
\hspace{-5.1mm}{\bf File}: bn\_mp\_mul\_d.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* multiply by a digit */
-018 int
-019 mp_mul_d (mp_int * a, mp_digit b, mp_int * c)
-020 \{
-021 mp_digit u, *tmpa, *tmpc;
-022 mp_word r;
-023 int ix, res, olduse;
-024
-025 /* make sure c is big enough to hold a*b */
-026 if (c->alloc < a->used + 1) \{
-027 if ((res = mp_grow (c, a->used + 1)) != MP_OKAY) \{
-028 return res;
-029 \}
-030 \}
-031
-032 /* get the original destinations used count */
-033 olduse = c->used;
-034
-035 /* set the sign */
-036 c->sign = a->sign;
-037
-038 /* alias for a->dp [source] */
-039 tmpa = a->dp;
-040
-041 /* alias for c->dp [dest] */
-042 tmpc = c->dp;
-043
-044 /* zero carry */
-045 u = 0;
-046
-047 /* compute columns */
-048 for (ix = 0; ix < a->used; ix++) \{
-049 /* compute product and carry sum for this term */
-050 r = ((mp_word) u) + ((mp_word)*tmpa++) * ((mp_word)b);
-051
-052 /* mask off higher bits to get a single digit */
-053 *tmpc++ = (mp_digit) (r & ((mp_word) MP_MASK));
-054
-055 /* send carry into next iteration */
-056 u = (mp_digit) (r >> ((mp_word) DIGIT_BIT));
-057 \}
-058
-059 /* store final carry [if any] */
-060 *tmpc++ = u;
-061
-062 /* now zero digits above the top */
-063 while (ix++ < olduse) \{
-064 *tmpc++ = 0;
-065 \}
-066
-067 /* set used count */
-068 c->used = a->used + 1;
-069 mp_clamp(c);
-070
-071 return MP_OKAY;
-072 \}
+016 /* multiply by a digit */
+017 int
+018 mp_mul_d (mp_int * a, mp_digit b, mp_int * c)
+019 \{
+020 mp_digit u, *tmpa, *tmpc;
+021 mp_word r;
+022 int ix, res, olduse;
+023
+024 /* make sure c is big enough to hold a*b */
+025 if (c->alloc < a->used + 1) \{
+026 if ((res = mp_grow (c, a->used + 1)) != MP_OKAY) \{
+027 return res;
+028 \}
+029 \}
+030
+031 /* get the original destinations used count */
+032 olduse = c->used;
+033
+034 /* set the sign */
+035 c->sign = a->sign;
+036
+037 /* alias for a->dp [source] */
+038 tmpa = a->dp;
+039
+040 /* alias for c->dp [dest] */
+041 tmpc = c->dp;
+042
+043 /* zero carry */
+044 u = 0;
+045
+046 /* compute columns */
+047 for (ix = 0; ix < a->used; ix++) \{
+048 /* compute product and carry sum for this term */
+049 r = ((mp_word) u) + ((mp_word)*tmpa++) * ((mp_word)b);
+050
+051 /* mask off higher bits to get a single digit */
+052 *tmpc++ = (mp_digit) (r & ((mp_word) MP_MASK));
+053
+054 /* send carry into next iteration */
+055 u = (mp_digit) (r >> ((mp_word) DIGIT_BIT));
+056 \}
+057
+058 /* store final carry [if any] */
+059 *tmpc++ = u;
+060
+061 /* now zero digits above the top */
+062 while (ix++ < olduse) \{
+063 *tmpc++ = 0;
+064 \}
+065
+066 /* set used count */
+067 c->used = a->used + 1;
+068 mp_clamp(c);
+069
+070 return MP_OKAY;
+071 \}
\end{alltt}
\end{small}
@@ -8744,100 +8727,99 @@ from chapter seven.
\hspace{-5.1mm}{\bf File}: bn\_mp\_div\_d.c
\vspace{-3mm}
\begin{alltt}
-016
-017 static int s_is_power_of_two(mp_digit b, int *p)
-018 \{
-019 int x;
-020
-021 for (x = 1; x < DIGIT_BIT; x++) \{
-022 if (b == (((mp_digit)1)<<x)) \{
-023 *p = x;
-024 return 1;
-025 \}
-026 \}
-027 return 0;
-028 \}
-029
-030 /* single digit division (based on routine from MPI) */
-031 int mp_div_d (mp_int * a, mp_digit b, mp_int * c, mp_digit * d)
-032 \{
-033 mp_int q;
-034 mp_word w;
-035 mp_digit t;
-036 int res, ix;
-037
-038 /* cannot divide by zero */
-039 if (b == 0) \{
-040 return MP_VAL;
-041 \}
-042
-043 /* quick outs */
-044 if (b == 1 || mp_iszero(a) == 1) \{
-045 if (d != NULL) \{
-046 *d = 0;
-047 \}
-048 if (c != NULL) \{
-049 return mp_copy(a, c);
-050 \}
-051 return MP_OKAY;
-052 \}
-053
-054 /* power of two ? */
-055 if (s_is_power_of_two(b, &ix) == 1) \{
-056 if (d != NULL) \{
-057 *d = a->dp[0] & ((1<<ix) - 1);
-058 \}
-059 if (c != NULL) \{
-060 return mp_div_2d(a, ix, c, NULL);
-061 \}
-062 return MP_OKAY;
-063 \}
-064
-065 /* three? */
-066 if (b == 3) \{
-067 return mp_div_3(a, c, d);
-068 \}
-069
-070 /* no easy answer [c'est la vie]. Just division */
-071 if ((res = mp_init_size(&q, a->used)) != MP_OKAY) \{
-072 return res;
-073 \}
-074
-075 q.used = a->used;
-076 q.sign = a->sign;
-077 w = 0;
-078 for (ix = a->used - 1; ix >= 0; ix--) \{
-079 w = (w << ((mp_word)DIGIT_BIT)) | ((mp_word)a->dp[ix]);
-080
-081 if (w >= b) \{
-082 t = (mp_digit)(w / b);
-083 w -= ((mp_word)t) * ((mp_word)b);
-084 \} else \{
-085 t = 0;
-086 \}
-087 q.dp[ix] = (mp_digit)t;
-088 \}
-089
-090 if (d != NULL) \{
-091 *d = (mp_digit)w;
-092 \}
-093
-094 if (c != NULL) \{
-095 mp_clamp(&q);
-096 mp_exch(&q, c);
-097 \}
-098 mp_clear(&q);
-099
-100 return res;
-101 \}
-102
+016 static int s_is_power_of_two(mp_digit b, int *p)
+017 \{
+018 int x;
+019
+020 for (x = 1; x < DIGIT_BIT; x++) \{
+021 if (b == (((mp_digit)1)<<x)) \{
+022 *p = x;
+023 return 1;
+024 \}
+025 \}
+026 return 0;
+027 \}
+028
+029 /* single digit division (based on routine from MPI) */
+030 int mp_div_d (mp_int * a, mp_digit b, mp_int * c, mp_digit * d)
+031 \{
+032 mp_int q;
+033 mp_word w;
+034 mp_digit t;
+035 int res, ix;
+036
+037 /* cannot divide by zero */
+038 if (b == 0) \{
+039 return MP_VAL;
+040 \}
+041
+042 /* quick outs */
+043 if (b == 1 || mp_iszero(a) == 1) \{
+044 if (d != NULL) \{
+045 *d = 0;
+046 \}
+047 if (c != NULL) \{
+048 return mp_copy(a, c);
+049 \}
+050 return MP_OKAY;
+051 \}
+052
+053 /* power of two ? */
+054 if (s_is_power_of_two(b, &ix) == 1) \{
+055 if (d != NULL) \{
+056 *d = a->dp[0] & ((1<<ix) - 1);
+057 \}
+058 if (c != NULL) \{
+059 return mp_div_2d(a, ix, c, NULL);
+060 \}
+061 return MP_OKAY;
+062 \}
+063
+064 /* three? */
+065 if (b == 3) \{
+066 return mp_div_3(a, c, d);
+067 \}
+068
+069 /* no easy answer [c'est la vie]. Just division */
+070 if ((res = mp_init_size(&q, a->used)) != MP_OKAY) \{
+071 return res;
+072 \}
+073
+074 q.used = a->used;
+075 q.sign = a->sign;
+076 w = 0;
+077 for (ix = a->used - 1; ix >= 0; ix--) \{
+078 w = (w << ((mp_word)DIGIT_BIT)) | ((mp_word)a->dp[ix]);
+079
+080 if (w >= b) \{
+081 t = (mp_digit)(w / b);
+082 w -= ((mp_word)t) * ((mp_word)b);
+083 \} else \{
+084 t = 0;
+085 \}
+086 q.dp[ix] = (mp_digit)t;
+087 \}
+088
+089 if (d != NULL) \{
+090 *d = (mp_digit)w;
+091 \}
+092
+093 if (c != NULL) \{
+094 mp_clamp(&q);
+095 mp_exch(&q, c);
+096 \}
+097 mp_clear(&q);
+098
+099 return res;
+100 \}
+101
\end{alltt}
\end{small}
Like the implementation of algorithm mp\_div this algorithm allows either of the quotient or remainder to be passed as a \textbf{NULL} pointer to
indicate the respective value is not required. This allows a trivial single digit modular reduction algorithm, mp\_mod\_d to be created.
-The division and remainder on lines 43 and @45,%@ can be replaced often by a single division on most processors. For example, the 32-bit x86 based
+The division and remainder on lines 42 and @45,%@ can be replaced often by a single division on most processors. For example, the 32-bit x86 based
processors can divide a 64-bit quantity by a 32-bit quantity and produce the quotient and remainder simultaneously. Unfortunately the GCC
compiler does not recognize that optimization and will actually produce two function calls to find the quotient and remainder respectively.
@@ -8905,117 +8887,116 @@ root. Ideally this algorithm is meant to find the $n$'th root of an input where
\hspace{-5.1mm}{\bf File}: bn\_mp\_n\_root.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* find the n'th root of an integer
-018 *
-019 * Result found such that (c)**b <= a and (c+1)**b > a
-020 *
-021 * This algorithm uses Newton's approximation
-022 * x[i+1] = x[i] - f(x[i])/f'(x[i])
-023 * which will find the root in log(N) time where
-024 * each step involves a fair bit. This is not meant to
-025 * find huge roots [square and cube, etc].
-026 */
-027 int mp_n_root (mp_int * a, mp_digit b, mp_int * c)
-028 \{
-029 mp_int t1, t2, t3;
-030 int res, neg;
-031
-032 /* input must be positive if b is even */
-033 if ((b & 1) == 0 && a->sign == MP_NEG) \{
-034 return MP_VAL;
-035 \}
-036
-037 if ((res = mp_init (&t1)) != MP_OKAY) \{
-038 return res;
-039 \}
-040
-041 if ((res = mp_init (&t2)) != MP_OKAY) \{
-042 goto __T1;
-043 \}
-044
-045 if ((res = mp_init (&t3)) != MP_OKAY) \{
-046 goto __T2;
-047 \}
-048
-049 /* if a is negative fudge the sign but keep track */
-050 neg = a->sign;
-051 a->sign = MP_ZPOS;
-052
-053 /* t2 = 2 */
-054 mp_set (&t2, 2);
-055
-056 do \{
-057 /* t1 = t2 */
-058 if ((res = mp_copy (&t2, &t1)) != MP_OKAY) \{
-059 goto __T3;
-060 \}
-061
-062 /* t2 = t1 - ((t1**b - a) / (b * t1**(b-1))) */
-063
-064 /* t3 = t1**(b-1) */
-065 if ((res = mp_expt_d (&t1, b - 1, &t3)) != MP_OKAY) \{
-066 goto __T3;
-067 \}
-068
-069 /* numerator */
-070 /* t2 = t1**b */
-071 if ((res = mp_mul (&t3, &t1, &t2)) != MP_OKAY) \{
-072 goto __T3;
-073 \}
-074
-075 /* t2 = t1**b - a */
-076 if ((res = mp_sub (&t2, a, &t2)) != MP_OKAY) \{
-077 goto __T3;
-078 \}
-079
-080 /* denominator */
-081 /* t3 = t1**(b-1) * b */
-082 if ((res = mp_mul_d (&t3, b, &t3)) != MP_OKAY) \{
-083 goto __T3;
-084 \}
-085
-086 /* t3 = (t1**b - a)/(b * t1**(b-1)) */
-087 if ((res = mp_div (&t2, &t3, &t3, NULL)) != MP_OKAY) \{
-088 goto __T3;
-089 \}
-090
-091 if ((res = mp_sub (&t1, &t3, &t2)) != MP_OKAY) \{
-092 goto __T3;
-093 \}
-094 \} while (mp_cmp (&t1, &t2) != MP_EQ);
-095
-096 /* result can be off by a few so check */
-097 for (;;) \{
-098 if ((res = mp_expt_d (&t1, b, &t2)) != MP_OKAY) \{
-099 goto __T3;
-100 \}
-101
-102 if (mp_cmp (&t2, a) == MP_GT) \{
-103 if ((res = mp_sub_d (&t1, 1, &t1)) != MP_OKAY) \{
-104 goto __T3;
-105 \}
-106 \} else \{
-107 break;
-108 \}
-109 \}
-110
-111 /* reset the sign of a first */
-112 a->sign = neg;
-113
-114 /* set the result */
-115 mp_exch (&t1, c);
-116
-117 /* set the sign of the result */
-118 c->sign = neg;
-119
-120 res = MP_OKAY;
-121
-122 __T3:mp_clear (&t3);
-123 __T2:mp_clear (&t2);
-124 __T1:mp_clear (&t1);
-125 return res;
-126 \}
+016 /* find the n'th root of an integer
+017 *
+018 * Result found such that (c)**b <= a and (c+1)**b > a
+019 *
+020 * This algorithm uses Newton's approximation
+021 * x[i+1] = x[i] - f(x[i])/f'(x[i])
+022 * which will find the root in log(N) time where
+023 * each step involves a fair bit. This is not meant to
+024 * find huge roots [square and cube, etc].
+025 */
+026 int mp_n_root (mp_int * a, mp_digit b, mp_int * c)
+027 \{
+028 mp_int t1, t2, t3;
+029 int res, neg;
+030
+031 /* input must be positive if b is even */
+032 if ((b & 1) == 0 && a->sign == MP_NEG) \{
+033 return MP_VAL;
+034 \}
+035
+036 if ((res = mp_init (&t1)) != MP_OKAY) \{
+037 return res;
+038 \}
+039
+040 if ((res = mp_init (&t2)) != MP_OKAY) \{
+041 goto __T1;
+042 \}
+043
+044 if ((res = mp_init (&t3)) != MP_OKAY) \{
+045 goto __T2;
+046 \}
+047
+048 /* if a is negative fudge the sign but keep track */
+049 neg = a->sign;
+050 a->sign = MP_ZPOS;
+051
+052 /* t2 = 2 */
+053 mp_set (&t2, 2);
+054
+055 do \{
+056 /* t1 = t2 */
+057 if ((res = mp_copy (&t2, &t1)) != MP_OKAY) \{
+058 goto __T3;
+059 \}
+060
+061 /* t2 = t1 - ((t1**b - a) / (b * t1**(b-1))) */
+062
+063 /* t3 = t1**(b-1) */
+064 if ((res = mp_expt_d (&t1, b - 1, &t3)) != MP_OKAY) \{
+065 goto __T3;
+066 \}
+067
+068 /* numerator */
+069 /* t2 = t1**b */
+070 if ((res = mp_mul (&t3, &t1, &t2)) != MP_OKAY) \{
+071 goto __T3;
+072 \}
+073
+074 /* t2 = t1**b - a */
+075 if ((res = mp_sub (&t2, a, &t2)) != MP_OKAY) \{
+076 goto __T3;
+077 \}
+078
+079 /* denominator */
+080 /* t3 = t1**(b-1) * b */
+081 if ((res = mp_mul_d (&t3, b, &t3)) != MP_OKAY) \{
+082 goto __T3;
+083 \}
+084
+085 /* t3 = (t1**b - a)/(b * t1**(b-1)) */
+086 if ((res = mp_div (&t2, &t3, &t3, NULL)) != MP_OKAY) \{
+087 goto __T3;
+088 \}
+089
+090 if ((res = mp_sub (&t1, &t3, &t2)) != MP_OKAY) \{
+091 goto __T3;
+092 \}
+093 \} while (mp_cmp (&t1, &t2) != MP_EQ);
+094
+095 /* result can be off by a few so check */
+096 for (;;) \{
+097 if ((res = mp_expt_d (&t1, b, &t2)) != MP_OKAY) \{
+098 goto __T3;
+099 \}
+100
+101 if (mp_cmp (&t2, a) == MP_GT) \{
+102 if ((res = mp_sub_d (&t1, 1, &t1)) != MP_OKAY) \{
+103 goto __T3;
+104 \}
+105 \} else \{
+106 break;
+107 \}
+108 \}
+109
+110 /* reset the sign of a first */
+111 a->sign = neg;
+112
+113 /* set the result */
+114 mp_exch (&t1, c);
+115
+116 /* set the sign of the result */
+117 c->sign = neg;
+118
+119 res = MP_OKAY;
+120
+121 __T3:mp_clear (&t3);
+122 __T2:mp_clear (&t2);
+123 __T1:mp_clear (&t1);
+124 return res;
+125 \}
\end{alltt}
\end{small}
@@ -9057,40 +9038,39 @@ the integers from $0$ to $\beta - 1$.
\hspace{-5.1mm}{\bf File}: bn\_mp\_rand.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* makes a pseudo-random int of a given size */
-018 int
-019 mp_rand (mp_int * a, int digits)
-020 \{
-021 int res;
-022 mp_digit d;
-023
-024 mp_zero (a);
-025 if (digits <= 0) \{
-026 return MP_OKAY;
-027 \}
-028
-029 /* first place a random non-zero digit */
-030 do \{
-031 d = ((mp_digit) abs (rand ()));
-032 \} while (d == 0);
-033
-034 if ((res = mp_add_d (a, d, a)) != MP_OKAY) \{
-035 return res;
-036 \}
-037
-038 while (digits-- > 0) \{
-039 if ((res = mp_lshd (a, 1)) != MP_OKAY) \{
-040 return res;
-041 \}
-042
-043 if ((res = mp_add_d (a, ((mp_digit) abs (rand ())), a)) != MP_OKAY) \{
-044 return res;
-045 \}
-046 \}
-047
-048 return MP_OKAY;
-049 \}
+016 /* makes a pseudo-random int of a given size */
+017 int
+018 mp_rand (mp_int * a, int digits)
+019 \{
+020 int res;
+021 mp_digit d;
+022
+023 mp_zero (a);
+024 if (digits <= 0) \{
+025 return MP_OKAY;
+026 \}
+027
+028 /* first place a random non-zero digit */
+029 do \{
+030 d = ((mp_digit) abs (rand ()));
+031 \} while (d == 0);
+032
+033 if ((res = mp_add_d (a, d, a)) != MP_OKAY) \{
+034 return res;
+035 \}
+036
+037 while (digits-- > 0) \{
+038 if ((res = mp_lshd (a, 1)) != MP_OKAY) \{
+039 return res;
+040 \}
+041
+042 if ((res = mp_add_d (a, ((mp_digit) abs (rand ())), a)) != MP_OKAY) \{
+043 return res;
+044 \}
+045 \}
+046
+047 return MP_OKAY;
+048 \}
\end{alltt}
\end{small}
@@ -9173,67 +9153,66 @@ as part of larger input without any significant problem.
\hspace{-5.1mm}{\bf File}: bn\_mp\_read\_radix.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* read a string [ASCII] in a given radix */
-018 int mp_read_radix (mp_int * a, char *str, int radix)
-019 \{
-020 int y, res, neg;
-021 char ch;
-022
-023 /* make sure the radix is ok */
-024 if (radix < 2 || radix > 64) \{
-025 return MP_VAL;
-026 \}
-027
-028 /* if the leading digit is a
-029 * minus set the sign to negative.
-030 */
-031 if (*str == '-') \{
-032 ++str;
-033 neg = MP_NEG;
-034 \} else \{
-035 neg = MP_ZPOS;
-036 \}
-037
-038 /* set the integer to the default of zero */
-039 mp_zero (a);
-040
-041 /* process each digit of the string */
-042 while (*str) \{
-043 /* if the radix < 36 the conversion is case insensitive
-044 * this allows numbers like 1AB and 1ab to represent the same value
-045 * [e.g. in hex]
-046 */
-047 ch = (char) ((radix < 36) ? toupper (*str) : *str);
-048 for (y = 0; y < 64; y++) \{
-049 if (ch == mp_s_rmap[y]) \{
-050 break;
-051 \}
-052 \}
-053
-054 /* if the char was found in the map
-055 * and is less than the given radix add it
-056 * to the number, otherwise exit the loop.
-057 */
-058 if (y < radix) \{
-059 if ((res = mp_mul_d (a, (mp_digit) radix, a)) != MP_OKAY) \{
-060 return res;
-061 \}
-062 if ((res = mp_add_d (a, (mp_digit) y, a)) != MP_OKAY) \{
-063 return res;
-064 \}
-065 \} else \{
-066 break;
-067 \}
-068 ++str;
-069 \}
-070
-071 /* set the sign only if a != 0 */
-072 if (mp_iszero(a) != 1) \{
-073 a->sign = neg;
-074 \}
-075 return MP_OKAY;
-076 \}
+016 /* read a string [ASCII] in a given radix */
+017 int mp_read_radix (mp_int * a, char *str, int radix)
+018 \{
+019 int y, res, neg;
+020 char ch;
+021
+022 /* make sure the radix is ok */
+023 if (radix < 2 || radix > 64) \{
+024 return MP_VAL;
+025 \}
+026
+027 /* if the leading digit is a
+028 * minus set the sign to negative.
+029 */
+030 if (*str == '-') \{
+031 ++str;
+032 neg = MP_NEG;
+033 \} else \{
+034 neg = MP_ZPOS;
+035 \}
+036
+037 /* set the integer to the default of zero */
+038 mp_zero (a);
+039
+040 /* process each digit of the string */
+041 while (*str) \{
+042 /* if the radix < 36 the conversion is case insensitive
+043 * this allows numbers like 1AB and 1ab to represent the same value
+044 * [e.g. in hex]
+045 */
+046 ch = (char) ((radix < 36) ? toupper (*str) : *str);
+047 for (y = 0; y < 64; y++) \{
+048 if (ch == mp_s_rmap[y]) \{
+049 break;
+050 \}
+051 \}
+052
+053 /* if the char was found in the map
+054 * and is less than the given radix add it
+055 * to the number, otherwise exit the loop.
+056 */
+057 if (y < radix) \{
+058 if ((res = mp_mul_d (a, (mp_digit) radix, a)) != MP_OKAY) \{
+059 return res;
+060 \}
+061 if ((res = mp_add_d (a, (mp_digit) y, a)) != MP_OKAY) \{
+062 return res;
+063 \}
+064 \} else \{
+065 break;
+066 \}
+067 ++str;
+068 \}
+069
+070 /* set the sign only if a != 0 */
+071 if (mp_iszero(a) != 1) \{
+072 a->sign = neg;
+073 \}
+074 return MP_OKAY;
+075 \}
\end{alltt}
\end{small}
@@ -9298,60 +9277,59 @@ are required instead of a series of $n \times k$ divisions. One design flaw of
\hspace{-5.1mm}{\bf File}: bn\_mp\_toradix.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* stores a bignum as a ASCII string in a given radix (2..64) */
-018 int mp_toradix (mp_int * a, char *str, int radix)
-019 \{
-020 int res, digs;
-021 mp_int t;
-022 mp_digit d;
-023 char *_s = str;
-024
-025 /* check range of the radix */
-026 if (radix < 2 || radix > 64) \{
-027 return MP_VAL;
-028 \}
-029
-030 /* quick out if its zero */
-031 if (mp_iszero(a) == 1) \{
-032 *str++ = '0';
-033 *str = '\symbol{92}0';
-034 return MP_OKAY;
-035 \}
-036
-037 if ((res = mp_init_copy (&t, a)) != MP_OKAY) \{
-038 return res;
-039 \}
-040
-041 /* if it is negative output a - */
-042 if (t.sign == MP_NEG) \{
-043 ++_s;
-044 *str++ = '-';
-045 t.sign = MP_ZPOS;
-046 \}
-047
-048 digs = 0;
-049 while (mp_iszero (&t) == 0) \{
-050 if ((res = mp_div_d (&t, (mp_digit) radix, &t, &d)) != MP_OKAY) \{
-051 mp_clear (&t);
-052 return res;
-053 \}
-054 *str++ = mp_s_rmap[d];
-055 ++digs;
-056 \}
-057
-058 /* reverse the digits of the string. In this case _s points
-059 * to the first digit [exluding the sign] of the number]
-060 */
-061 bn_reverse ((unsigned char *)_s, digs);
-062
-063 /* append a NULL so the string is properly terminated */
-064 *str = '\symbol{92}0';
-065
-066 mp_clear (&t);
-067 return MP_OKAY;
-068 \}
-069
+016 /* stores a bignum as a ASCII string in a given radix (2..64) */
+017 int mp_toradix (mp_int * a, char *str, int radix)
+018 \{
+019 int res, digs;
+020 mp_int t;
+021 mp_digit d;
+022 char *_s = str;
+023
+024 /* check range of the radix */
+025 if (radix < 2 || radix > 64) \{
+026 return MP_VAL;
+027 \}
+028
+029 /* quick out if its zero */
+030 if (mp_iszero(a) == 1) \{
+031 *str++ = '0';
+032 *str = '\symbol{92}0';
+033 return MP_OKAY;
+034 \}
+035
+036 if ((res = mp_init_copy (&t, a)) != MP_OKAY) \{
+037 return res;
+038 \}
+039
+040 /* if it is negative output a - */
+041 if (t.sign == MP_NEG) \{
+042 ++_s;
+043 *str++ = '-';
+044 t.sign = MP_ZPOS;
+045 \}
+046
+047 digs = 0;
+048 while (mp_iszero (&t) == 0) \{
+049 if ((res = mp_div_d (&t, (mp_digit) radix, &t, &d)) != MP_OKAY) \{
+050 mp_clear (&t);
+051 return res;
+052 \}
+053 *str++ = mp_s_rmap[d];
+054 ++digs;
+055 \}
+056
+057 /* reverse the digits of the string. In this case _s points
+058 * to the first digit [exluding the sign] of the number]
+059 */
+060 bn_reverse ((unsigned char *)_s, digs);
+061
+062 /* append a NULL so the string is properly terminated */
+063 *str = '\symbol{92}0';
+064
+065 mp_clear (&t);
+066 return MP_OKAY;
+067 \}
+068
\end{alltt}
\end{small}
@@ -9539,115 +9517,114 @@ must be adjusted by multiplying by the common factors of two ($2^k$) removed ear
\hspace{-5.1mm}{\bf File}: bn\_mp\_gcd.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* Greatest Common Divisor using the binary method */
-018 int mp_gcd (mp_int * a, mp_int * b, mp_int * c)
-019 \{
-020 mp_int u, v;
-021 int k, u_lsb, v_lsb, res;
-022
-023 /* either zero than gcd is the largest */
-024 if (mp_iszero (a) == 1 && mp_iszero (b) == 0) \{
-025 return mp_abs (b, c);
-026 \}
-027 if (mp_iszero (a) == 0 && mp_iszero (b) == 1) \{
-028 return mp_abs (a, c);
-029 \}
-030
-031 /* optimized. At this point if a == 0 then
-032 * b must equal zero too
-033 */
-034 if (mp_iszero (a) == 1) \{
-035 mp_zero(c);
-036 return MP_OKAY;
-037 \}
-038
-039 /* get copies of a and b we can modify */
-040 if ((res = mp_init_copy (&u, a)) != MP_OKAY) \{
-041 return res;
-042 \}
-043
-044 if ((res = mp_init_copy (&v, b)) != MP_OKAY) \{
-045 goto __U;
-046 \}
-047
-048 /* must be positive for the remainder of the algorithm */
-049 u.sign = v.sign = MP_ZPOS;
-050
-051 /* B1. Find the common power of two for u and v */
-052 u_lsb = mp_cnt_lsb(&u);
-053 v_lsb = mp_cnt_lsb(&v);
-054 k = MIN(u_lsb, v_lsb);
-055
-056 if (k > 0) \{
-057 /* divide the power of two out */
-058 if ((res = mp_div_2d(&u, k, &u, NULL)) != MP_OKAY) \{
-059 goto __V;
-060 \}
-061
-062 if ((res = mp_div_2d(&v, k, &v, NULL)) != MP_OKAY) \{
-063 goto __V;
-064 \}
-065 \}
-066
-067 /* divide any remaining factors of two out */
-068 if (u_lsb != k) \{
-069 if ((res = mp_div_2d(&u, u_lsb - k, &u, NULL)) != MP_OKAY) \{
-070 goto __V;
-071 \}
-072 \}
-073
-074 if (v_lsb != k) \{
-075 if ((res = mp_div_2d(&v, v_lsb - k, &v, NULL)) != MP_OKAY) \{
-076 goto __V;
-077 \}
-078 \}
-079
-080 while (mp_iszero(&v) == 0) \{
-081 /* make sure v is the largest */
-082 if (mp_cmp_mag(&u, &v) == MP_GT) \{
-083 /* swap u and v to make sure v is >= u */
-084 mp_exch(&u, &v);
-085 \}
-086
-087 /* subtract smallest from largest */
-088 if ((res = s_mp_sub(&v, &u, &v)) != MP_OKAY) \{
-089 goto __V;
-090 \}
-091
-092 /* Divide out all factors of two */
-093 if ((res = mp_div_2d(&v, mp_cnt_lsb(&v), &v, NULL)) != MP_OKAY) \{
-094 goto __V;
-095 \}
-096 \}
-097
-098 /* multiply by 2**k which we divided out at the beginning */
-099 if ((res = mp_mul_2d (&u, k, c)) != MP_OKAY) \{
-100 goto __V;
-101 \}
-102 c->sign = MP_ZPOS;
-103 res = MP_OKAY;
-104 __V:mp_clear (&u);
-105 __U:mp_clear (&v);
-106 return res;
-107 \}
+016 /* Greatest Common Divisor using the binary method */
+017 int mp_gcd (mp_int * a, mp_int * b, mp_int * c)
+018 \{
+019 mp_int u, v;
+020 int k, u_lsb, v_lsb, res;
+021
+022 /* either zero than gcd is the largest */
+023 if (mp_iszero (a) == 1 && mp_iszero (b) == 0) \{
+024 return mp_abs (b, c);
+025 \}
+026 if (mp_iszero (a) == 0 && mp_iszero (b) == 1) \{
+027 return mp_abs (a, c);
+028 \}
+029
+030 /* optimized. At this point if a == 0 then
+031 * b must equal zero too
+032 */
+033 if (mp_iszero (a) == 1) \{
+034 mp_zero(c);
+035 return MP_OKAY;
+036 \}
+037
+038 /* get copies of a and b we can modify */
+039 if ((res = mp_init_copy (&u, a)) != MP_OKAY) \{
+040 return res;
+041 \}
+042
+043 if ((res = mp_init_copy (&v, b)) != MP_OKAY) \{
+044 goto __U;
+045 \}
+046
+047 /* must be positive for the remainder of the algorithm */
+048 u.sign = v.sign = MP_ZPOS;
+049
+050 /* B1. Find the common power of two for u and v */
+051 u_lsb = mp_cnt_lsb(&u);
+052 v_lsb = mp_cnt_lsb(&v);
+053 k = MIN(u_lsb, v_lsb);
+054
+055 if (k > 0) \{
+056 /* divide the power of two out */
+057 if ((res = mp_div_2d(&u, k, &u, NULL)) != MP_OKAY) \{
+058 goto __V;
+059 \}
+060
+061 if ((res = mp_div_2d(&v, k, &v, NULL)) != MP_OKAY) \{
+062 goto __V;
+063 \}
+064 \}
+065
+066 /* divide any remaining factors of two out */
+067 if (u_lsb != k) \{
+068 if ((res = mp_div_2d(&u, u_lsb - k, &u, NULL)) != MP_OKAY) \{
+069 goto __V;
+070 \}
+071 \}
+072
+073 if (v_lsb != k) \{
+074 if ((res = mp_div_2d(&v, v_lsb - k, &v, NULL)) != MP_OKAY) \{
+075 goto __V;
+076 \}
+077 \}
+078
+079 while (mp_iszero(&v) == 0) \{
+080 /* make sure v is the largest */
+081 if (mp_cmp_mag(&u, &v) == MP_GT) \{
+082 /* swap u and v to make sure v is >= u */
+083 mp_exch(&u, &v);
+084 \}
+085
+086 /* subtract smallest from largest */
+087 if ((res = s_mp_sub(&v, &u, &v)) != MP_OKAY) \{
+088 goto __V;
+089 \}
+090
+091 /* Divide out all factors of two */
+092 if ((res = mp_div_2d(&v, mp_cnt_lsb(&v), &v, NULL)) != MP_OKAY) \{
+093 goto __V;
+094 \}
+095 \}
+096
+097 /* multiply by 2**k which we divided out at the beginning */
+098 if ((res = mp_mul_2d (&u, k, c)) != MP_OKAY) \{
+099 goto __V;
+100 \}
+101 c->sign = MP_ZPOS;
+102 res = MP_OKAY;
+103 __V:mp_clear (&u);
+104 __U:mp_clear (&v);
+105 return res;
+106 \}
\end{alltt}
\end{small}
This function makes use of the macros mp\_iszero and mp\_iseven. The former evaluates to $1$ if the input mp\_int is equivalent to the
integer zero otherwise it evaluates to $0$. The latter evaluates to $1$ if the input mp\_int represents a non-zero even integer otherwise
it evaluates to $0$. Note that just because mp\_iseven may evaluate to $0$ does not mean the input is odd, it could also be zero. The three
-trivial cases of inputs are handled on lines 24 through 37. After those lines the inputs are assumed to be non-zero.
+trivial cases of inputs are handled on lines 26 through 36. After those lines the inputs are assumed to be non-zero.
-Lines 34 and 40 make local copies $u$ and $v$ of the inputs $a$ and $b$ respectively. At this point the common factors of two
-must be divided out of the two inputs. The while loop on line 80 iterates so long as both are even. The local integer $k$ is used to
+Lines 38 and 39 make local copies $u$ and $v$ of the inputs $a$ and $b$ respectively. At this point the common factors of two
+must be divided out of the two inputs. The while loop on line 79 iterates so long as both are even. The local integer $k$ is used to
keep track of how many factors of $2$ are pulled out of both values. It is assumed that the number of factors will not exceed the maximum
value of a C ``int'' data type\footnote{Strictly speaking no array in C may have more than entries than are accessible by an ``int'' so this is not
a limitation.}.
-At this point there are no more common factors of two in the two values. The while loops on lines 80 and 80 remove any independent
+At this point there are no more common factors of two in the two values. The while loops on lines 79 and 79 remove any independent
factors of two such that both $u$ and $v$ are guaranteed to be an odd integer before hitting the main body of the algorithm. The while loop
-on line 80 performs the reduction of the pair until $v$ is equal to zero. The unsigned comparison and subtraction algorithms are used in
+on line 79 performs the reduction of the pair until $v$ is equal to zero. The unsigned comparison and subtraction algorithms are used in
place of the full signed routines since both values are guaranteed to be positive and the result of the subtraction is guaranteed to be non-negative.
\section{Least Common Multiple}
@@ -9686,45 +9663,44 @@ dividing the product of the two inputs by their greatest common divisor.
\hspace{-5.1mm}{\bf File}: bn\_mp\_lcm.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* computes least common multiple as |a*b|/(a, b) */
-018 int mp_lcm (mp_int * a, mp_int * b, mp_int * c)
-019 \{
-020 int res;
-021 mp_int t1, t2;
+016 /* computes least common multiple as |a*b|/(a, b) */
+017 int mp_lcm (mp_int * a, mp_int * b, mp_int * c)
+018 \{
+019 int res;
+020 mp_int t1, t2;
+021
022
-023
-024 if ((res = mp_init_multi (&t1, &t2, NULL)) != MP_OKAY) \{
-025 return res;
-026 \}
-027
-028 /* t1 = get the GCD of the two inputs */
-029 if ((res = mp_gcd (a, b, &t1)) != MP_OKAY) \{
-030 goto __T;
-031 \}
-032
-033 /* divide the smallest by the GCD */
-034 if (mp_cmp_mag(a, b) == MP_LT) \{
-035 /* store quotient in t2 such that t2 * b is the LCM */
-036 if ((res = mp_div(a, &t1, &t2, NULL)) != MP_OKAY) \{
-037 goto __T;
-038 \}
-039 res = mp_mul(b, &t2, c);
-040 \} else \{
-041 /* store quotient in t2 such that t2 * a is the LCM */
-042 if ((res = mp_div(b, &t1, &t2, NULL)) != MP_OKAY) \{
-043 goto __T;
-044 \}
-045 res = mp_mul(a, &t2, c);
-046 \}
-047
-048 /* fix the sign to positive */
-049 c->sign = MP_ZPOS;
-050
-051 __T:
-052 mp_clear_multi (&t1, &t2, NULL);
-053 return res;
-054 \}
+023 if ((res = mp_init_multi (&t1, &t2, NULL)) != MP_OKAY) \{
+024 return res;
+025 \}
+026
+027 /* t1 = get the GCD of the two inputs */
+028 if ((res = mp_gcd (a, b, &t1)) != MP_OKAY) \{
+029 goto __T;
+030 \}
+031
+032 /* divide the smallest by the GCD */
+033 if (mp_cmp_mag(a, b) == MP_LT) \{
+034 /* store quotient in t2 such that t2 * b is the LCM */
+035 if ((res = mp_div(a, &t1, &t2, NULL)) != MP_OKAY) \{
+036 goto __T;
+037 \}
+038 res = mp_mul(b, &t2, c);
+039 \} else \{
+040 /* store quotient in t2 such that t2 * a is the LCM */
+041 if ((res = mp_div(b, &t1, &t2, NULL)) != MP_OKAY) \{
+042 goto __T;
+043 \}
+044 res = mp_mul(a, &t2, c);
+045 \}
+046
+047 /* fix the sign to positive */
+048 c->sign = MP_ZPOS;
+049
+050 __T:
+051 mp_clear_multi (&t1, &t2, NULL);
+052 return res;
+053 \}
\end{alltt}
\end{small}
@@ -9882,90 +9858,89 @@ $\left ( {p' \over a'} \right )$ which is multiplied against the current Jacobi
\hspace{-5.1mm}{\bf File}: bn\_mp\_jacobi.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* computes the jacobi c = (a | n) (or Legendre if n is prime)
-018 * HAC pp. 73 Algorithm 2.149
-019 */
-020 int mp_jacobi (mp_int * a, mp_int * p, int *c)
-021 \{
-022 mp_int a1, p1;
-023 int k, s, r, res;
-024 mp_digit residue;
-025
-026 /* if p <= 0 return MP_VAL */
-027 if (mp_cmp_d(p, 0) != MP_GT) \{
-028 return MP_VAL;
-029 \}
-030
-031 /* step 1. if a == 0, return 0 */
-032 if (mp_iszero (a) == 1) \{
-033 *c = 0;
-034 return MP_OKAY;
-035 \}
-036
-037 /* step 2. if a == 1, return 1 */
-038 if (mp_cmp_d (a, 1) == MP_EQ) \{
-039 *c = 1;
-040 return MP_OKAY;
-041 \}
-042
-043 /* default */
-044 s = 0;
-045
-046 /* step 3. write a = a1 * 2**k */
-047 if ((res = mp_init_copy (&a1, a)) != MP_OKAY) \{
-048 return res;
-049 \}
-050
-051 if ((res = mp_init (&p1)) != MP_OKAY) \{
-052 goto __A1;
-053 \}
-054
-055 /* divide out larger power of two */
-056 k = mp_cnt_lsb(&a1);
-057 if ((res = mp_div_2d(&a1, k, &a1, NULL)) != MP_OKAY) \{
-058 goto __P1;
-059 \}
-060
-061 /* step 4. if e is even set s=1 */
-062 if ((k & 1) == 0) \{
-063 s = 1;
-064 \} else \{
-065 /* else set s=1 if p = 1/7 (mod 8) or s=-1 if p = 3/5 (mod 8) */
-066 residue = p->dp[0] & 7;
-067
-068 if (residue == 1 || residue == 7) \{
-069 s = 1;
-070 \} else if (residue == 3 || residue == 5) \{
-071 s = -1;
-072 \}
-073 \}
-074
-075 /* step 5. if p == 3 (mod 4) *and* a1 == 3 (mod 4) then s = -s */
-076 if ( ((p->dp[0] & 3) == 3) && ((a1.dp[0] & 3) == 3)) \{
-077 s = -s;
-078 \}
-079
-080 /* if a1 == 1 we're done */
-081 if (mp_cmp_d (&a1, 1) == MP_EQ) \{
-082 *c = s;
-083 \} else \{
-084 /* n1 = n mod a1 */
-085 if ((res = mp_mod (p, &a1, &p1)) != MP_OKAY) \{
-086 goto __P1;
-087 \}
-088 if ((res = mp_jacobi (&p1, &a1, &r)) != MP_OKAY) \{
-089 goto __P1;
-090 \}
-091 *c = s * r;
-092 \}
-093
-094 /* done */
-095 res = MP_OKAY;
-096 __P1:mp_clear (&p1);
-097 __A1:mp_clear (&a1);
-098 return res;
-099 \}
+016 /* computes the jacobi c = (a | n) (or Legendre if n is prime)
+017 * HAC pp. 73 Algorithm 2.149
+018 */
+019 int mp_jacobi (mp_int * a, mp_int * p, int *c)
+020 \{
+021 mp_int a1, p1;
+022 int k, s, r, res;
+023 mp_digit residue;
+024
+025 /* if p <= 0 return MP_VAL */
+026 if (mp_cmp_d(p, 0) != MP_GT) \{
+027 return MP_VAL;
+028 \}
+029
+030 /* step 1. if a == 0, return 0 */
+031 if (mp_iszero (a) == 1) \{
+032 *c = 0;
+033 return MP_OKAY;
+034 \}
+035
+036 /* step 2. if a == 1, return 1 */
+037 if (mp_cmp_d (a, 1) == MP_EQ) \{
+038 *c = 1;
+039 return MP_OKAY;
+040 \}
+041
+042 /* default */
+043 s = 0;
+044
+045 /* step 3. write a = a1 * 2**k */
+046 if ((res = mp_init_copy (&a1, a)) != MP_OKAY) \{
+047 return res;
+048 \}
+049
+050 if ((res = mp_init (&p1)) != MP_OKAY) \{
+051 goto __A1;
+052 \}
+053
+054 /* divide out larger power of two */
+055 k = mp_cnt_lsb(&a1);
+056 if ((res = mp_div_2d(&a1, k, &a1, NULL)) != MP_OKAY) \{
+057 goto __P1;
+058 \}
+059
+060 /* step 4. if e is even set s=1 */
+061 if ((k & 1) == 0) \{
+062 s = 1;
+063 \} else \{
+064 /* else set s=1 if p = 1/7 (mod 8) or s=-1 if p = 3/5 (mod 8) */
+065 residue = p->dp[0] & 7;
+066
+067 if (residue == 1 || residue == 7) \{
+068 s = 1;
+069 \} else if (residue == 3 || residue == 5) \{
+070 s = -1;
+071 \}
+072 \}
+073
+074 /* step 5. if p == 3 (mod 4) *and* a1 == 3 (mod 4) then s = -s */
+075 if ( ((p->dp[0] & 3) == 3) && ((a1.dp[0] & 3) == 3)) \{
+076 s = -s;
+077 \}
+078
+079 /* if a1 == 1 we're done */
+080 if (mp_cmp_d (&a1, 1) == MP_EQ) \{
+081 *c = s;
+082 \} else \{
+083 /* n1 = n mod a1 */
+084 if ((res = mp_mod (p, &a1, &p1)) != MP_OKAY) \{
+085 goto __P1;
+086 \}
+087 if ((res = mp_jacobi (&p1, &a1, &r)) != MP_OKAY) \{
+088 goto __P1;
+089 \}
+090 *c = s * r;
+091 \}
+092
+093 /* done */
+094 res = MP_OKAY;
+095 __P1:mp_clear (&p1);
+096 __A1:mp_clear (&a1);
+097 return res;
+098 \}
\end{alltt}
\end{small}
@@ -9980,9 +9955,9 @@ After a local copy of $a$ is made all of the factors of two are divided out and
bit of $k$ is required, however, it makes the algorithm simpler to follow to perform an addition. In practice an exclusive-or and addition have the same
processor requirements and neither is faster than the other.
-Line 61 through 70 determines the value of $\left ( { 2 \over p } \right )^k$. If the least significant bit of $k$ is zero than
+Line 60 through 71 determines the value of $\left ( { 2 \over p } \right )^k$. If the least significant bit of $k$ is zero than
$k$ is even and the value is one. Otherwise, the value of $s$ depends on which residue class $p$ belongs to modulo eight. The value of
-$(-1)^{(p-1)(a'-1)/4}$ is compute and multiplied against $s$ on lines 75 through 73.
+$(-1)^{(p-1)(a'-1)/4}$ is compute and multiplied against $s$ on lines 74 through 77.
Finally, if $a1$ does not equal one the algorithm must recurse and compute $\left ( {p' \over a'} \right )$.
@@ -10091,165 +10066,164 @@ then only a couple of additions or subtractions will be required to adjust the i
\hspace{-5.1mm}{\bf File}: bn\_mp\_invmod.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* hac 14.61, pp608 */
-018 int mp_invmod (mp_int * a, mp_int * b, mp_int * c)
-019 \{
-020 mp_int x, y, u, v, A, B, C, D;
-021 int res;
-022
-023 /* b cannot be negative */
-024 if (b->sign == MP_NEG || mp_iszero(b) == 1) \{
-025 return MP_VAL;
-026 \}
-027
-028 /* if the modulus is odd we can use a faster routine instead */
-029 if (mp_isodd (b) == 1) \{
-030 return fast_mp_invmod (a, b, c);
-031 \}
-032
-033 /* init temps */
-034 if ((res = mp_init_multi(&x, &y, &u, &v,
-035 &A, &B, &C, &D, NULL)) != MP_OKAY) \{
-036 return res;
-037 \}
-038
-039 /* x = a, y = b */
-040 if ((res = mp_copy (a, &x)) != MP_OKAY) \{
-041 goto __ERR;
-042 \}
-043 if ((res = mp_copy (b, &y)) != MP_OKAY) \{
-044 goto __ERR;
-045 \}
-046
-047 /* 2. [modified] if x,y are both even then return an error! */
-048 if (mp_iseven (&x) == 1 && mp_iseven (&y) == 1) \{
-049 res = MP_VAL;
-050 goto __ERR;
-051 \}
-052
-053 /* 3. u=x, v=y, A=1, B=0, C=0,D=1 */
-054 if ((res = mp_copy (&x, &u)) != MP_OKAY) \{
-055 goto __ERR;
-056 \}
-057 if ((res = mp_copy (&y, &v)) != MP_OKAY) \{
-058 goto __ERR;
-059 \}
-060 mp_set (&A, 1);
-061 mp_set (&D, 1);
-062
-063 top:
-064 /* 4. while u is even do */
-065 while (mp_iseven (&u) == 1) \{
-066 /* 4.1 u = u/2 */
-067 if ((res = mp_div_2 (&u, &u)) != MP_OKAY) \{
-068 goto __ERR;
-069 \}
-070 /* 4.2 if A or B is odd then */
-071 if (mp_isodd (&A) == 1 || mp_isodd (&B) == 1) \{
-072 /* A = (A+y)/2, B = (B-x)/2 */
-073 if ((res = mp_add (&A, &y, &A)) != MP_OKAY) \{
-074 goto __ERR;
-075 \}
-076 if ((res = mp_sub (&B, &x, &B)) != MP_OKAY) \{
-077 goto __ERR;
-078 \}
-079 \}
-080 /* A = A/2, B = B/2 */
-081 if ((res = mp_div_2 (&A, &A)) != MP_OKAY) \{
-082 goto __ERR;
-083 \}
-084 if ((res = mp_div_2 (&B, &B)) != MP_OKAY) \{
-085 goto __ERR;
-086 \}
-087 \}
-088
-089 /* 5. while v is even do */
-090 while (mp_iseven (&v) == 1) \{
-091 /* 5.1 v = v/2 */
-092 if ((res = mp_div_2 (&v, &v)) != MP_OKAY) \{
-093 goto __ERR;
-094 \}
-095 /* 5.2 if C or D is odd then */
-096 if (mp_isodd (&C) == 1 || mp_isodd (&D) == 1) \{
-097 /* C = (C+y)/2, D = (D-x)/2 */
-098 if ((res = mp_add (&C, &y, &C)) != MP_OKAY) \{
-099 goto __ERR;
-100 \}
-101 if ((res = mp_sub (&D, &x, &D)) != MP_OKAY) \{
-102 goto __ERR;
-103 \}
-104 \}
-105 /* C = C/2, D = D/2 */
-106 if ((res = mp_div_2 (&C, &C)) != MP_OKAY) \{
-107 goto __ERR;
-108 \}
-109 if ((res = mp_div_2 (&D, &D)) != MP_OKAY) \{
-110 goto __ERR;
-111 \}
-112 \}
-113
-114 /* 6. if u >= v then */
-115 if (mp_cmp (&u, &v) != MP_LT) \{
-116 /* u = u - v, A = A - C, B = B - D */
-117 if ((res = mp_sub (&u, &v, &u)) != MP_OKAY) \{
-118 goto __ERR;
-119 \}
-120
-121 if ((res = mp_sub (&A, &C, &A)) != MP_OKAY) \{
-122 goto __ERR;
-123 \}
-124
-125 if ((res = mp_sub (&B, &D, &B)) != MP_OKAY) \{
-126 goto __ERR;
-127 \}
-128 \} else \{
-129 /* v - v - u, C = C - A, D = D - B */
-130 if ((res = mp_sub (&v, &u, &v)) != MP_OKAY) \{
-131 goto __ERR;
-132 \}
-133
-134 if ((res = mp_sub (&C, &A, &C)) != MP_OKAY) \{
-135 goto __ERR;
-136 \}
-137
-138 if ((res = mp_sub (&D, &B, &D)) != MP_OKAY) \{
-139 goto __ERR;
-140 \}
-141 \}
-142
-143 /* if not zero goto step 4 */
-144 if (mp_iszero (&u) == 0)
-145 goto top;
-146
-147 /* now a = C, b = D, gcd == g*v */
-148
-149 /* if v != 1 then there is no inverse */
-150 if (mp_cmp_d (&v, 1) != MP_EQ) \{
-151 res = MP_VAL;
-152 goto __ERR;
-153 \}
-154
-155 /* if its too low */
-156 while (mp_cmp_d(&C, 0) == MP_LT) \{
-157 if ((res = mp_add(&C, b, &C)) != MP_OKAY) \{
-158 goto __ERR;
-159 \}
-160 \}
-161
-162 /* too big */
-163 while (mp_cmp_mag(&C, b) != MP_LT) \{
-164 if ((res = mp_sub(&C, b, &C)) != MP_OKAY) \{
-165 goto __ERR;
-166 \}
-167 \}
-168
-169 /* C is now the inverse */
-170 mp_exch (&C, c);
-171 res = MP_OKAY;
-172 __ERR:mp_clear_multi (&x, &y, &u, &v, &A, &B, &C, &D, NULL);
-173 return res;
-174 \}
+016 /* hac 14.61, pp608 */
+017 int mp_invmod (mp_int * a, mp_int * b, mp_int * c)
+018 \{
+019 mp_int x, y, u, v, A, B, C, D;
+020 int res;
+021
+022 /* b cannot be negative */
+023 if (b->sign == MP_NEG || mp_iszero(b) == 1) \{
+024 return MP_VAL;
+025 \}
+026
+027 /* if the modulus is odd we can use a faster routine instead */
+028 if (mp_isodd (b) == 1) \{
+029 return fast_mp_invmod (a, b, c);
+030 \}
+031
+032 /* init temps */
+033 if ((res = mp_init_multi(&x, &y, &u, &v,
+034 &A, &B, &C, &D, NULL)) != MP_OKAY) \{
+035 return res;
+036 \}
+037
+038 /* x = a, y = b */
+039 if ((res = mp_copy (a, &x)) != MP_OKAY) \{
+040 goto __ERR;
+041 \}
+042 if ((res = mp_copy (b, &y)) != MP_OKAY) \{
+043 goto __ERR;
+044 \}
+045
+046 /* 2. [modified] if x,y are both even then return an error! */
+047 if (mp_iseven (&x) == 1 && mp_iseven (&y) == 1) \{
+048 res = MP_VAL;
+049 goto __ERR;
+050 \}
+051
+052 /* 3. u=x, v=y, A=1, B=0, C=0,D=1 */
+053 if ((res = mp_copy (&x, &u)) != MP_OKAY) \{
+054 goto __ERR;
+055 \}
+056 if ((res = mp_copy (&y, &v)) != MP_OKAY) \{
+057 goto __ERR;
+058 \}
+059 mp_set (&A, 1);
+060 mp_set (&D, 1);
+061
+062 top:
+063 /* 4. while u is even do */
+064 while (mp_iseven (&u) == 1) \{
+065 /* 4.1 u = u/2 */
+066 if ((res = mp_div_2 (&u, &u)) != MP_OKAY) \{
+067 goto __ERR;
+068 \}
+069 /* 4.2 if A or B is odd then */
+070 if (mp_isodd (&A) == 1 || mp_isodd (&B) == 1) \{
+071 /* A = (A+y)/2, B = (B-x)/2 */
+072 if ((res = mp_add (&A, &y, &A)) != MP_OKAY) \{
+073 goto __ERR;
+074 \}
+075 if ((res = mp_sub (&B, &x, &B)) != MP_OKAY) \{
+076 goto __ERR;
+077 \}
+078 \}
+079 /* A = A/2, B = B/2 */
+080 if ((res = mp_div_2 (&A, &A)) != MP_OKAY) \{
+081 goto __ERR;
+082 \}
+083 if ((res = mp_div_2 (&B, &B)) != MP_OKAY) \{
+084 goto __ERR;
+085 \}
+086 \}
+087
+088 /* 5. while v is even do */
+089 while (mp_iseven (&v) == 1) \{
+090 /* 5.1 v = v/2 */
+091 if ((res = mp_div_2 (&v, &v)) != MP_OKAY) \{
+092 goto __ERR;
+093 \}
+094 /* 5.2 if C or D is odd then */
+095 if (mp_isodd (&C) == 1 || mp_isodd (&D) == 1) \{
+096 /* C = (C+y)/2, D = (D-x)/2 */
+097 if ((res = mp_add (&C, &y, &C)) != MP_OKAY) \{
+098 goto __ERR;
+099 \}
+100 if ((res = mp_sub (&D, &x, &D)) != MP_OKAY) \{
+101 goto __ERR;
+102 \}
+103 \}
+104 /* C = C/2, D = D/2 */
+105 if ((res = mp_div_2 (&C, &C)) != MP_OKAY) \{
+106 goto __ERR;
+107 \}
+108 if ((res = mp_div_2 (&D, &D)) != MP_OKAY) \{
+109 goto __ERR;
+110 \}
+111 \}
+112
+113 /* 6. if u >= v then */
+114 if (mp_cmp (&u, &v) != MP_LT) \{
+115 /* u = u - v, A = A - C, B = B - D */
+116 if ((res = mp_sub (&u, &v, &u)) != MP_OKAY) \{
+117 goto __ERR;
+118 \}
+119
+120 if ((res = mp_sub (&A, &C, &A)) != MP_OKAY) \{
+121 goto __ERR;
+122 \}
+123
+124 if ((res = mp_sub (&B, &D, &B)) != MP_OKAY) \{
+125 goto __ERR;
+126 \}
+127 \} else \{
+128 /* v - v - u, C = C - A, D = D - B */
+129 if ((res = mp_sub (&v, &u, &v)) != MP_OKAY) \{
+130 goto __ERR;
+131 \}
+132
+133 if ((res = mp_sub (&C, &A, &C)) != MP_OKAY) \{
+134 goto __ERR;
+135 \}
+136
+137 if ((res = mp_sub (&D, &B, &D)) != MP_OKAY) \{
+138 goto __ERR;
+139 \}
+140 \}
+141
+142 /* if not zero goto step 4 */
+143 if (mp_iszero (&u) == 0)
+144 goto top;
+145
+146 /* now a = C, b = D, gcd == g*v */
+147
+148 /* if v != 1 then there is no inverse */
+149 if (mp_cmp_d (&v, 1) != MP_EQ) \{
+150 res = MP_VAL;
+151 goto __ERR;
+152 \}
+153
+154 /* if its too low */
+155 while (mp_cmp_d(&C, 0) == MP_LT) \{
+156 if ((res = mp_add(&C, b, &C)) != MP_OKAY) \{
+157 goto __ERR;
+158 \}
+159 \}
+160
+161 /* too big */
+162 while (mp_cmp_mag(&C, b) != MP_LT) \{
+163 if ((res = mp_sub(&C, b, &C)) != MP_OKAY) \{
+164 goto __ERR;
+165 \}
+166 \}
+167
+168 /* C is now the inverse */
+169 mp_exch (&C, c);
+170 res = MP_OKAY;
+171 __ERR:mp_clear_multi (&x, &y, &u, &v, &A, &B, &C, &D, NULL);
+172 return res;
+173 \}
\end{alltt}
\end{small}
@@ -10321,35 +10295,34 @@ This algorithm attempts to determine if a candidate integer $n$ is composite by
\hspace{-5.1mm}{\bf File}: bn\_mp\_prime\_is\_divisible.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* determines if an integers is divisible by one
-018 * of the first PRIME_SIZE primes or not
-019 *
-020 * sets result to 0 if not, 1 if yes
-021 */
-022 int mp_prime_is_divisible (mp_int * a, int *result)
-023 \{
-024 int err, ix;
-025 mp_digit res;
-026
-027 /* default to not */
-028 *result = MP_NO;
-029
-030 for (ix = 0; ix < PRIME_SIZE; ix++) \{
-031 /* what is a mod __prime_tab[ix] */
-032 if ((err = mp_mod_d (a, __prime_tab[ix], &res)) != MP_OKAY) \{
-033 return err;
-034 \}
-035
-036 /* is the residue zero? */
-037 if (res == 0) \{
-038 *result = MP_YES;
-039 return MP_OKAY;
-040 \}
-041 \}
-042
-043 return MP_OKAY;
-044 \}
+016 /* determines if an integers is divisible by one
+017 * of the first PRIME_SIZE primes or not
+018 *
+019 * sets result to 0 if not, 1 if yes
+020 */
+021 int mp_prime_is_divisible (mp_int * a, int *result)
+022 \{
+023 int err, ix;
+024 mp_digit res;
+025
+026 /* default to not */
+027 *result = MP_NO;
+028
+029 for (ix = 0; ix < PRIME_SIZE; ix++) \{
+030 /* what is a mod __prime_tab[ix] */
+031 if ((err = mp_mod_d (a, __prime_tab[ix], &res)) != MP_OKAY) \{
+032 return err;
+033 \}
+034
+035 /* is the residue zero? */
+036 if (res == 0) \{
+037 *result = MP_YES;
+038 return MP_OKAY;
+039 \}
+040 \}
+041
+042 return MP_OKAY;
+043 \}
\end{alltt}
\end{small}
@@ -10360,46 +10333,45 @@ mp\_digit. The table \_\_prime\_tab is defined in the following file.
\hspace{-5.1mm}{\bf File}: bn\_prime\_tab.c
\vspace{-3mm}
\begin{alltt}
-016 const mp_digit __prime_tab[] = \{
-017 0x0002, 0x0003, 0x0005, 0x0007, 0x000B, 0x000D, 0x0011, 0x0013,
-018 0x0017, 0x001D, 0x001F, 0x0025, 0x0029, 0x002B, 0x002F, 0x0035,
-019 0x003B, 0x003D, 0x0043, 0x0047, 0x0049, 0x004F, 0x0053, 0x0059,
-020 0x0061, 0x0065, 0x0067, 0x006B, 0x006D, 0x0071, 0x007F,
-021 #ifndef MP_8BIT
-022 0x0083,
-023 0x0089, 0x008B, 0x0095, 0x0097, 0x009D, 0x00A3, 0x00A7, 0x00AD,
-024 0x00B3, 0x00B5, 0x00BF, 0x00C1, 0x00C5, 0x00C7, 0x00D3, 0x00DF,
-025 0x00E3, 0x00E5, 0x00E9, 0x00EF, 0x00F1, 0x00FB, 0x0101, 0x0107,
-026 0x010D, 0x010F, 0x0115, 0x0119, 0x011B, 0x0125, 0x0133, 0x0137,
-027
-028 0x0139, 0x013D, 0x014B, 0x0151, 0x015B, 0x015D, 0x0161, 0x0167,
-029 0x016F, 0x0175, 0x017B, 0x017F, 0x0185, 0x018D, 0x0191, 0x0199,
-030 0x01A3, 0x01A5, 0x01AF, 0x01B1, 0x01B7, 0x01BB, 0x01C1, 0x01C9,
-031 0x01CD, 0x01CF, 0x01D3, 0x01DF, 0x01E7, 0x01EB, 0x01F3, 0x01F7,
-032 0x01FD, 0x0209, 0x020B, 0x021D, 0x0223, 0x022D, 0x0233, 0x0239,
-033 0x023B, 0x0241, 0x024B, 0x0251, 0x0257, 0x0259, 0x025F, 0x0265,
-034 0x0269, 0x026B, 0x0277, 0x0281, 0x0283, 0x0287, 0x028D, 0x0293,
-035 0x0295, 0x02A1, 0x02A5, 0x02AB, 0x02B3, 0x02BD, 0x02C5, 0x02CF,
-036
-037 0x02D7, 0x02DD, 0x02E3, 0x02E7, 0x02EF, 0x02F5, 0x02F9, 0x0301,
-038 0x0305, 0x0313, 0x031D, 0x0329, 0x032B, 0x0335, 0x0337, 0x033B,
-039 0x033D, 0x0347, 0x0355, 0x0359, 0x035B, 0x035F, 0x036D, 0x0371,
-040 0x0373, 0x0377, 0x038B, 0x038F, 0x0397, 0x03A1, 0x03A9, 0x03AD,
-041 0x03B3, 0x03B9, 0x03C7, 0x03CB, 0x03D1, 0x03D7, 0x03DF, 0x03E5,
-042 0x03F1, 0x03F5, 0x03FB, 0x03FD, 0x0407, 0x0409, 0x040F, 0x0419,
-043 0x041B, 0x0425, 0x0427, 0x042D, 0x043F, 0x0443, 0x0445, 0x0449,
-044 0x044F, 0x0455, 0x045D, 0x0463, 0x0469, 0x047F, 0x0481, 0x048B,
-045
-046 0x0493, 0x049D, 0x04A3, 0x04A9, 0x04B1, 0x04BD, 0x04C1, 0x04C7,
-047 0x04CD, 0x04CF, 0x04D5, 0x04E1, 0x04EB, 0x04FD, 0x04FF, 0x0503,
-048 0x0509, 0x050B, 0x0511, 0x0515, 0x0517, 0x051B, 0x0527, 0x0529,
-049 0x052F, 0x0551, 0x0557, 0x055D, 0x0565, 0x0577, 0x0581, 0x058F,
-050 0x0593, 0x0595, 0x0599, 0x059F, 0x05A7, 0x05AB, 0x05AD, 0x05B3,
-051 0x05BF, 0x05C9, 0x05CB, 0x05CF, 0x05D1, 0x05D5, 0x05DB, 0x05E7,
-052 0x05F3, 0x05FB, 0x0607, 0x060D, 0x0611, 0x0617, 0x061F, 0x0623,
-053 0x062B, 0x062F, 0x063D, 0x0641, 0x0647, 0x0649, 0x064D, 0x0653
-054 #endif
-055 \};
+016 0x0002, 0x0003, 0x0005, 0x0007, 0x000B, 0x000D, 0x0011, 0x0013,
+017 0x0017, 0x001D, 0x001F, 0x0025, 0x0029, 0x002B, 0x002F, 0x0035,
+018 0x003B, 0x003D, 0x0043, 0x0047, 0x0049, 0x004F, 0x0053, 0x0059,
+019 0x0061, 0x0065, 0x0067, 0x006B, 0x006D, 0x0071, 0x007F,
+020 #ifndef MP_8BIT
+021 0x0083,
+022 0x0089, 0x008B, 0x0095, 0x0097, 0x009D, 0x00A3, 0x00A7, 0x00AD,
+023 0x00B3, 0x00B5, 0x00BF, 0x00C1, 0x00C5, 0x00C7, 0x00D3, 0x00DF,
+024 0x00E3, 0x00E5, 0x00E9, 0x00EF, 0x00F1, 0x00FB, 0x0101, 0x0107,
+025 0x010D, 0x010F, 0x0115, 0x0119, 0x011B, 0x0125, 0x0133, 0x0137,
+026
+027 0x0139, 0x013D, 0x014B, 0x0151, 0x015B, 0x015D, 0x0161, 0x0167,
+028 0x016F, 0x0175, 0x017B, 0x017F, 0x0185, 0x018D, 0x0191, 0x0199,
+029 0x01A3, 0x01A5, 0x01AF, 0x01B1, 0x01B7, 0x01BB, 0x01C1, 0x01C9,
+030 0x01CD, 0x01CF, 0x01D3, 0x01DF, 0x01E7, 0x01EB, 0x01F3, 0x01F7,
+031 0x01FD, 0x0209, 0x020B, 0x021D, 0x0223, 0x022D, 0x0233, 0x0239,
+032 0x023B, 0x0241, 0x024B, 0x0251, 0x0257, 0x0259, 0x025F, 0x0265,
+033 0x0269, 0x026B, 0x0277, 0x0281, 0x0283, 0x0287, 0x028D, 0x0293,
+034 0x0295, 0x02A1, 0x02A5, 0x02AB, 0x02B3, 0x02BD, 0x02C5, 0x02CF,
+035
+036 0x02D7, 0x02DD, 0x02E3, 0x02E7, 0x02EF, 0x02F5, 0x02F9, 0x0301,
+037 0x0305, 0x0313, 0x031D, 0x0329, 0x032B, 0x0335, 0x0337, 0x033B,
+038 0x033D, 0x0347, 0x0355, 0x0359, 0x035B, 0x035F, 0x036D, 0x0371,
+039 0x0373, 0x0377, 0x038B, 0x038F, 0x0397, 0x03A1, 0x03A9, 0x03AD,
+040 0x03B3, 0x03B9, 0x03C7, 0x03CB, 0x03D1, 0x03D7, 0x03DF, 0x03E5,
+041 0x03F1, 0x03F5, 0x03FB, 0x03FD, 0x0407, 0x0409, 0x040F, 0x0419,
+042 0x041B, 0x0425, 0x0427, 0x042D, 0x043F, 0x0443, 0x0445, 0x0449,
+043 0x044F, 0x0455, 0x045D, 0x0463, 0x0469, 0x047F, 0x0481, 0x048B,
+044
+045 0x0493, 0x049D, 0x04A3, 0x04A9, 0x04B1, 0x04BD, 0x04C1, 0x04C7,
+046 0x04CD, 0x04CF, 0x04D5, 0x04E1, 0x04EB, 0x04FD, 0x04FF, 0x0503,
+047 0x0509, 0x050B, 0x0511, 0x0515, 0x0517, 0x051B, 0x0527, 0x0529,
+048 0x052F, 0x0551, 0x0557, 0x055D, 0x0565, 0x0577, 0x0581, 0x058F,
+049 0x0593, 0x0595, 0x0599, 0x059F, 0x05A7, 0x05AB, 0x05AD, 0x05B3,
+050 0x05BF, 0x05C9, 0x05CB, 0x05CF, 0x05D1, 0x05D5, 0x05DB, 0x05E7,
+051 0x05F3, 0x05FB, 0x0607, 0x060D, 0x0611, 0x0617, 0x061F, 0x0623,
+052 0x062B, 0x062F, 0x063D, 0x0641, 0x0647, 0x0649, 0x064D, 0x0653
+053 #endif
+054 \};
\end{alltt}
\end{small}
@@ -10446,47 +10418,46 @@ determine the result.
\hspace{-5.1mm}{\bf File}: bn\_mp\_prime\_fermat.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* performs one Fermat test.
-018 *
-019 * If "a" were prime then b**a == b (mod a) since the order of
-020 * the multiplicative sub-group would be phi(a) = a-1. That means
-021 * it would be the same as b**(a mod (a-1)) == b**1 == b (mod a).
-022 *
-023 * Sets result to 1 if the congruence holds, or zero otherwise.
-024 */
-025 int mp_prime_fermat (mp_int * a, mp_int * b, int *result)
-026 \{
-027 mp_int t;
-028 int err;
-029
-030 /* default to composite */
-031 *result = MP_NO;
-032
-033 /* ensure b > 1 */
-034 if (mp_cmp_d(b, 1) != MP_GT) \{
-035 return MP_VAL;
-036 \}
-037
-038 /* init t */
-039 if ((err = mp_init (&t)) != MP_OKAY) \{
-040 return err;
-041 \}
-042
-043 /* compute t = b**a mod a */
-044 if ((err = mp_exptmod (b, a, a, &t)) != MP_OKAY) \{
-045 goto __T;
-046 \}
-047
-048 /* is it equal to b? */
-049 if (mp_cmp (&t, b) == MP_EQ) \{
-050 *result = MP_YES;
-051 \}
-052
-053 err = MP_OKAY;
-054 __T:mp_clear (&t);
-055 return err;
-056 \}
+016 /* performs one Fermat test.
+017 *
+018 * If "a" were prime then b**a == b (mod a) since the order of
+019 * the multiplicative sub-group would be phi(a) = a-1. That means
+020 * it would be the same as b**(a mod (a-1)) == b**1 == b (mod a).
+021 *
+022 * Sets result to 1 if the congruence holds, or zero otherwise.
+023 */
+024 int mp_prime_fermat (mp_int * a, mp_int * b, int *result)
+025 \{
+026 mp_int t;
+027 int err;
+028
+029 /* default to composite */
+030 *result = MP_NO;
+031
+032 /* ensure b > 1 */
+033 if (mp_cmp_d(b, 1) != MP_GT) \{
+034 return MP_VAL;
+035 \}
+036
+037 /* init t */
+038 if ((err = mp_init (&t)) != MP_OKAY) \{
+039 return err;
+040 \}
+041
+042 /* compute t = b**a mod a */
+043 if ((err = mp_exptmod (b, a, a, &t)) != MP_OKAY) \{
+044 goto __T;
+045 \}
+046
+047 /* is it equal to b? */
+048 if (mp_cmp (&t, b) == MP_EQ) \{
+049 *result = MP_YES;
+050 \}
+051
+052 err = MP_OKAY;
+053 __T:mp_clear (&t);
+054 return err;
+055 \}
\end{alltt}
\end{small}
@@ -10539,88 +10510,87 @@ composite then it is \textit{probably} prime.
\hspace{-5.1mm}{\bf File}: bn\_mp\_prime\_miller\_rabin.c
\vspace{-3mm}
\begin{alltt}
-016
-017 /* Miller-Rabin test of "a" to the base of "b" as described in
-018 * HAC pp. 139 Algorithm 4.24
-019 *
-020 * Sets result to 0 if definitely composite or 1 if probably prime.
-021 * Randomly the chance of error is no more than 1/4 and often
-022 * very much lower.
-023 */
-024 int mp_prime_miller_rabin (mp_int * a, mp_int * b, int *result)
-025 \{
-026 mp_int n1, y, r;
-027 int s, j, err;
-028
-029 /* default */
-030 *result = MP_NO;
-031
-032 /* ensure b > 1 */
-033 if (mp_cmp_d(b, 1) != MP_GT) \{
-034 return MP_VAL;
-035 \}
-036
-037 /* get n1 = a - 1 */
-038 if ((err = mp_init_copy (&n1, a)) != MP_OKAY) \{
-039 return err;
-040 \}
-041 if ((err = mp_sub_d (&n1, 1, &n1)) != MP_OKAY) \{
-042 goto __N1;
-043 \}
-044
-045 /* set 2**s * r = n1 */
-046 if ((err = mp_init_copy (&r, &n1)) != MP_OKAY) \{
-047 goto __N1;
-048 \}
-049
-050 /* count the number of least significant bits
-051 * which are zero
-052 */
-053 s = mp_cnt_lsb(&r);
-054
-055 /* now divide n - 1 by 2**s */
-056 if ((err = mp_div_2d (&r, s, &r, NULL)) != MP_OKAY) \{
-057 goto __R;
-058 \}
-059
-060 /* compute y = b**r mod a */
-061 if ((err = mp_init (&y)) != MP_OKAY) \{
-062 goto __R;
-063 \}
-064 if ((err = mp_exptmod (b, &r, a, &y)) != MP_OKAY) \{
-065 goto __Y;
-066 \}
-067
-068 /* if y != 1 and y != n1 do */
-069 if (mp_cmp_d (&y, 1) != MP_EQ && mp_cmp (&y, &n1) != MP_EQ) \{
-070 j = 1;
-071 /* while j <= s-1 and y != n1 */
-072 while ((j <= (s - 1)) && mp_cmp (&y, &n1) != MP_EQ) \{
-073 if ((err = mp_sqrmod (&y, a, &y)) != MP_OKAY) \{
-074 goto __Y;
-075 \}
-076
-077 /* if y == 1 then composite */
-078 if (mp_cmp_d (&y, 1) == MP_EQ) \{
-079 goto __Y;
-080 \}
-081
-082 ++j;
-083 \}
-084
-085 /* if y != n1 then composite */
-086 if (mp_cmp (&y, &n1) != MP_EQ) \{
-087 goto __Y;
-088 \}
-089 \}
-090
-091 /* probably prime now */
-092 *result = MP_YES;
-093 __Y:mp_clear (&y);
-094 __R:mp_clear (&r);
-095 __N1:mp_clear (&n1);
-096 return err;
-097 \}
+016 /* Miller-Rabin test of "a" to the base of "b" as described in
+017 * HAC pp. 139 Algorithm 4.24
+018 *
+019 * Sets result to 0 if definitely composite or 1 if probably prime.
+020 * Randomly the chance of error is no more than 1/4 and often
+021 * very much lower.
+022 */
+023 int mp_prime_miller_rabin (mp_int * a, mp_int * b, int *result)
+024 \{
+025 mp_int n1, y, r;
+026 int s, j, err;
+027
+028 /* default */
+029 *result = MP_NO;
+030
+031 /* ensure b > 1 */
+032 if (mp_cmp_d(b, 1) != MP_GT) \{
+033 return MP_VAL;
+034 \}
+035
+036 /* get n1 = a - 1 */
+037 if ((err = mp_init_copy (&n1, a)) != MP_OKAY) \{
+038 return err;
+039 \}
+040 if ((err = mp_sub_d (&n1, 1, &n1)) != MP_OKAY) \{
+041 goto __N1;
+042 \}
+043
+044 /* set 2**s * r = n1 */
+045 if ((err = mp_init_copy (&r, &n1)) != MP_OKAY) \{
+046 goto __N1;
+047 \}
+048
+049 /* count the number of least significant bits
+050 * which are zero
+051 */
+052 s = mp_cnt_lsb(&r);
+053
+054 /* now divide n - 1 by 2**s */
+055 if ((err = mp_div_2d (&r, s, &r, NULL)) != MP_OKAY) \{
+056 goto __R;
+057 \}
+058
+059 /* compute y = b**r mod a */
+060 if ((err = mp_init (&y)) != MP_OKAY) \{
+061 goto __R;
+062 \}
+063 if ((err = mp_exptmod (b, &r, a, &y)) != MP_OKAY) \{
+064 goto __Y;
+065 \}
+066
+067 /* if y != 1 and y != n1 do */
+068 if (mp_cmp_d (&y, 1) != MP_EQ && mp_cmp (&y, &n1) != MP_EQ) \{
+069 j = 1;
+070 /* while j <= s-1 and y != n1 */
+071 while ((j <= (s - 1)) && mp_cmp (&y, &n1) != MP_EQ) \{
+072 if ((err = mp_sqrmod (&y, a, &y)) != MP_OKAY) \{
+073 goto __Y;
+074 \}
+075
+076 /* if y == 1 then composite */
+077 if (mp_cmp_d (&y, 1) == MP_EQ) \{
+078 goto __Y;
+079 \}
+080
+081 ++j;
+082 \}
+083
+084 /* if y != n1 then composite */
+085 if (mp_cmp (&y, &n1) != MP_EQ) \{
+086 goto __Y;
+087 \}
+088 \}
+089
+090 /* probably prime now */
+091 *result = MP_YES;
+092 __Y:mp_clear (&y);
+093 __R:mp_clear (&r);
+094 __N1:mp_clear (&n1);
+095 return err;
+096 \}
\end{alltt}
\end{small}