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
|
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<link rel="stylesheet" type="text/css" href="html.css" />
<title>JAS project web-log</title>
</head>
<body class="main">
<h1>JAS project web-log</h1>
<p>For a detailed list of the latest changes see the
<a href="git_change.log" target="top">Git change log</a>.
</p>
<!--
<dt>2022, 1, </dt> < ! - - 2.6.60xx - - >
<dd>
</dd>
<code></code>
<code></code>
-->
<dl>
<dt>2023, July </dt> <!-- 2.7.200 -->
<dd>
More tests with <code>BigQuaternion</code> polynomial coefficients.
Fixed a left-right bug in solvable polynomials <code>monic()</code>
method. (left and right monic must be distinguished although the
inverse of the leading base coefficient is a left and right inverse.)
Fix to <code>leftMonic()</code> where required.
Adjust polynomial <code>reverse()</code> method with using
<code>conjugate()</code> on coefficients. More tests for Ore
conditions for polynomials with quaternion coefficients.
Fixed default implementations in interface <code>MonoidElem</code> for
left, right and two-sided operations by throwing exceptions when not
correctly overriden.
</dd>
<dt>2023, May </dt> <!-- 2.7.190 -->
<dd>
This release adds exterior derivations for polynomials and rational
functions. The weak or strong term order for index lists are now
selectable. Explicit k-forms and improved random index lists.
More non-commutative unit tests (quotient remainder, Ore conditions,
common divisors) for solvable polynomials with quaternion
coefficients.
Exterior algebra provided within Jruby and Jython interfaces.
Renamed <code>inner*Product()</code> to <code>interior*Product()</code>
since this seems to be the correct translation. Remove and cleanup
unsued experimental code and small bug fixes. Add file with simple
NCSS report summary.
</dd>
<dt>2023, March </dt> <!-- 2.7.180 -->
<dd>
This release adds exterior algebra polynomials / vectors in classes
<code>GenExteriorPolynomial</code> and
<code>GenExteriorPolynomialRing</code>. With exterior multiplication
and inner left / right multiplication methods. Also included are
determinant and resultant methods via exterior algebra algorithms.
Add new characteristic polynomial method <code>charPolynomial()</code>
using Faddeev-LeVerrier algorithm in class
<code>GenPolynomialRing</code>. Add <code>trace()</code>method in
class <code>GenMatrix</code>. Fixed many spelling errors, small bug
fixes and cleanups.
</dd>
<dt>2023, January </dt> <!-- 2.7.170 -->
<dd>
Added more unit test cases to improve code coverage of statement and
expression tests together with eventual fixes, for example: exponent
vector storage units, polynomial conversions, complex constants,
runGB distributed cases, ideal decomposition mod prime, and right
solvable multiplicaton.
Ensure compatibility with JRuby version 9.4.0.0 (Ruby 3.1.0
compatible). Adjust for year 2023. Further cleanups and small bug
fixes.
</dd>
<dt>2022, November </dt> <!-- 2.7.160/1 -->
<dd>
Introduce some right- and two-sided operations in
<code>SolvableIdeal</code> to represent such ideals. Time-limited
stop for long running or infinite word Groebner Base
computations. Additionally counter stop configuration for long
running Kronecker factorization algorithm cases, using <a
href="https://github.com/kredel/java-algebra-system/pull/32">Pull
request 32</a>.
Fix bugs in <code>ExpVector</code> subclasses, in methods
<code>setVal()</code>, this resolves <a
href="https://github.com/kredel/java-algebra-system/issues/30">issue
30</a>. Fix in <code>SquarefreeFieldCharP</code> for polynomial
1. Fixes in <code>SquarefreeFieldChar0</code> and
<code>SquarefreeRingChar0</code> for recursion to polynomial content.
Fix in <code>PolyUfdUtilTest</code> of
<code>evaluationPoints()</code> to ensure squarefree input.
Added more unit test cases to improve code coverage of statement and
expression tests. Further cleanups and bug fixes (see <a
href="git_change.log">Git log</a>).
</dd>
<dt>2022, September </dt> <!-- 2.7.150 -->
<dd>
Tried to improve code in <code>Gen*PolynomialRing</code> constructors
and method <code>getZERO()</code> with respect to Java memory model
for problems appearing with Java OpenJDK version "11.0.15",
2022-04-19 and still in "17.0.4", 2022-07-22. Added some unit tests
to improve test coverage, for example <code>RunGB</code>,
<code>RunSGB</code>, <code>IntegerProgram</code>,
<code>StandardBaseSeq</code>, <code>jas.kern</code> utilities or
<code>GenMatrix</code> and more. Added selectable
<code>Quotient</code> normalizations, but only
<code>QuoNorm.normDenLead</code> works in other parts of JAS. Other
normalizations must be checked and code fixed (see <a
href="https://github.com/kredel/java-algebra-system/issues/29">issue
29</a>). Fix bug in <code>UnivPowerSeries</code> method
<code>reductum()</code>. Fix bug in <code>ExpVector</code>
constructor with respect to <code>hashCode()</code>. Verified again
that JAS can be compiled and run with Java 17(.0.3) and jruby 9.2.14
and jython 2.7.2.
</dd>
<dt>2022, July </dt> <!-- 2.7.140 -->
<dd>
Fix spelling of names of <code>derivative</code> methods. Taylor
series expansion for polynomial quotients. Some code moved from
<code>edu.jas.ps</code> and <code>edu.jas.vector</code> to
<code>edu.jas.ufd</code> to clear package dependency cycles. Pade
approximation from Taylor series, in particular for polynomial
quotients.
</dd>
<dt>2022, May </dt> <!-- 2.7.130 -->
<dd>
New methods <code>extGB()</code> and <code>inverse()</code> for d-
and e-Groebner Bases in classes <code>DGroebnerBaseSeq</code> and via
new reduction methods automatically in
<code>EGroebnerBasesSeq</code>. Tests can reuse methods
<code>isReductionMatrix()</code> and
<code>isMinReductionMatrix()</code> from
<code>GroebnerBaseAbstract</code>. Added missing methods for
normalform, S-polynomial, G-Polynomial with recording in
<code>DReduction</code>, <code>EReduction</code> interfaces and
<code>DReductionSeq</code>, <code>EReductionSeq</code> classes. For
scripting the respective methods <code>eExtGB</code>,
<code>iseExtGB</code>, <code>eInverse</code> and
<code>iseInverse</code> have been added to <code>Ideal</code>
respectively <code>SimIdeal</code>. JAS can be compiled and run with
Java 17, but no switch to Java 17 class files at the moment. The JAS
debian package is build on Debian 11 bullseye with Java 17 and Jython
2.7.2, so <code>jas.py</code> and <code>jas -py</code> scripts can be
used again in Debian.
</dd>
<dt>2022, March </dt> <!-- 2.7.120 -->
<dd>
Fix multiplicities of complex roots in
<code>ComplexRootsAbstract. complexRoots()</code>. Revisit recursive
solvable polynomial algorithms and activate some missing test cases,
resolve commutator table related todos, add missing right-multiply
using methods from to do list
(<code>SolvablePseudoReduction. rightNormalform</code>,
<code>rightNormalformRecursive</code>,
<code>rightNormalformFactor</code>). Related fixes and extensions in
scripting frameworks. Update and revision of JAS web documentation.
</dd>
<dt>2022, January </dt> <!-- 2.7.110 -->
<dd>
Continue changes for Log4J version 2 API. Adjust year 2022. Improve
maximal ideal check. Further cleanups and small fixes.
</dd>
<dt>2021, December </dt> <!-- 2.7.100 -->
<dd>
Continue changes for Log4J version 2 API. Update Log4j version
because of potential CVE-2021-44228 vulnerability.
</dd>
<dt>2021, November, </dt> <!-- 2.7.90 -->
<dd>
Improved logging dependencies for JAS in Maven POM (see README or
download). Started using the Log4J version 2 API. Small fixes and
cleanups.
</dd>
<dt>2021, September </dt> <!-- 2.7.80 -->
<dd>
Fraction free Gauss elimination. Some matrix concatination
operations. Choice of evaluation points for Hensel lifting. Some
more polynomial utilities: reciprocal transformation, translation and
evaluation. Missing algebraic number Jython examples. Cleanups and
small bug fixes.
</dd>
<dt>2021, August </dt> <!-- 2.7.70 -->
<dd>
Factorization now provides Berlekamp, Cantor and Zassenhaus
algorithms. Corresponding methods are contained in classes
<code>ufd.PolyUfdUtil</code> and
<code>ufd.FactorModularBerlekamp</code> and are called
<code>contructQmatrix</code> and <code>baseFactorsSquarefree</code>.
There are sub-methods for the small and big primes algorithm
variants. Berlekamp factorization algorithm is now the default for
polynomials over finite fields (algebraic extensions of prime
fields), defined in <code>FactorFactory</code> for this case.
<code>GenMatrix</code> is equiped with an <code>inverse</code> method
with the help of <code>LinAlg.decomposeLU</code>. The extension field
builder has a new method <code>matrixExtension</code> to provide
matrix extension rings. A sparser form of a given row echelon matrix
is computed by <code>rowEchelonFormSparse</code>. Some other small
fixes and improvements.
</dd>
<dt>2021, July </dt> <!-- 2.7.60 -->
<dd>
Linear algebra package extended by LU decomposition, solution of
systems of equations, matrix inversion, determinants, null space
basis and row echelon form computation. Methods are called
<code>decompositionLU</code>, <code>solveLU</code>,
<code>determinantLU</code>, <code>inverseLU</code>,
<code>nullSpaceBasis</code>, <code>rowEchelonForm</code> and
<code>rankRE</code>. They are contained in class
<code>vector.LinAlg</code>. Corresponding methods and examples for
JRuby and Jython created. Methods <code>contFrac</code> and
<code>contFracApprox</code> for continued fraction computation for
JRuby and Jython. Further cleanups, improvements and small bug fixes.
</dd>
<dt>2021, June </dt> <!-- 2.7.50 -->
<dd>
New methods <code>chineseRemainderTheorem</code>,
<code>isChineseRemainder</code> and <code>CRTInterpolation</code> in
class <code>PolyGBUtil</code> for computing Chinese remainders for
polynomials, polynomial interpolation and test. Together with
corresponding methods and examples for JRuby and Jython. New class
<code>SquarefreeFieldChar0Yun</code> with Yun's square-free
decomposition algorithm. This is now the default algorithm in
square-free factory methods since it is slightly faster. Other small
fixes and improvements. Fix github deployment.
</dd>
<dt>2021, May </dt> <!-- 2.7.40 -->
<dd>
New method <code>factors</code> in class <code>PolyUfdUtil</code> for
rational functions of class <code>Quotient</code>. New methods
<code>subRing</code> and <code>subRingMember</code> in class
<code>PolyGBUtil</code> for computing GB generators for polynomial
subrings and membership tests. Together with analogous methods and
examples for JRuby and Jython. More small improvements and fixes.
</dd>
<dt>2021, March </dt> <!-- 2.7.30 -->
<dd>
Methods for continued fractions of rational and real algebraic
numbers. Improved heuristics for polynomial factorization. New real
root methods related to Thom's lemma. Minimal root and root
separation bounds. Some interval arithmetic, reimplement
<code>excludeZero</code> method. Squarefree part fix in
<code>edu.jas.root.</code> <code>ComplexRootsAbstract</code>.
Delegate <code>compareTo</code> from <code>edu.jas.arith.</code>
<code>BigDecimal</code> to <code>java.math.</code>
<code>BigDecimal</code>. More unit tests for missing cases. Further
code cleanup by Eclipse rules, small fixes and improvements.
</dd>
<dt>2021, February </dt> <!-- 2.7.20 -->
<dd>
In this release the source and classes are switched to Java 11, Log4j
2.13.2, JRuby 9.2.14.0 and Jython 2.7.2 with some fixes. For example
the deprecated JRuby <code>mathn</code> module for rational number
input had to be replaced. JavaDoc is now generated in HTML5, tags and
entities in method descriptions fixed. Internal calls to deprecated
<code>PseudoRemainder</code> methods are replaced. Termination
detection in <code>GreatestCommonDivisorModEval</code> was fixed. A
new parsing method for <code>WordPolynomial</code>s was added. The
<a href="https://symbolicdata.github.io/"
target="new">SymbolicData</a> test are deactivated as its servers
have been terminated. Further cleanups, improvements and small bug
fixes.
</dd>
<dt>2021, January </dt> <!-- 2.7.10 -->
<dd>
Switch from SVN to Git, so the SVN revision number will no more be
part of the JAS version. Several small fixes for some issues found
by <a href="https://lgtm.com/" target="new">LGTM</a>. For example,
<code>hashCode</code>, potential <code>int, long</code> overflows and
parameter typos in Javadoc.
<b>Note:</b> From JAS version 2.7 on, the deprecated methods and
classes might be removed.
</dd>
<dt>2020, December, 13th </dt> <!-- 2.6.6027 -->
<dd>
Undo error in selection of evaluation points in factorization of
polynomials with integer coeffcients. Fix in Debian package.
</dd>
<dt>2020, December </dt> <!-- 2.6.6025 -->
<dd>
In polynomial factorization check and force INVLEX term ordering.
Improve special case of polynomials with positive degree of
trailing term in squarefree decomposition.
</dd>
<dt>2020, May </dt> <!-- 2.6.6017 -->
<dd>
Cleanup auto generated variable names. Some new tests and examples.
Reduce heap memory requirements, see issue <a
href="https://github.com/kredel/java-algebra-system/issues/12"
target="new">#12</a>. Fix / improve Debian <code>lintian</code>
errors. Remove Javadoc reserved <code>@usage</code> tag from source
and cleanup comments. Further cleanups and bug fixes.
</dd>
<dt>2020, March </dt> <!-- 2.6.6000 -->
<dd>
Fixed/improved issue <a
href="https://github.com/kredel/java-algebra-system/issues/12"
target="new">#12</a>. Further improvements, cleanups and small bug
fixes.
</dd>
<dt>2019, April </dt> <!-- 2.6.5988 -->
<dd>
Improve factorization of multivariate polynomials with algebraic
number coefficients by avoiding Kronecker reduction from multivariate
polynomials to univariate polynomials. Do not use ModEval greatest
common divisor computations for too small field coefficients of
polynomials.
New finite field constructors <code>FF(p,n)</code> in JAS scripting
interfaces.
Update to Jruby 9.1.7 in JRuby interface to JAS. Installation of
<code>configparser</code> necessary, <code>require mathn</code> and
<code>require Matrix</code> in some place. Other small improvements
and bug fixes.
</dd>
<dt>2018, November </dt> <!-- 2.6.5961 -->
<dd>
New <code>mapOnStream()</code> methods implemented operating on
(parallel) stream map methods of polynomial monomials. Performance
seems to be worse by factors compared to non stream method variants.
Provide a spliterator over monomials for polynomials via a new
<code>spliterator()</code> method and class
<code>PolySpliterator</code>.
Polynomial absolute norm implemented and some improvements for square
roots.
Converted the usages of <code>edu.jas.util.ThreadPool</code> to
<code>java.util.concurrent.ThreadpoolExecutor</code>.
Checked that JAS compiles and runs with Java 11 (without module
definition). Bug fixes and other small improvements.
</dd>
<dt>2018, October </dt> <!-- 2.6.5938 -->
<dd>
New smaller modular coefficients in <code>ModInt</code> and
<code>ModIntRing</code> based on <code>int</code> integers.
Performance improvements for polynomial <code>sum()</code> method for
polynomials with unbalanced size. <code>sqrt()</code>
approximation for <code>BigRational</code> and tests fixed for
complex <code>abs()</code> methods.
Further small improvements and bug fixes.
</dd>
<dt>2018, August </dt> <!-- 2.6.5918 -->
<dd>
New term order for module Gröbner bases and module
reduction. Besides the (default) POT module term order there is now
the TOP term order implemented for IGRLEX and INVLEX block term order
combinations. (POT is "Position over Term" and TOP is "Term over
Position".) Fixed issue <a
href="https://github.com/kredel/java-algebra-system/issues/6"
target="new">#6</a>. Further bug fixes and small improvements.
</dd>
<dt>2018, July </dt> <!-- 2.6.5884 -->
<dd>
Source refactored to use Apache Log4j version 2 API. The dependency
to Log4j version 1 API can be removed. The helper logging jars
<code>mylog.jar</code>, <code>nolog.jar</code> and
<code>droidlog.jar</code> are no more working and obsolet.
Add further missing methods for non-commutative
<code>WordIdeal</code>. Small improvements and bug fixes.
</dd>
<dt>2018, June </dt> <!-- 2.6.5851 -->
<dd>
New algorithms of Lazard-Rioboo-Trager and Czichowski for the integration
of rational functions developed by Youssef Elbarbary. Improved partial
fraction and Bernoulli algorithm.
Removed deprecated and unused package <code>edu.mas</code>. Cleanup
todo comments. Improve types of return values. Checked that JAS
compiles and runs with Java 10. Bug fixes and other small
improvements.
</dd>
<dt>2018, March </dt> <!-- 2.6.5803 -->
<dd>
Improvements in parallel algorithms according to the Java memory
model. Other bug fixes and small improvements.
</dd>
<dt>2017, December </dt> <!-- 2.6.5786 -->
<dd>
This release fixed missing factorization of polynomial content, and
added generation of random irreducible polynomials.
Checked that JAS compiles and runs with Java 9. Small bug fixes and
improvements.
</dd>
<dt>2017, June </dt> <!-- 2.6.5765 -->
<dd>
This release improved performance of polynomial factoring methods
over integers and rational numbers. The affected classes are
<code>FactorRational</code>,
<code>GreatestCommonDivisorModular</code> and
<code>GreatestCommonDivisorModEval</code>. Thanks to Stanislav
Poslavsky from the <a href="http://redberry.cc/"
target="new">Redberry</a> project for pointing out these issues.
Several Findbugs issues have been fixed, for example, insufficient
synchronization. Other bug fixes and small improvements.
</dd>
<dt>2017, February </dt> <!-- 2.6.5733 -->
<dd>
This release adds left and right methods in <code>MonoidElem</code>
with commutative default implementations. The Ore condition for
<code>StarRingElem</code> classes can be computed. Quaternion classes
are refactored for separate <code>Ring</code> and integral quaternion
classes. Bug fixes and small improvements.
There is now a Maven compatible repository with JAS at
<a href="http://krum.rz.uni-mannheim.de/maven-repository/" target="new"
>http://krum.rz.uni-mannheim.de/maven-repository/</a>.
</dd>
<dt>2017, January </dt> <!-- 2.6.5690 -->
<dd>
Support Java 8 lambda expressions for the generation of matrix
entries and power series coefficients. Factorization for rational
functions (quotients of polynomials). Factorization for BigInteger
elements.
Quaternion implementation extended to handle integral quaternions.
Some tests and improvements for (commutative) polynomials with
non-commutative coefficients. Other small improvements and bug
fixes.
</dd>
<dt>2016, November </dt> <!-- 2.6.5652 -->
<dd>
New class with integer factorization, partly from previous SAC2/Aldes
and MAS codes, mixed with probable prime test from
<code>java.math</code>. Main method is <code>factors()</code> in
class <code>PrimeInteger</code>.
Cyclotomic polynomial construction and decomposition, similar to
Sympy. Improvements in Gröbner walk implementation to make
source and target term order selectable. Small improvements and bug
fixes.
</dd>
<dt>2016, October </dt> <!-- 2.6.5616 -->
<dd>
New Gröbner walk algorithm in class
<code>GroebnerBaseWalk</code>. Extensions to existing code for marked
polynomials used in Gröbner walk.
Bug fixes and small improvements, more use of Java 8 features.
</dd>
<dt>2016, August </dt> <!-- 2.6.5591 -->
<dd>
Improved methods to handle real and complex algebraic roots of
univariate polynomials based on <code>RootFactory</code> methods.
<!-- <code>realAlgebraicNumbers()</code> and
<code>compelxAlgebraicNumbers()</code> --> New methods in class
<code>RootFactory</code> to compute both the real and complex
algebraic roots with <code>algebraicRoots()</code>, method
<code>rootsOfUnity()</code> to filter roots of unity, and methods
<code>rootRefine()</code> and <code>decimalRoots()</code> to compute
approximations of real and complex roots. The method
<code>rootReduce()</code> in <code>RootFactoryApp</code> helps to
construct common field extensions via primitive element
computations. The algorithms are also accessible via the scripting
interfaces under the same names.
Dockerfile to construct a standalone JAS scripting application.
</dd>
<dt>2016, July </dt> <!-- 2.6.5555 -->
<dd>
Mostly improvements and bug fixes in package <code>edu.jas.fd</code>.
Use (Java 8) method <code>power()</code> from <code>MonoidElem</code>
where possible. Further bug fixes and small improvements.
</dd>
<dt>2016, May </dt> <!-- 2.6.5508 -->
<dd>
Improvements in package <code>edu.jas.fd</code>. New class
<code>SGCDFactory</code> with methods <code>getImplementation()</code>
and <code>getProxy()</code> to obtian suitable common divisor
implementations based on the coefficient ring of the polynomials.
New class <code>SGCDParallelProxy</code> to run two common divisor
implementations in parallel and take the result of the first finished
one (compare to <code>GCDProxy</code>).
The solvable left and right common divisor algorithms are now used in
<code>SolvableLocalResidue</code>, <code>SolvableLocal</code> and
<code>SolvableQuotient</code> to reduce the fractions to lower terms.
Refactoring some classes to <code>edu.jas.fd</code> package.
Bug fixes, small improvements and use of more Java 8 features.
</dd>
<dt>2016, March </dt> <!-- 2.6.5480 -->
<dd>
New signature-based Gröbner base algorithms, F5, GGV and Arri,
after the paper <em>"Signature-based Algorithms to Compute
Gröbner bases"</em> by Eder and Perry, ISSAC 2011. The classes
are <code>GroebnerBaseF5SigSeqIter</code>,
<code>GroebnerBaseGGVSigSeqIter</code>,
<code>GroebnerBaseArriSigSeqIter</code> and are selectable via
<code>GBAlgorithmBuilder</code> methods <code>F5()</code>,
<code>GGV()</code> and <code>Arri()</code>. Some of the new methods
use Java 8 constructions.
<code>GBAlgorithmBuilder</code> expressions can be used in
<code>RunGB</code> using the parameter
<code>build=string</code>. Started with new methods
<code>bitLength()</code> for coefficient arithmetic classes and
polynomials. Some bug fixes and small improvements. Debian package
improved.
</dd>
<dt>2016, February </dt> <!-- 2.6.5428 -->
<dd>
This is release 2.6 of JAS. We have switched to latest versions of
used packages, for example to Apache Log4j version 2.5, JRuby version
1.7.23 and Jython version 2.7.0. Junit 4.12 is already used since the
last JAS version. At the moment all old versions of these packages
will still work, but this may change in the next JAS versions. From
then on we will eventually also make use of Java 8 features.
The old version will be kept here:
<a href="http://krum.rz.uni-mannheim.de/jas-2.5/" target="new">JAS 2.5</a>.
<br />
We removed some long time deprecated classes <code>GBDist</code>,
<code>GBDistHybrid</code>, <code>GroebnerBaseDistributed</code>,
<code>GroebnerBaseDistributedHybrid</code>, the method
<code>divideAndRemainder</code> of several classes and some other
unused methods. Code cleanup and unified logger declaration.
New class <code>IntegerProgram</code> to solve integer optimization
problems via Gröbner bases. Tests and some fixes for
compatibility of term orders with Sage, Singular and
Mathematica. Several small bug fixes and improvements. Print JAS
version in jython and jruby modules. Iterative Gröbner base
algorithms selectable in <code>GBAlgorithmBuilder</code>.
</dd>
<dt>2016, January </dt> <!-- 2.5.5380 -->
<dd>
New parallel iterative Gröbner base algorithm in class
<code>GreoebnerBaseParIter</code>. Names for Sage, Singular and
Mathematica term orders defined in class
<code>TermOrderByName</code>. Better separation of ExpVector from
TermOrder. Missing polynomial methods <code>weightDegree()</code>
and <code>leadingWeightPolynomial()</code> added.
Switched to Junit 4.12 and use the timeout option on long running
tests. Small improvements, changes and bug fixes.
</dd>
<dt>2015, December </dt> <!-- 2.5.5345 -->
<dd>
New iterative Gröbner base algorithm in class
<code>GreoebnerBaseSeqIter</code>. Term orders with weight matrix are
now usable from jython and jruby via the <code>PolyRing</code>
constructors. More names for defined and implemented term orders in
class <code>TermOrderByName</code>.
Improved unit tests and further small changes and bug fixes.
</dd>
<dt>2015, November </dt> <!-- 2.5.5318 -->
<dd>
Extensions to experimental classes for solvable polynomials with
non-commutative word polynomials and non-commutative residue classes
as coefficients.
Fixed bugs spotted by new findbugs version. Small improvements and
bug fixes. The distributed byte code is now Java 8. But no Java 8
features have been used and the sources still compile with Java 7.
</dd>
<dt>2015, July </dt> <!-- 2.5.5281 -->
<dd>
Refactoring of the intefaces and classes in package
<code>edu.jas.gbmod</code> to the packages <code>edu.jas.gb</code>
and <code>edu.jas.gbufd</code> to cut the package dependency cycles.
Changes to the organization and contents of the Web pages.
<b>Note:</b> The next release will eventually use Java 8 features and
drop Java 7 support, moreover many deprecated methods and classes
may be removed.
</dd>
<dt>2015, May </dt> <!-- 2.5.5246 -->
<dd>
New experimental classes for solvable polynomials with
non-commutative word polynomials as coefficients. Adjustments for
solvable left multiplication with word polynomial coefficients and
corresponding changes for Gröbner bases (might not be computable
in all cases).
More <code>valueOf</code> methods in polynomial ring classes to
construct polynomials from coefficients and exponents or words. Check
for missing Ore condition usage in solvable reduction algorithms. Use
Ore condition in solvable pseudo reduction algorithms for solvable
polynomial coefficients. There is a new class
<code>GreatestCommonDivisorFake</code> in which <code>gcd</code>
methods always return 1.
Bugfix in two-sided Gröbner bases right coefficient multipliers.
Fixed the polynomial parser to accept some more
<code>ASCIIMath</code> expressions. Small improvements and
refactoring of the HTML documentation.
</dd>
<dt>2015, April </dt> <!-- 2.5.5178 -->
<dd>
New two-sided Gröbner bases for solvable polynomial rings with
parametric coefficients and commutator relations between coeficient
variables and main variables. Addition of this methods also to
<code>SolvableIdeal</code>. New right module Gröbner bases and
right module syzygies. Syzygy methods added to scripting interfaces.
Performance improvements for solvable polynomial multiplication and
polynomial reduction. Small bug fixes and improvements.
Moved one JAS repository from Google code to
<a href="https://github.com/kredel/java-algebra-system" target="gh">GitHub</a>
since Google code will be discontinued.
</dd>
<dt>2015, March </dt>
<dd>
Small modifications to comprehensive Gröbner bases
implementation to allow computation of left comprehensive
Gröbner bases in case of solvable polynomials with commutative
parameter coefficients. Shared memory parallel versions for module
Gröbner bases. Refactoring to remove package dependecy cycles.
Code cleanup, small fixes and improvements.
</dd>
<dt>2015, February </dt>
<dd>
Parallel versions for module Gröbner bases. Refactor syzygy
computation classes into abstract and sequential classes. Disable
some correctness checks in syzygy computation depending on disabled
Java assertions. Improve solvable relation table updates. Proxy and
factory for solvable Gröbner bases <code>SGBProxy</code> and
<code>SGBFactory</code>.
Refactor term order optimization methods to naturally / better suited
classes. Make use of <code>ModLong</code> classes and the improved
<code>RingFactory</code> parser in the scripting interfaces. Remove
the dependency on Junit from the src-tree. Some more small fixes and
improvements. Ivy resolve task for log4j and junit libraries.
</dd>
<dt>2015, January </dt>
<dd>
Integer and (commutative) polynomial coefficients in solvable and
word Gröbner bases. New classes <code>WordResidue</code> and
<code>WordResidueRing</code> for residue classes modulo twosided
ideals <code>WordIdeal</code> in word polynomial rings (free
non-commutative algebas). Fix missing critical pairs to consider in
word Gröbner bases. Code cleanup and small fixes and
improvements.
</dd>
<dt>2014, December </dt>
<dd>
Added some jython and jruby scripts to access the
<a href="http://symbolicdata.uni-leipzig.de">SymbolicData</a>
data base of polynomial systems. Small improvements and corrections.
The code now compiles and runs with Java 8.
</dd>
<dt>2014, October </dt>
<dd>
Improved issues spotted by <a href="https://code-spotter.com"
target="new">code-spotter.com</a>. Cleanup and improvements of the
<code>RingElem</code> class in the jython and Ruby script interface.
Small improvements for recursive pseudo division Gröbner bases
and corrections, new Junit test cases.
</dd>
<dt>2014, September </dt>
<dd>
Use of automatic variables in Jython and JRuby examples where
possible. By this, the variables of a polynomial ring
<code>PolyRing(QQ(),"x,y")</code> are directly available as script
variables <code>x, y</code> with out calling <code>r.gens()</code>.
Improved <code>jas</code> script to run also under Debian with
MathLibre. Small updates, new diagrams and pictures.
</dd>
<dt>2014, August</dt>
<dd>
New class <code>BigDecimalComplex</code> for complex floating point
arithmetic. Some fixes and other small improvements for floating
point calculations.
The Java <em>bytecode</em> of JAS is now dual licenced under the
Apache 2.0 licence to allow its usage in Android projects.
</dd>
<dt>2014, June</dt>
<dd>
Small bug fixes, code optimizations, some new UML class diagrams and
code cosmetic. Added Apache Commons Math3 adapter to the repository.
</dd>
<dt>2014, April </dt>
<dd>
The solvable polynomial common divisor package
<code>edu.jas.fd</code> is now in a usable condition. The definition
of greatest common divisor has changed slightly and left and right
gcds are now distinguished. Various improvements, refactorings and
bug fixes. Detection of wrong method dispatching by JRE in
<code>GenSolvablePolynomial</code> and <code>GenPolynomial</code>.
Cleanup of Gröbner base packages. Completion of GB class
constructors with <code>PairList</code> parameters. New parallel
recursive polynomial Gröbner base computation. Refactoring of
<code>Quotient</code> coefficient cases. Handle more cases in
<code>GBAlgorithmBuilder</code> and <code>GBFactory</code>. jython
scripting GB with selectable sig-based GB algorithm. Unit tests for
the new algorithms.
</dd>
<dt>2014, March </dt>
<dd>
Small improvements in solvable polynomial common divisor computation,
more cases working. New method for right pseudo division.
Performance improvements in <code>PrimeList</code>. Restore and keep
MPJ Express compatibility and test cases.
</dd>
<dt>2014, January </dt>
<dd>
New package <code>edu.jas.fd</code> for solvable polynomial common
divisor computation. It will contain algorithms for (non-unique)
factorization domains. There are methods for polynomial pseudo
remainder computation over Ore domains in class <code>FDUtil</code>.
Further, methods for common divisors are included, but not yet
finished. Converge and cleanup MPJ and MPI implementations. Added
Javadocs for JLinAlg adapter.
</dd>
<dt>2013, November </dt>
<dd>
New solvable local residue ring <code>SolvableLocalResidue</code> as
solvable quotient field modulo an ideal. New generic solvable
polynomials <code>QLRSolvablePolynomial</code> with abstracted generic
coefficients from solvable quotient, local or local-residue rings.
Implemented corresponding interfaces <code>QuotPair</code> and
<code>QuotPairFactory</code> in respective classes.
Adjust and extend scripting examples for the new classes.
Removed differences and clean-up different versions of
<code>Run*GB</code> stand alone Gröbner base programs.
</dd>
<dt>2013, October </dt>
<dd>
Android version of JAS based on Ruboto (JRuby for Android) now with
signed code and installable from <a href="download.html"
target="main">download</a>.
Least common multiple for solvable polynomials and <em>trial</em>
greatest common divisor for solvable polynomials.
Apel-Lassner canonical simplifier to obtain "smaller"
solvable quotients in method <code>leftSimplifier()</code>.
Some code refactoring to break package dependency cycles. Fixed, cleaned
and worked-around some more <em>Findbugs</em> and
<em>Eclipse</em> issues. Dropped Java-5 compatibility in most
places.
</dd>
<dt>2013, September </dt>
<dd>
New distributed Gröbner base algorithms based on the Java
bindings of <a href="http://www.open-mpi.org" target="mpi"
>OpenMPI</a> similarly to the MPJ version. Both OpenMPI and MPJ are
not thread-safe for all devices (in particular not for the
<code>ibvdev</code> InfiniBand device), MPJ is thread-safe for
<code>niodev</code> Java NewIO device. As work-around the transport
layer of both versions is split to allow selection of TCP/IP sockets
or MPI/MPJ channels for transport. The channels and distributed hash
tables have been simplified for both MPJ and MPI. Socket based
distributed hash table now implements the <code>clear()</code>
method. This caused unspecific errors in iterated distributed
Gröbner base computations. Simplified solvable
multiplication. Fixes and improvements to Jython and JRuby scripts.
</dd>
<dt>2013, August </dt>
<dd>
New algorithms for solvable polynomial rings over solvable local
rings in classes <code>LocalSolvablePolynomialRing</code> and
<code>LocalSolvablePolynomial</code>. New scripting examples for
solvable polynomials with solvable local coefficients. Refactoring
for non-commutative relation handling of solvable polynomials with
interface <code>RelationGenerator</code>. Fixed and cleanup some
more <em>Findbugs</em> and <em>Eclipse</em> issues. Several fixes
and improvements for jruby of Android.
</dd>
<dt>2013, July </dt>
<dd>
New algorithms for solvable polynomial rings over solvable residue
rings in classes <code>ResidueSolvablePolynomialRing</code> and
<code>ResidueSolvablePolynomial</code>. Methods to compute
annihilators with respect to ideals and solvable ideals. New
scripting examples for solvable polynomials with solvable residue
coefficients. Fixed associativity of solvable multiplication by
considering all Ore conditions.
</dd>
<dt>2013, May - June </dt>
<dd>
New algorithms for recursive solvable polynomial rings in classes
<code>RecSolvablePolynomialRing</code> and
<code>RecSolvablePolynomial</code>. New solvable polynomial rings
with solvable quotient coefficients are avaliable in classes
<code>QuotSolvablePolynomialRing</code> and
<code>QuotSolvablePolynomial</code>. This rings feature
non-commutative multiplication of variables with coefficients.
New scripting examples for recursive solvable polynomial rings and
solvable polynomials with solvable quotient coefficients.
</dd>
<dt>2013, April - May </dt>
<dd>
New algorithms for ideals in solvable polynomial rings in class
<code>SolvableIdeal</code>, and new structures for solvable
polynomial rings in classes <code>SolvableQuotient</code>,
<code>SolvableResidue</code> and the corresponding factories
<code>SolvableQuotientRing</code>,
<code>SolvableResidueRing</code>. There is a new theme for Ruby rdoc
documentation and the scripts have been adapted to a newer version of
jruby (1.7.3). Further small fixes and improvements.
</dd>
<dt>2013, January </dt>
<dd>
New version number 2.5. The JAS Java API will be more stable from now
on. Fixed a race condition in distributed (hybrid) Gröbner
bases implementations. Improved MPJ version of GBs. Refactoring of
<code>GBFactory</code> and added new option to select Gebauer &
Möller critical pair handling in
<code>GBAlgorithmBuilder</code>. Switch to DECIMAL128 as default in
<code>BigDecimal</code>. Improved
<code>GreatestCommonDivisorHensel</code> by using integer evaluation
points and other optimizations.
</dd>
<dt>2012, December </dt>
<dd>
Mostly performance optimizations and small improvements and fixes.
The optimizations include combined methods for polynomials like
<code>scaleSubtractMultiple(b, g, a, e, S)</code> to compute the expression <em>b
x<sup>g</sup> this - a x<sup>e</sup> S</em> in one rush. There is now first
version of an Android App. The JAS App uses its JRuby
scripting interface and runs within the Ruby IRB Android App
<a href="http://www.ruboto.org">Ruboto</a>.
</dd>
<dt>2012, November </dt>
<dd>
New distributed Gröbner base algorithms based on MPI as
communication middle-ware. The implementation uses the MPJ (MPI Java)
API and can be run with both <a href="http://mpj-express.org/"
target="mpj" >MPJ Express</a> or <a href="http://fastmpj.com/"
target="mpj" >FastMPJ</a>. The implementing classes are
<code>GroebnerBaseDistributedMPJ</code> for the pure distributed
version and <code>GroebnerBaseDistributedHybridMPJ</code> for the
distributed and multi-threaded version.
</dd>
<dt>2012, October </dt>
<dd>
New parts for free non-commutative Gröbner base computation and
polynomial reduction. New interface <code>WordGroebnerBase</code>
and new classes <code>WordGroebnerBaseAbstract</code> and
<code>WordGroebnerBaseSeq</code>. jython and jruby access to
non-commutative polynomials in <code>WordPolyRing</code> and
<code>WordIdeal</code>. Improved selection of (commutative)
Gröbner base algorithm implementations in class
<code>GBAlgorithmBuilder</code>. For example in case of rational
number coefficients a fraction free algorithm with optimization of
the variable order can be requested by <code>gbab.fractionFree()
.optimize() .build()</code>.
</dd>
<dt>2012, September </dt>
<dd>
Refactorings to further reduce Findbugs issues. Removed
<code>Clonable</code> from <code>Element</code> and renamed
<code>clone()</code> to <code>copy()</code>. New classes for free
non-commutative associative rings in <code>GenWordPolynomial</code>
and <code>GenWordPolynomialRing</code>.
</dd>
<dt>2012, August</dt>
<dd>
Fixed most severe and many medium Findbugs issues. Remaining
programming issues and possible bugs are listed in the
<a href="findbugs.html" target="fb">Findbugs report</a>.
</dd>
<dt>2012, July</dt>
<dd>
More JRuby examples. Bug fixes for right module Gröbner bases
and multiple roots computation. Bug fixes for meaningful problems
spotted by findbugs.
</dd>
<dt>2012, June</dt>
<dd>
Improved root bounds for real root computation. Added missing
methods for real root computation. Fixed complex root selection of
zero dimensional ideals. Small fixes and more missing methods.
</dd>
<dt>2012, May</dt>
<dd>
More, refactored and fixed algorithms for Wu-Ritt characteristic sets
in class <code>CharacteristicSetWu</code>. Unit tests are in
<code>CharSetTest</code>. jython and jruby script access to
characteristic set algorithms in methods <code>CS()</code>,
<code>isCS()</code>, <code>csReduction()</code>. Small fixes and
improvements.
</dd>
<dt>2012, March</dt>
<dd>
The Jython and JRuby scripting classes <code>PolyRing</code> are now
injecting the polynomial ring variables into the top level
interpreter environment by default. New class
<code>GroebnerBaseFGLM</code> to compute a Gröbner base
according to the "FGLM" algorithm. It computes a Gröbner base
with respect to a graded term order and then constructs the
Gröbner base with respect to the requested term order via linear
algebra in the residue class ring. Changes from '<code>{}</code>' to
'<code>()</code>' in <code>GenPolynomial</code> to string conversion.
New launcher shell script <code>jas</code>. Small fixes, improvements
and a missing method implemented and in <code>PolyUtilApp</code>.
</dd>
<dt>2012, February</dt>
<dd>
Refactorings to simplify type parameters and loosen type
conditions. New package <code>edu.jas.ufdroot</code> to remove cyclic
package dependencies again. Improved selection of factorization
implementations in <code>FactorFactory</code> classes and better
suited constructors of the factorization implementations. Small
fixes and improvements.
</dd>
<dt>2012, January</dt>
<dd>
Some algorithms for Wu-Ritt characteristic sets and unit tests in
class <code>PolyGBUtil</code>. Small fixes and improvements.
</dd>
<dt>2011, Sylvester</dt>
<dd>
Modular variants and parallel proxy versions of resultant algorithms
implemented. Cleanup and filled missing methods in
<code>GreatestCommonDivisor*</code> classes in the
<code>edu.jas.ufd</code> package. Fixed <code>ModLong</code> to
<code>ModInteger</code> conversion. Small fixes, improvements and
refactorings of methods to right classes.
</dd>
<dt>2011, December</dt>
<dd>
Switched to Java 7 for development. JAS will still compile and run on
Java 6 and Java 5. A new online repositoriy for JAS on
<a href="http://code.google.com/p/java-algebra-system/" target="gc">Google code</a>
which contains a bug-tracker. Definition of variables for polynomial ring
generators in the jython and jruby scripting interface. More JRuby examples.
</dd>
<dt>2011, October</dt>
<dd>
Separated test classes to new test source tree (trc). New <a
href="../examples/basic_sigbased_gb.py" target ="py">scripting
classes</a> for Gröbner base computations according to Eder and
Perry (F5, Arri, GGV) and adapted <code>jas.py</code> in JAS for the
required methods. More JRuby examples. Small improvements and
fixes.
</dd>
<dt>2011, September - October</dt>
<dd>
Release 2.4 updates all depending packages to the latest version and
prepares for JAS 3.0. Updates for Jython 2.5.2 and JRuby 1.6.4. A
new <a href="algo-ca-book.html">index</a> of all algorithms from the book
<a href="http://www.springer.com/computer/theoretical+computer+science/book/978-0-7923-9259-0"
target="algca">Algorithms for Computer Algebra</a> by Geddes &
Czapor & Labahn to their JAS equivalents. Small improvements and
fixes again in multivariate integral polynomial factorization.
</dd>
<dt>2011, September</dt>
<dd>
Bug fixes and missing cases for multivariate integral polynomial
factorization with multivariate Hensel lifting. Further improvements
and fixes.
</dd>
<dt>2011, August</dt>
<dd>
Experimental multivariate integral polynomial factorization with
multivariate Hensel lifting in method
<code>factorsSquarefreeHensel()</code> in class
<code>FactorInteger</code>. Improved multivariate Hensel lifting in
class <code>HenselMultUtil</code>. Small improvements and fixes.
</dd>
<dt>2011, June</dt>
<dd>
Experimental ideal complex root computation in method
<code>complexAlgebraicRoots()</code> in class
<code>PolyUtilApp</code>. Simple isolating interval refinement for
real and complex roots. Alternative factoring of univariate
polynomials over algebraic number fields via prime ideal
decomposition in class <code>FactorAlgebraicPrim</code>. Improved
parsing of complex numbers. Forced term orders in some situations
and further small improvements and fixes.
</dd>
<dt>2011, May </dt>
<dd>
Complex roots represented by ideal real roots, uses new class
<code>RealAlgebraicNumber</code> and <code>RealAlgebraicRing</code>
in package <code>edu.jas.application</code>. New experimental
<code>RootFactory</code> with methods to compute complex roots for
polynomials with coefficients in some complex algebraic extension
field of the rational numbers. Uses the respective classes form
package <code>edu.jas.root</code> in a recursive setting.
New generic factorization classes <code>FactorRealAlgebraic</code>
and <code>FactorRealReal</code>. Small improvement for reduced / minimal
Gröbner base computation.
</dd>
<dt>2011, April </dt>
<dd>
Multivariate algebraic ring / field extensions using class
<code>ResidueRing</code>. Jruby and Jython versions and examples of
the extension field builder. Small improvements and bug fixes for
latest Eclipse and Java 1.7 version.
</dd>
<dt>2011, March </dt>
<dd>
Easy to use construction of towers of extension fields in class
<code>ExtensionFieldBuilder</code> with methods for algebraic and
transcendental field extensions. Improvements in real and complex
algebraic numbers. Improved polynomial parser for recursive
representations. Small bug fixes.
</dd>
<dt>2011, February </dt>
<dd>
New class <code>HenselMultUtil</code> for multivariate Hensel lifting.
Will be used in polyomial factorization in the future.
Some parts of greatest common divisor using multivariate Hensel lifting.
The JAS source (r3408) compiles on Apache Harmony 6.0 (r991881). The
unit tests pass with the exception of test cases involving object
serialization.
</dd>
<dt>2011, January </dt>
<dd>
New scripting interface to Ruby (JRuby). Ruby allows rational number
literals as p/q, which are better than the Python tuple form (p,q).
Some <code>toScript()</code> methods rewritten to reflect the Ruby
language requirements and to differentiate between Ruby and Python.
More precise exceptions for modular computations to return also the
discovered factors.
</dd>
<dt>2010, December, 28</dt>
<dd>
Cleanup of package structure so that all cyclic dependencies have
been removed, see <a href="../images/PackageOverview.png">diagram</a>.
Split factory parsing parts from <code>GenPolynomialTokenizer</code>
to <code>RingFactoryTokenizer</code>. Some artificial code was
required to use solvable polynomials as ring elements since solvable
polynomials cannot implement
<code>RingElem<GenSolvablePolynomial<C>></code>. This
resulted in some cases in wrong method dispatch for the
<code>multiply()</code> method due to compiler optimizations. A work
around to detect and repair this is now implemented in class
<code>GenPolynomial</code>.
</dd>
<dt>2010, December, 18 </dt>
<dd>
New critial pair selection for Gröbner base computation with
syzygy based algorithm after Gebauer and Möller in class
<code>OrderedSyzPairlist</code>. Refactoring of Gröbner base
classes to optionally use the new pair selection. Back port of some
JDK 1.6 constructs to be again compatible with JDK 1.5. Small
improvements in Kronecker factor combination in class
<code>FactorAbstract</code>. Fixed race condition in
<code>ThreadPool</code> and improved termination detection in
<code>Terminator</code>. Fixes in parallel reduced Gröbner base
computations. Fixed univariate polynomial construction in
<code>Ideal</code>.
<!-- New complex roots directly for rational polynomials in
<code>RootFactory</code>. -->
</dd>
<dt>2010, October </dt>
<dd>
Multivariate Taylor series expansion interface and implementation.
Improved multivariate power series for standard base computation.
Refactored methods to better suited classes and moved classes to decouple packages,
e.g. <code>Quotient*</code> to package <code>edu.jas.ufd</code>.
Fixed small bugs and cosmetic.
</dd>
<dt>2010, September </dt>
<dd>
Multivariate power series in classes <code>MultiVarPowerSeries</code>
and <code>MultiVarPowerSeriesRing</code>. Mora's tangent cone reduction
algorithm and standard base computation for power series in package
<code>edu.jas.ps</code>. Iterator over exponent vectors.
</dd>
<dt>2010, August, 28 </dt>
<dd>
Iterators for finite and some infinite structures and finite and
infinite cartesian products of them. Fixed constructors to comply
with the (new) Java memory model. Small bug fixes and
improvements. More meaningful exceptions and some renamings.
</dd>
<dt>2010, August, 8 </dt>
<dd>
Improved the polynomial parser to accept rational numbers denoted
with decimal points and to accept <code>BigDecimal</code>
coefficients. Removed the use of the underscore for algebraic number
coefficients in the polynomial parser. Now every recursive call of
<code>parse()</code> from a ring factory is triggered by braces which
can be nested to any depth. Fixed synchronization bug in solvable
polynomial relation tables and a parallelization bug in parallel
solvable polynomial Gröbner base computation. Use of unbounded
thread pools to avoid dead-locks. Added remaining parts for the
square-free decomposition in polynomial rings of characteristic p
> 0. Changed the script representation of <code>AN</code>
(<code>AlgebraicNumber</code>s).
</dd>
<dt>2010, July </dt>
<dd>
Downgraded for Java 5 language and run-time system for use with systems relying on
older Java versions, for example MathPiper and GeoGebra.
New class <code>edu.jas.kern.TimeStatus</code> to provide user feedback for
long running tasks via method <code>checkTime()</code>.
Implemented some missing <code>extGB()</code> methods. <code>GBFactory</code> for
the selection of appropriate Gröbner base implementations.
New method <code>isFinite()</code> for all <code>ElemFactory</code>s and usage
in <code>SquarefreeFactory</code>. Added some missing parts for the factorization
in polynomial rings of characteristic p > 0 and ideal decomposition.
</dd>
<dt>2010, June </dt>
<dd>
Factory for Gröbner base algorithm implementations in class <code>GBFactory</code>.
New <code>GBProxy</code> like <code>GCDProxy</code> to run a sequential and a parallel
Gröbner base computation concurrently.
Primitive element computation via <code>normalPositionFor()</code> in
methods <code>primitiveElement()</code> together with several
conversion methods <code>convertToPrimitiveElem()</code>. A new
<a href="gb-book.html">index</a> of all algorithms from the book
<a href="http://www.springer.com/mathematics/book/978-0-387-97971-7"
target="gbb">Gröbner bases</a> to their JAS equivalents.
</dd>
<dt>2010, May, 28 </dt>
<dd>
Implementation of arbitrary dimensional ideal radical-, irreducible-, prime-
and primary-decomposition in class <code>Ideal</code> with methods
<code>radicalDecomposition()</code>,
<code>decomposition()</code>,
<code>primeDecomposition()</code> and
<code>primaryDecomposition()</code>.
Computation of extension and contraction ideals.
Unit tests for the decomposition methods.
Fixed a bug in multivariate polynomial factorization in Kronecker's method.
<!-- (wrong usage of <code>removeAll</code> for factors) -->
Fixed a bug in squarefree decomposition in inseparable case.
Added <code>NO_THREADS</code> flag to <code>edu.jas.kern.ComputerThreads</code>
to avoid (some) thread creation for usage in Google app engine.
</dd>
<dt>2010, May, 8 </dt>
<dd>
Implementation of zero dimensional ideal radical-, prime-, primary-
and root-decomposition in class <code>Ideal</code> with methods
<code>zeroDimRadicalDecomposition()</code>,
<code>zeroDimDecomposition()</code>,
<code>zeroDimPrimeDecomposition()</code>,
<code>zeroDimPrimaryDecomposition()</code> and
<code>zeroDimRootDecomposition()</code>. Exact 0-dim ideal real root
computation and approximation in methods
<code>PolyUtilApp.realAlgebraicRoots()</code> and
<code>decimalApproximation()</code>. Small enhancements to Javadoc
comments.
</dd>
<dt>2010, April </dt>
<dd>
Some more documentation for package <code>edu.jas.ufd</code>,
simplified and improved the factory classes. Refactorings of
parallel Gröbner bases computations for solvable polynomial
rings. Improved logging for distributed Gröbner bases and
distributed middle-ware.
</dd>
<dt>2010, March </dt>
<dd>
Decimal approximations for real and complex roots based on Newton-Raphson iteration
restricted to isolating intervals or rectangles.
Small enhancements for partial Gröbner bases. Added some Mersenne primes to
<code>PrimeList</code>.
Construction of minimal univariate polynomials in zero dimensional ideals.
Supersets of complex and real roots of zero dimensional ideals. More unit tests for
real and complex roots of univariate polynomials and zero dimensional ideal roots.
Minor enhancements and fixes.
</dd>
<dt>2010, February </dt>
<dd>
Gröbner bases for sub-sets of variables in class <code>GroebnerBasePartial</code>.
Small enhancements: polynomial recursive coefficient parser and a
matrix parser. Book-keeping of all used polynomial variable names.
New and improved unit tests.
</dd>
<dt>2010, January </dt>
<dd>
Factorization for polynomials with <code>Complex</code> coefficients via algebraic
coefficients in Q(i).
New classes <code>ModLong</code> and <code>ModLongRing</code> for faster modular arithmetic.
New interfaces <code>Modular</code> and <code>ModularRingFactory</code> implemented also by
<code>ModInteger</code> to make both interchangable.
Improved factorization and serveral refactorings. Factorization mod p = 2 is now implemented.
</dd>
<dt>2009, December</dt>
<dd>
Added a Git repository and a link to Ohloh code analysis of JAS.
Cosmetic, small updates and a simple Java scripting interface.
New classes for complex root isolation <code>ComplexRoots</code>, <code>ComplexRootsAbstract</code>,
<code>ComplexRootsSturm</code>.
The implementation provides an exact infallible method which follows the numeric method of Wilf.
It uses Sturm sequences following the Routh-Hurwitz Method
to count the number of complex roots within a rectangle in the complex plane.
</dd>
<dt>2009, November</dt>
<dd>
New package for the elementary integration of rational functions
developed together with Axel Kramer during the computer algebra seminar 2009.
The implementation is based on the book <em>Bronstein: Symbolic Integration I</em>.
New adapter (<a href="commons-math_adapter.jar">commons-math_adapter.jar</a>)
for JAS to the Apache Commons Math library version 2.0 by Axel Kramer.
Cosmetic, small updates and a jython example for integration.
</dd>
<dt>2009, September </dt>
<dd>
Improved comprehensive Gröbner bases with explicit classes for
several alternative implementations of multiplicative sets.
Base class is <code>MultiplicativeSet</code>, in sub-classes
polynomials made co-prime in <code>MultiplicativeSetCoPrime</code>,
polynomials made co-prime and squarefree in <code>MultiplicativeSetSquarefree</code>
and polynomials made irreducible in <code>MultiplicativeSetFactors</code>.
New distributed hybrid Gröbner base computation with new class
<code>TaggedMesageChannel</code> to handle multiple message types and partners over
one socket connection. Improved object serialization in distributed hash table.
Adapter updated for JLinAlg version 0.6.
</dd>
<dt>2009, August </dt>
<dd>
New adaptor classes (<a href="jlinalg_adapter.jar">jlinalg_adapter.jar</a>)
to use the linear algebra library
<a href="http://jlinalg.sourceforge.net/" target="rela">JLinAlg</a> from JAS.
Improvements in the distributed Gröbner bases algorithms.
Minor fixes and improvements.
</dd>
<dt>2009, July </dt>
<dd>
Code and output cosmetic, minor fixes and improvements.
New interface <code>ToRational</code> used for <code>BigRational</code>
and <code>RealAlgebraicNumber</code> to remove type case distinctions
in <code>Interval</code>.
<code>clone()</code> removed from <code>Element</code> interface because
of compiler changes.
</dd>
<dt>2009, June and July </dt>
<dd>
Improved absolute factorization for splitting fields. Fixes and
further improvements. Implemented factorization over inseparable
field extensions. Fixed squarefree factorization and added unit
test. Refactored squarefree tests to separate classes. Refactored
squarefree algorithms to separate classes.
Interface is <code>Squarefree</code>, abstract class is
<code>SquarefreeAbstract</code>. Other main classes are
<code>SquarefreeFieldChar0</code>, <code>SquarefreeFiniteFieldCharP</code>
and <code>SquarefreeInfiniteFieldCharP</code>.
</dd>
<dt>2009, June </dt>
<dd>
Improved algebraic and absolute factorization.
<code>FactorAlgebraic</code> can now also handle factorizations over
multiple algebraic extensions like for example Q(i)(sqrt(2)).
Class <code>FactorAbsolute</code> is now also extended
by <code>FactorAlgebraic</code>, so that absolute factorizations can
be computed over algebraic extensions of Q. Added new containers for
absolute factorization results and tests for correct absolute
factorizations. More <code>toScript()</code> methods and
improvements in Jython script interface. Minor additions and fixes.
</dd>
<dt>2009, May </dt>
<dd>
Improved Jython script interface to handle most of the implemented rings,
developed in cooperation with Raphael Jolly.
New or improved Python functions <code>ZZ, ZM, QQ, DD, CC, Quat, Oct</code>,
<code>PolyRing, AN, RealN, RF, RC, LC, SolvPolyRing</code>
and <code>RR, PS, Vec, Mat</code> for the construction of rings and elements.
Added generic <code>Complex</code> class and <code>ComplexRing</code> factory.
Fixed a programming bug in factorization code.
</dd>
<dt>2009, April </dt>
<dd>
Added <code>factory()</code> method to <code>Element</code> interface to have an uniform way to
obtain a corresponing ring object.
Improved <code>RealAlgebraicNumber</code> so that it can be used as polynomial coefficients,
for example <code>GenPolynomial<RealAlgebricNumber<BigRational>></code>.
Real root isolation can now also be used for polynomials with real algebraic coefficients,
for example <code>RealRootsSturm<RealAlgebraicNumber<BigRational>></code>.
</dd>
<dt>2009, March </dt>
<dd>
Implemented univariate polynomial real root isolation algorithms
and real algebraic numbers in package <code>edu.jas.root</code> during CISIS/ECDS 2009.
Reached 100.000 lines of Java code.
</dd>
<dt>2009, February </dt>
<dd>
Finished first version of polynomial factorization algorithms.
Refactored package names <code>edu.jas.ring</code> to <code>edu.jas.gb</code>
and <code>edu.jas.module</code> to <code>edu.jas.gbmod</code>.
</dd>
<dt>2009, January</dt>
<dd>
Switch to version 2.3 with experimental factorization of polynomials.
<code>Factorization</code> interface with <code>FactorAbstract</code> class for common codes.
Factorization of univariate polynomials with several coefficient rings:
modulo primes in class <code>FactorModular</code>,
over integers in class <code>FactorInteger</code>,
over rational numbers in class <code>FactorRational</code> and
over algebraic numbers in class <code>FactorAlgebraic<C></code>
(where <code>C</code> can be <code>ModInteger</code> or <code>BigRational</code>).
Multivatiate polynomials are reduced to the univariate polynomials via Kronecker substitution
and are therefore not very efficient.
Refactorings and fixes.
</dd>
<dt>2008, December </dt>
<dd>
Fixed squarefree part and factor computation for modular coefficients.
Fixed polynomial <code>compareTo</code> to be transitive as required by
Javas <code>SortedMap</code> implementations.
Implemented an adaptor package for Apache Log4j to delegate logging calls to native Java logging.
</dd>
<dt>2008, September</dt>
<dd>
Implemented univariate power series during ADG2008
as <code>RingElem</code> and <code>RingFactory</code> types
in package <code>edu.jas.ps</code>
in classes <code>UnivPowerSeries</code> and <code>UnivPowerSeriesRing</code>.
The implementation follows the "Infinite Streams in Java" paper of D. Gruntz
in PPPJ2006.
</dd>
<dt>2008, August, 11</dt>
<dd>
Added jython html documentation generated by epydoc.
Added jython module to allow native polynomial expression input.
</dd>
<dt>2008, August, 8</dt>
<dd>
New release 2.2.
Implemented interface to use JAS as an meditor engine,
see <a href="http://jscl-meditor.sourceforge.net/" target="rela">jscl-meditor</a>.
</dd>
<dt>2008, July </dt>
<dd>
Finished implementation of comprehensive Groebner bases via Groebner systems.
Object oriented class layout uses <code>Condition</code>
and <code>ColoredSystem</code> classes.
<code>Condition</code>s consist of an ideal
(with lazy Groebner base computation) for the conditions equal to zero
and a multiplicative set for the conditions not equal to zero.
Non-zero condition polynomials are reduced modulo the ideal of
condition zero polynomials.
The squarefree part from both condition polynomials is used.
It differs from the MAS implementation by Schoenfeld, Pesch and others
by the ideal used to store the zero conditions and some more details.
</dd>
<dt>2008, June </dt>
<dd>
Added dimension computation to Ideal.
Added term order optimization method to Ideal.
Refactored ExpVector for different storage unit implementations of the exponent arrays.
Supported storage units are <code>long</code>,
<code>int</code> (now the default, as seems to be the fastest),
<code>short</code> and <code>byte</code>.
The respective classes are <code>ExpVectorLong</code>,
<code>ExpVectorInteger</code>,
<code>ExpVectorShort</code> and <code>ExpVectorByte</code>.
</dd>
<dt>2008, January and February</dt>
<dd>
Added Groebner bases for polynomial rings over regular rings
<code>RGroebnerBaseSeq</code> and <code>RGroebnerBasePseudoSeq</code>.
Refactorings and fixes.
</dd>
<dt>2007, November and December</dt>
<dd>
Added von Neuman regular rings as (finite) direct products of rings,
<code>Product</code> and <code>RegularRingElem</code>.
Added fraction free pseudo reduction and Groebner bases
<code>GroebnerBasePseudoSeq</code>.
Minor refactorings and fixes.
</dd>
<dt>2007, October</dt>
<dd>
Added Groebner bases in polynomial rings over principal ideal domains
and Euclidean domains, so called D- and E-Groebner bases,
<code>DGroebnerBaseSeq</code> and <code>EGroebnerBaseSeq</code>.
Added test methods for reducibility and refactored sequential
Groebner base implementations.
</dd>
<dt>2007, September</dt>
<dd>
Minor refactorings and fixes.
Modular rational functions and related conversions.
</dd>
<dt>2007, August, 19</dt>
<dd>
Added term order optimization for
polynomial and rational function coefficients.
</dd>
<dt>2007, August, 12</dt>
<dd>
Cleanup of UFD code and subversion exports.
Term order optimization also available in jython.
</dd>
<dt>2007, July, 28</dt>
<dd>
Added term order optimization class from old DIP/MAS system.
This introduced a dependency on JDK 1.6.
Refactored source tree to allow fully functional subversion exports.
</dd>
<dt>2007, July, 12</dt>
<dd>
New global class edu.jas.kern.ComputerThreads to represent a thread pool.
To stop JAS, when the pool has been started, it is required
to call ComputerThreads.terminate().
</dd>
<dt>2007, July, 11</dt>
<dd>
New preemptive cancellation handling.
Introduced class PreemptingException as runtime exception and
a global class PreemptStatus to allow or deny preemption cancellation.
GenPolynomialRing queries PreemptStatus upon creation.
GenPolynomial checks preempt cancellation handling and thread interrupt status
on construction. If preemption is requested, it throws PreemptingException.
This allows e.g. GCDProxy to ignore the respective sub-task and get the thread free.
Removed explicit isInterrupted() checks in edu.jas.ufd package.
</dd>
<dt>2007, July, 10</dt>
<dd>
Refactored generation of (lists of) univariate polynomials
from SolvableGroebnerBase* to GenSolvablePolynomialRing and GenPolynomialRing.
Implemented generic Power class in edu.jas.structure,
refactored power() in subresultant PRS.
</dd>
<dt>2007, July, 9</dt>
<dd>
Added unit tests for distributive law in arith and poly packages.
Review of all documentation comments.
</dd>
<dt>2007, July, 8</dt>
<dd>
Added assertions to check for number of polynomial variables in GenPolynomial.
In ModInteger and AlgebraicNumber inverse() now throws a NotInvertibleExecption,
which extends runtime exception.
Fixed some correctness bugs detected by Findbugs.
</dd>
<dt>2007, July, 7</dt>
<dd>
Refactored ModInteger for ModIntegerRing factory.
Changed all depending classes.
Refactored GenPolynomial.getMap() to return unmodifiable SortedMap.
Refactored GenPolynomial.val using methods from jas.ufd package to jas.poly package.
ExpVector.getVal() renamed and made package private.
Logger variables now also final.
</dd>
<dt>2007, June, 10</dt>
<dd>
Improved InterruptedException handling.
Refactored use of edu.ky.parallel package to use edu.jas.util and
java.util.concurrent.
Refactored project web-site.
</dd>
<dt>2007, April and May </dt>
<dd>
Implementation of greatest common divisor algorithms.
Using recursive types.
Implemented remainder sequences: primitive, monic, subresultant.
Implemented modular methods with chinese remaindering for ModIntegers
and evaluation in finite fields to reduce the number of variables.
Implemented Hensel lifting: linear and quadratic; mod ideal is still missing.
Factory classes to select "best" implementations.
Proxy classes to run probable good implementations in parallel,
taking the result of the first terminating algorithm.
Refactored many classes to fit for the new requirements.
New method characteristic() in RingFactory and implementing classes.
Changed Quotient (rational function) to use new gcd algorithms.
Can compute GBs for polynomials with rational function coefficients.
</dd>
<dt>2006, March </dt>
<dd>
Refactored ring package to separate application package with
more application of Groebner bases oriented classes.
The ring package could now be renamed to gb package.
Cosmetic and documentation improvements,
e.g. javadoc package descriptions and type parameter tags,
removed all tabs in all java files.
Implemented generic Quotient(Ring), Residue(Ring) and Local(Ring).
</dd>
<dt>2006, February, 27 </dt>
<dd>
Implemented parallel solvable Groebner base algorithms and tests.
New class distributed ThreadPool.
Cosmetic and code improvements spotted by eclipse, lint4j and jdepend.
Refactored module package to separate vector package with
basic linear algebra and list handling classes.
Refactored to allow different Groebner base or reduction engines
where appropriate.
Split Syzygy etc. to an interface and a class.
Factored basic linear algebra out of Syzygy etc.
Adapted jython files to Jave code refactorings.
Reorganized jar files and documentation.
</dd>
<dt>2006, February, 12 </dt>
<dd>
Moved old examples to MAS subdirectory and new examples
to examples directory.
Implemented some right version algorithms using opposite rings.
Switched to subversion from cvs.
Fixed bugs in new left syzygy algorithm.
</dd>
<dt>2006, January </dt>
<dd>
More documentation and cosmetic.
Implementation of an extended Groebner Base algorithm
and arbitrary base syzygy computation.
GenPolynomialTokenizer enhanced to parse algebraic number
and Galois field coefficients.
Fixed an error in leftNormalform.
</dd>
<dt>2005, 12, 30</dt>
<dd>
New classes CriticalPair and CriticalPairList replace OrderedPairlist.
Reworked GB parallel and distributed versions to better respect
sequential version critical pair sequences.
Fixed some race conditions in parallel and distributed algorithms.
</dd>
<dt>2005, 12, 28</dt>
<dd>
Refactored all classes to remove static methods.
So to use any method at first an appropriate object is required.
Also class organization has changed to interfaces, abstract classes
and concrete classes, e.g. GroebnerBase, GroebnerBaseAbstract,
GroebnerBaseSeq, GroebnerBaseParallel and GroebnerBaseDistributed.
</dd>
<dt>2005, 12, 27</dt>
<dd>
Implemented new Ideal class with some ideal operations
like sum, product, intersection and quotient.
Added TermOrder extension and contraction.
</dd>
<dt>2005, 11-12 </dt>
<dd>
Updated documentation comments.
</dd>
<dt>2005, 7, 24</dt>
<dd>
Updated old Java JDK 1.4 branch.
Bugfixes (in twoSidedGB), minor changes and cosmetic.
<br />
Updated documentation for new Java JDK 1.5 branch.
</dd>
<dt>2005, 5-7</dt>
<dd>
Working through all classes to introduce type parameters
and making all implied modifications.
</dd>
<dt>2005, 5, 5</dt>
<dd>
Switched to Java 1.5.
Now using covariant returns for implemented interfaces.
</dd>
<dt>2005, 3, 25-29</dt>
<dd>
Some module algorithms implemented.
Activated project web pages.
</dd>
<dt>2005, 3, 12-19</dt>
<dd>
Some Syzygy algorithms implemented.
Cosmetic on comments and forked web-log.
</dd>
<dt>2005, 3, 5</dt>
<dd>
For the python languege and interpreter exists also a Java
version named jython. This system can directly access Java classes
and execute Java methods.
Added some jython modules Ring, Ideal, SolvRing and SolvIdeal,
to access jas GB algorithms from jython.
</dd>
<dt>2005, 2, 25-28</dt>
<dd>
Penality of commutative GB computed as non-commutative left GB
is about 24% for (graded) Katsura 6 to 74% for (graded) Katsura 5.
Commutative GB computed as non-commutative twosided GB
is about a factor of 4 for (graded) Katsura 5 to a factor of 9
for (graded) Katsura 5.
Penality for weighted degree term order compated to graded Term order
is not measurable or sometimes better.
Fixed error in polynomial getONE() to correct term order.
Parser for non-commutative problems with relation tables
(but only commutative representations) and RunSGB main routine.
</dd>
<dt>2005, 2, 14-21</dt>
<dd>
New TermOrder with direct generation of Comparators for
ExpVector comparisons. Split term orders (elimination orders)
and weighted degree orders.
</dd>
<dt>2005, 2, 4-8</dt>
<dd>
New unit test case for TermOrder.
Fixed weak point in polynomial getONE() to correct number
of variables, e.g. correct exponent vector size.
Polynomial constant ONE still has wrong exponent vector size.
Deleted many old polynomial classes.
<p>
Implemented noncommutative product for solvable polynomials,
together with relation tables.
SolvableOrderedMapPolynomial extends OrderedMapPolynomial.
RatSolvableOrderedMapPolynomial extends SolvableOrderedMapPolynomial.
Interface SolvablePolynomial extends Ordered Polynomial.
Some more left multiplication methods, left reduction and
left Groebner Bases, twosided Groebner Base test and computation.
Pairlist class changed to avoid usage of criterion 4 if running
for SolvablePolynomials, also criterion4() method itself checks
for SolvablePolynomials.
</p>
<div align="center" >
<table border="1" cellpadding="10"
summary="relation table timings 1" >
<caption>RelationTable timings I, U(sl_3)</caption>
<tr>
<th>run / n</th>
<th>2</th>
<th>3</th>
<th>4</th>
<th>5</th>
<th>6</th>
<th>7</th>
<th>8</th>
<th>9</th>
<th>10</th>
<th>11</th>
<th>12</th>
<th>13</th>
<th>14</th>
<th>15</th>
</tr>
<tr align="right">
<th>first</th>
<td> 3</td>
<td> 13</td>
<td> 32</td>
<td> 92</td>
<td> 128</td>
<td> 188</td>
<td> 274</td>
<td> 420</td>
<td> 683</td>
<td> 1126</td>
<td> 1795</td>
<td> 2793</td>
<td> 4380</td>
<td> 6741</td>
</tr>
<tr align="right">
<th>second</th>
<td> 0</td>
<td> 1</td>
<td> 2</td>
<td> 3</td>
<td> 4</td>
<td> 5</td>
<td> 6</td>
<td> 8</td>
<td> 10</td>
<td> 13</td>
<td> 16</td>
<td> 21</td>
<td> 27</td>
<td> 35</td>
</tr>
</table>
</div>
<p>
Timings in ms on AMD XP 2800+.
Computation of (Y^n) * (X^n) with respect to the relation
Y * X = X Y - H.
In the first run the relation table is populated with the
products Y^i * X^i, i = 2,...,n.
In the second run the relations are reused, showing almost
no computing time anymore for the products.
</p>
<div align="center" >
<table border="1" cellpadding="10"
summary="relation table timings 2" >
<caption>RelationTable timings II, U(sl_3)</caption>
<tr>
<th>run / n</th>
<th>2</th>
<th>3</th>
<th>4</th>
<th>5</th>
<th>6</th>
<th>7</th>
</tr>
<tr align="right">
<th>first</th>
<td> 28</td>
<td> 94</td>
<td> 303</td>
<td> 1234</td>
<td> 5185</td>
<td> 24647</td>
</tr>
<tr align="right">
<th>second</th>
<td> 1</td>
<td> 12</td>
<td> 107</td>
<td> 782</td>
<td> 4569</td>
<td> 23897</td>
</tr>
</table>
</div>
<p>
Second example shows the computation of
( Xa + Xb + Xc + Ya + Yb + Yc + Ha + Hb )^n
in U(sl_3).
Since in the relation table only products of two variables
are stored, the improvement is minimal (for low n).
</p>
</dd>
<dt>2005, 1, 24-31</dt>
<dd>
Removed old deprecated classes.
Todo: let DistHashTable implement Map Interface.
Reimplemented Reduction.Normalform so that asynchronous
update of the polynomial list is possible and respected.
In case a new polynomial arrives, the reduction is restarted
from the beginning. Continuing with the done work and
rereducing so far irreducible terms would be an alternative.
Todo: use JDK 1.5 java.util.concurrent with interference free Lists,
BlockingQueues.
<div align="center" >
<table border="1" cellpadding="10"
summary="distributed timings k6g" >
<caption>Distributed computation timings, Katsura 6 (G)</caption>
<tr>
<th># Threads <br /> CPUs</th>
<th># JVMs</th>
<th>time (sec)</th>
<th>#put</th>
<th>#remove</th>
<th>% total</th>
</tr>
<tr align="right">
<td>1, seq</td>
<td>1</td>
<td>160.2</td>
<td>70</td>
<td>327</td>
<td>13.5</td>
</tr>
<tr align="right">
<td>1, par</td>
<td>1</td>
<td>157.0</td>
<td>70</td>
<td>327</td>
<td>13.5</td>
</tr>
<tr align="right">
<td>2, par</td>
<td>1</td>
<td> 82.2</td>
<td>72</td>
<td>329</td>
<td>12.7</td>
</tr>
<tr align="right">
<td>1, dist</td>
<td>1</td>
<td>177.2</td>
<td>77</td>
<td>334</td>
<td>11.4</td>
</tr>
<tr align="right">
<td>2, dist</td>
<td>2</td>
<td> 92.2</td>
<td>90</td>
<td>347</td>
<td> 8.6</td>
</tr>
<tr align="right">
<td>4, dist</td>
<td>2</td>
<td> 56.2</td>
<td>112</td>
<td>369</td>
<td> 5.9</td>
</tr>
<tr align="right">
<td>8, dist</td>
<td>2</td>
<td> 58.9</td>
<td>255</td>
<td>516</td>
<td> 1.5</td>
</tr>
<tr align="right">
<td>4, dist</td>
<td>4</td>
<td> 51.2</td>
<td>117</td>
<td>374</td>
<td> 5.5</td>
</tr>
<tr align="right">
<td>6, dist</td>
<td>4</td>
<td> 43.7</td>
<td>129</td>
<td>386</td>
<td> 4.6</td>
</tr>
<tr align="right">
<td>8, dist</td>
<td>4</td>
<td> 62.9</td>
<td>259</td>
<td>519</td>
<td> 1.5</td>
</tr>
<!--
<tr align="right">
<td></td>
<td></td>
<td></td>
</tr>
-->
</table>
</div>
<p>Timings taken on a 16 CPU Intel Xeon SMP computer running
at 2.7 GHz and with 32 GB RAM.
JVM 1.4.2 started with AggressiveHeap and UseParallelGC.
<br />
#JVMs = number of distinct Java virtual machines.
#put = number of polynomials put to pair list.
#remove = number of pairs removed from pair list,
i.e. after application of criterions,
but including nulls up to now.
% total = per cent of removed pairs from total pairs generated,
#remove / ( #put * (#put-1) / 2 ) * 100.
</p>
<div align="center" >
<table border="1" cellpadding="10"
summary="distributed timings k7g" >
<caption>Distributed computation timings, Katsura 7 (G)</caption>
<tr>
<th># Threads <br /> CPUs</th>
<th># JVMs</th>
<th>time (sec)</th>
<th>#put</th>
<th>#remove</th>
<th>% total</th>
</tr>
<tr align="right">
<td>1, dist</td>
<td>1</td>
<td>24726.2</td>
<td>140</td>
<td>781</td>
<td> 8.0</td>
</tr>
<tr align="right">
<td>2, dist</td>
<td>2</td>
<td>12356.1</td>
<td>165</td>
<td>806</td>
<td> 5.9</td>
</tr>
<tr align="right">
<td>4, dist</td>
<td>4</td>
<td>6859.3</td>
<td>218</td>
<td>859</td>
<td> 3.6</td>
</tr>
<tr align="right">
<td>8, dist</td>
<td>4</td>
<td>7465.1</td>
<td>411</td>
<td>1054</td>
<td> 1.2</td>
</tr>
<tr align="right">
<td>8, dist</td>
<td>8</td>
<td>6412.9</td>
<td>344</td>
<td>986</td>
<td> 1.6</td>
</tr>
<tr align="right">
<td>8, dist</td>
<td>8</td>
<td>7173.3</td>
<td>399</td>
<td>1041</td>
<td> 1.3</td>
</tr>
</table>
</div>
<p>
Overhead for distributed variant is about 10% in Katsura 6 (G).
Distributed 1 means one distributed process is running for the
reduction of S-polynomials. There is always a master process
handling polynomial input / output, setup and management of
distributed workers and handling of the pair list.
Communication between master and workers is always via TCP/IP
with object serialization, even if running on one computer.
</p>
</dd>
<dt>2005, 1, 15-16</dt>
<dd>
Further things to improve in GB algorithms (from tsp):
local work queues, i.e. local Pairlists,
improve data locality in polynomials and lists,
communication using message types,
reduce object serialization in DL-broadcast
by using MarshalledObjects,
reduce communication in Pair send by not sending polynomials
but indicies (requires distributed hashtable instead of DL),
interleave communication and computation by adding a
communication thread in the distributed client.
<p>
New classes implementing a distributed hash table to hold the
polynomials in distributed GB. Index of polynomials in Pairlist
is used as hash key.
Communication is now using message types GBTransportMess.
Now polynomials are only transported once to each reducer since
only polynomial hash indexes are transported.
Distributed list is asynchronous and late updated,
so some duplicate H-polynomials (head terms) could be (are) produced.
Solution by local put to hash table with dummy index?
Timings are not dramatically better.
</p>
<p>Todo: check reduction algorithm to use later arriving polynomials.
</p>
</dd>
<dt>2005, 1, 9-14</dt>
<dd>
Introduced all direct improvements in util classes found so far.
(ChannelFactory and others)
On parallel computers the following JVM options (1.4.2)
must be used:
<pre>
-Xms200M -Xmx400M -XX:+AggressiveHeap -XX:+UseParallelGC
</pre>
Memory must be adjusted with respect to your situation.
<p>
Seperated versions with Pair Sequence Respecting Order (PS) and
normal versions. PS versions try to keep the order of
reduced polynomials added to the ideal base the same as in
the sequential version.
Normal versions now running OK on parallel computer with the
right JVM options.
Refactoring with Eclipse (organize imports, static methods).
</p>
<div align="center" >
<table border="1" cellpadding="10"
summary="parallel timings" >
<caption>Parallel computation timings, Katsura examples</caption>
<tr>
<th># Threads<br />CPUs</th>
<th>Katsura 6 TO(G) <br />load*</th>
<th>Katsura 6 TO(G) <br />empty*</th>
<th>Katsura 7 TO(G) <br />load*</th>
<th>Katsura 7 TO(G) <br />empty*</th>
</tr>
<tr align="right">
<td>seq</td>
<td>184.5</td>
<td>153.3</td>
<td></td>
<td></td>
</tr>
<tr align="right">
<td>1</td>
<td>181.5</td>
<td>4% / 159.7</td>
<td></td>
<td>28418.6</td>
</tr>
<tr align="right">
<td>2</td>
<td>118.6</td>
<td>s2.02 / p2.11 / 75.6</td>
<td></td>
<td>p2.06 / 13760.0</td>
</tr>
<tr align="right">
<td>4</td>
<td>76.8</td>
<td>s3.79 / p3.95 / 40.4</td>
<td>6256.9</td>
<td>p4.56 / 6225.1</td>
</tr>
<tr align="right">
<td>8</td>
<td>43.2</td>
<td>s7.19 / p7.49 / 21.3</td>
<td>3240.7</td>
<td>p8.56/ 3318.8</td>
</tr>
<tr align="right">
<td>10</td>
<td>42.5</td>
<td></td>
<td></td>
<td></td>
</tr>
<tr align="right">
<td>12</td>
<td>40.5</td>
<td></td>
<td>2288.1</td>
<td>p9.90 / 2868.4</td>
</tr>
<tr align="right">
<td>14</td>
<td>31.2</td>
<td></td>
<td></td>
<td></td>
</tr>
<tr align="right">
<td>16</td>
<td>51.9</td>
<td>s8.19 / p8.54 / 18.7</td>
<td>5376.4</td>
<td>p12.59 / 2256.1</td>
</tr>
<!--
<tr align="right">
<td></td>
<td></td>
<td></td>
</tr>
-->
</table>
</div>
<p>Timings taken on a 16 CPU Intel Xeon SMP computer running
at 2.7 GHz and with 32 GB RAM.
JVM 1.4.2 started with AggressiveHeap and UseParallelGC.
<br />
*) timing taken with other load on the CPUs.
+) timing taken with no other load on the CPUs.
<br />
Speedup: s = relative to sequential,
p = relative to parallel with one thread / CPU.
<br />
Scaling from 8 to 16 CPUs is bad, but also observed on
non CA / GB Examples (Java and C/FORTRAN).
</p>
</dd>
<dt>2004, 10, 3 </dt>
<dd>
Generator for Katsura examples (from POSSO / FRISCO examples).
Timings on an AMD Athlon XP 2800 (2086MHz) with log level INFO.
Log level WARN would gain 10-20 %.
<div align="center" >
<table border="1" cellpadding="10"
summary="Timings Katsura examples" >
<caption>Timings Katsura examples</caption>
<tr>
<th>N <br />vars = N+1</th>
<th>TermOrder</th>
<th>Seconds</th>
<th>TermOrder</th>
<th>Seconds</th>
</tr>
<tr align="right">
<td> 7 </td>
<td> G </td>
<td>32044.204</td>
<td> L </td>
<td></td>
</tr>
<tr align="right">
<td> 6 </td>
<td> G </td>
<td>112.641</td>
<td> L </td>
<td></td>
</tr>
<tr align="right">
<td> 5 </td>
<td> G </td>
<td>4.195</td>
<td> L </td>
<td></td>
</tr>
<tr align="right">
<td> 4 </td>
<td> G </td>
<td>0.431</td>
<td> L </td>
<td>11.650</td>
</tr>
<tr align="right">
<td> 3 </td>
<td> G </td>
<td>0.153</td>
<td> L </td>
<td>0.310</td>
</tr>
<tr align="right">
<td> 2 </td>
<td> G </td>
<td>0.031</td>
<td> L </td>
<td>0.032</td>
</tr>
</table>
</div>
</dd>
<dt>2004, 9, 20-26 </dt>
<dd>
Changed OrderedPairlist to record the sequence of pairs taken from the list.
New methods <code>putParallel()</code>, <code>removeParallel()</code> and
helper methods. Sequence numbers are generated and reduced polynomials
are only put to the pair list if corresponding pair number is in
correct (sequential) sequence.
The ordered list / queue <code>pairsequence</code> (TreeMap/SortedMap)
keeps track of the polynomials not yet put to the pairlist.
<br />
Parallelism is possible as long there are pairs to be reduced.
But non zero reduced polynomials are only put into the pairlist if
the polynomial would be put into the pairlist in the sequential
Buchberger algorithm.
GroebnerBase algorithms had to be modified to record that a polynomial
reduced to zero.
</dd>
<dt>2004, 9, 19 </dt>
<dd>
Changed order of Pair inserts for pairs with same LCM of HTs.
Added sequence number to each Pair and indicator if Pair did not
reduce to zero.
</dd>
<dt>2004, September </dt>
<dd>
Implemented Java server (<code>ExecutableServer</code>) for remote execution
of objects implementing the <code>RemoteExecutable</code> interface.
<p>New setup for the distributed computation of GBs:
the GB master now sends the client code to some ExecutableSevers
based on a maschine file with host and port infos about the
distributed environment.
</p>
<p>Improved the PolynomialTokenizer so that it can read almost unedited
old MAS GB input files: <code>**</code> exponents and parenthesis
around polynomials.
Lines starting with <code>#</code> are treated as comments.
Comments <code>(* *)</code> and parenthesis within polynomials are
still not supported.
</p>
<p>Implemented a common driver for GB computations <code>RunGB</code>.
Sequential, thread parallel and distributed computation can be selected
by command line parameters. The input is taken from a file. The number
of threads respectively the number of distributed clients can be specified.
For distributed execution the host and port information is taken from
a maschines file.
</p>
<pre>
Usage: RunGB [seq|par|dist|cli] <file> #procs [machinefile]
</pre>
<p>Added methods <code>putCount()</code> and <code>remCount()</code>
in <code>OrderedPairlist</code> to count the number of polynomials
put and get from the pair data structure.
</p>
<div align="center" >
<table border="1" cellpadding="10"
summary="pairlist put and remove" >
<caption>pairlist put and remove, trinks6</caption>
<tr>
<th># Threads</th>
<td>1 seq</td>
<td>1 par</td>
<td>2 par</td>
<td>2 par</td>
<td>3 par</td>
<td>4 par</td>
<td>5 par</td>
<td>1 dist</td>
<td>2 dist</td>
<td>3 dist</td>
<td>4 dist</td>
<td>4 dist</td>
<td>4 dist</td>
<td>5 dist</td>
</tr>
<tr>
<th># put</th>
<td>22</td>
<td>22</td>
<td>43</td>
<td>26</td>
<td>28</td>
<td>28</td>
<td>28</td>
<td>22</td>
<td>25</td>
<td>28</td>
<td>37</td>
<td>40</td>
<td>33</td>
<td>27</td>
</tr>
<tr>
<th># remove</th>
<td>25</td>
<td>25</td>
<td>61</td>
<td>30</td>
<td>32</td>
<td>32</td>
<td>41</td>
<td>26</td>
<td>33</td>
<td>42</td>
<td>47</td>
<td>61</td>
<td>54</td>
<td>69</td>
</tr>
</table>
</div>
<p>Timings @ 500 MHz on one CPU and one maschine and log4j level INFO are: <br />
ca. 2.5 - 3.5 seconds for sequential GB,<br />
ca. 2.5 - 6 seconds for parallel GB,<br />
ca. 5.5 - 9 seconds plus 5 seconds sync time for distributed GB. <br />
Network shuffling of polynomials seems to account for 3 seconds in
this example.
</p>
<p>Problem uncovered: the distributed version of GB needs an
avarage of 5 seconds to sync with all clients (on one maschine).
This is way to much for execution times in the range of 2 to 8 seconds.
</p>
<p>Redesign of DistributedList, now using TreeMap to keep the list
entries in proper sequence. As key a natural number is used, which is
assigned by the server to successive add() requests.
The server now also holds a copy of the list by itself. So the
retransmission of list elements to late arriving clients is possible.
This doubles the space required to store polynomials, but removes
initial delays to sync all clients to receive all list elements.
<br />
By retransmission the DistributedList synchronization delay during
DistributedGB could be removed.
However the problem of about 5 seconds delay in startup
of DistributedGB still remains. It is not visible where and why this
delay occurs.
<br />
Further improvements would be the removal of list elements or the
clearing of the list.
Next steps could be distributed HashMap or TreeMap.
<br />
An important improvement would be to keep serialized copies of the
list elements (polynomials) at the server and to
avoid many time serialization during broadcast.
</p>
</dd>
<dt>2004, 2, 26</dt>
<dd>
Ideas to implement:
a distributed task launcher like <code>mpirun</code>,
a daemon to run on a distributed system to work with the launcher,
solvable polynomials and non-commutative GBs.
</dd>
<dt>2004, 2, 1</dt>
<dd>
Parallel computations with the Rose example are at ?? h with 3 threads
on 2 Pentium 4 @ 3.0 GHz hyperthreading CPUs.
<p>With one thread the time is 30.6 h.
Besides the better CPU speed, this makes a 5 % improvement on JDK 1.4
compared to the older timings from a JDK 1.3
and the new polynomial implementation.
</p>
</dd>
<dt>2004, 1, 25</dt>
<dd>
<a href="https://en.wikipedia.org/wiki/SPIN_model_checker">SPIN model checker:</>
Setup a Promela description of parallel and distributed GB algorithm. Used to
verify the safety and liveness properties of the algorithms.
</dd>
<dt>2004, 1, 17</dt>
<dd>
New (minimal) class DistributedList in preparation of a
distributed GB algorithm.
Made all mutually transported objects Serializable.
Fixed ChannelFactory and other classes in edu.unima.ky.parallel
to be interuptable.
Moved Semaphore back to edu.unima.ky.parallel.
First version of a distributed memory GB.
One problem was inner class Pair results in serialization
of outer class OrderedPairlist, which is not intented.
So Pair is now a proper class.
Distributed version mainly working.
Problem with signaling and termination if 1 in GB.
</dd>
<dt>2004, 1, 10</dt>
<dd>
Refactored Groebner base for new OrderedPolynomials and
split sequential and parallel GB implementations.
New unit tests for sequential and parallel GBs.
GB now works for arbitrary Coefficients.
</dd>
<dt>2004, 1, 5</dt>
<dd>
New coefficient domains BigComplex and BigQuaternion.
New test unit for all coefficients.
Based on these coefficients are new polynomials, e.g.
ComplexOrderedMapPolynomial and QuatOrderedMapPolynomial
together with unit tests.
Problem: RatPolynomial requires DEFAULT_EVORD be set correctly in ExpVector.
This is now solved for the new OrderedMapPolynomials.
</dd>
<dt>2003, 12, 29</dt>
<dd>
New organization of polynomials:
<br />
2 interfaces: UnorderedPolynomial and OrderedPolynomial.
Ordered polynomials have a term order and are implemented using
some SortedMap (e.g. TreeMap).
Unodered polynomials are implemented using some HashMap (e.g. LinkedHashMap).
<br />
2 abstract classes: UnorderedMapPolynomial and OrderedMapPolynomial.
Both implement all algorithms which do not need an explicit coeficient domain,
i.e. they are formulated in terms of the Coefficient interface from jas.arith.
<br />
2 or more classes which extend the respective abstract classes:
RatUnorderedMapPolynomial and RatOrderedMapPolynomial both need explicitly
coefficients from BigRational or others.
<p>
Multiplication with ordered polynomials is about 8-10 times faster than
the multiplication with unordered polynomials. Also the multiplication with
semi-ordered polynomials (LinkedHashMap) with orderpreserving addition is
about 7-8 times slower than multiplication with ordered polynomials.
</p>
<p>
All implementations are based on Map interface and classes.
The Map maps exponent vectors (from some monoid) to coefficients (from some domain).
This is in sync with the mathematical definition of multivariate polynomials
as mappings from some monoid to some domain.
Term orders are represented by a TermOrder class which provides the
desired Comparator classes for the SortedMap implementation.
</p>
</dd>
<dt>2003, 12, 28</dt>
<dd>Things to do:
refactor and test HashPolynomial, check performance.
Improve the parallel GB algorithm, e.g. parallelize the reduction algorithm.
Develop a distributed memory version of the parallel GB algorithm.
</dd>
<dt>2003, 12, 27</dt>
<dd>Using ArgoUML to produce class diagramms for jas.
Refactoring GB from edu.jas.poly to edu.jas.ring.
</dd>
<dt>2003, 12, 21</dt>
<dd>Setup for JUnit version 3.8.1.
Added JUnit testing with Apache Ant version 1.6.0 to build.xml.
</dd>
<dt>2003, September</dt>
<dd>
Experimented with LinkedHashMap instead of TreeMap (SortedMap)
for the representation of polynomials.
Algorithms which work also with LinkedHashMap have 1 or 2 in their names
(now in new class HashPolynomial).
LinkedHashMap has the property of using the insertion order for
the iterator order.
With LinkedHashMap the add() and subtract() can be reformulated to
use a merging algorithm as in the original DIP implementation.
Assuming the Map insertion order is the the same as the polynomial
term order.
<p>
However the merging add/subtact implementation is a factor of
2 slower than the TreeMap implementation.
Complexity for a+b is <br />
2*(length(a)+length(b))
for access and merging pre sorted polynomials and
<br />
2*length(a)+length(b)+length(b)*log2(length(a+b))
for TreeMap clone, access and insertion.
</p>
<p>
The merging multiplication implementation is by a factor of
10 slower than the TreeMap implementation.
Polynomial size was ~100 terms and the product contained ~8000 terms.
Complexity for a*b is
<br />
lab = length(a)*length(b) coefficient multiplications for both implementations
<br />
plus 2*length(a*b)*length(b) for merging summands, respectively
<br />
plus length(a)*length(b)*log2(length(a*b)) for TreeMap insertion.
Since for sparse polynomials length(a*b) = lab, the TreeMap complexity
is asymptotically better in this case:<br />
2*length(a)*length(b)*length(b) =>= length(a)*length(b)*log2(length(a*b))
<br />
For dense polynomials with length(a*b) ~ length(a)[+length(b)], then
the LinkedHashMap complexity is asymptotically better:
<br />
2*length(a)*length(b) =<= length(a)*length(b)*log2(length(a*b))
</p>
</dd>
<dt>2003, 3, 15</dt>
<dd>
Some testing with new
AMD Athlon XP 2200+ @ 1.8 GHz, 133x2 MHz memory access.<br />
Trinks 6: 1.013 sec with log4j level WARN, parallel 1.058 - 1.740 sec.<br />
Trinks 7: 0.553 sec with log4j level WARN.<br />
</dd>
<dt>2003, 2, 2 </dt>
<dd>
Replacing all System.out.println by Log4j logging calls.
adding some Junit tests.
</dd>
<dt>2003, 1, 28 </dt>
<dd>
Some testing with gcj (Gnu Java Compiler). this compiler gernerates
native executable binaries. the timings are not better than with
a jit, often worser.
<p>Parallel computations with the Rose example are at 18 h with 4 threads
on 2 Pentium 4 @ 2.4 GHz hyperthreading CPUs. With one thread the time
is 40 h.
</p>
</dd>
<dt>2003, 1, 26 </dt>
<dd>
timings with JDK 1.3 (from IBM) are 30% to 40% faster
than with JDK 1.4.1 (from Sun).
timings on PowerPC 604 @ 200MHz JDK 1.3 (from IBM)
JDK 1.2 (from Sun) are a factor 3.5-4.5 slower than on Intel PIII @ 450 MHz.
on PowerPC not using jit is faster than using a jit, ca. 20% - 30%.
</dd>
<dt>2003, 1, 12 </dt>
<dd>
General differences between sequential and parallel GB algorithms
<ul>
<li>The parallelization is achieved by doing the normal form reductions
in parallel.
</li>
<li>Since the reductions may require different times to complete
the normal forms may be entered into the list of polynomials
in different (time) order than in the sequential case.
So the pairs may be generated in different order.
However since the list of pairs is ordered wrt. the lcm of
the head terms this seems not to be a big issue.
</li>
<li>Since several reductions are scheduled in parallel
the pairs are taken from the list of pairs in different order
than in the sequential case.
One should not take more pairs from the list than can be reduced
in parallel.
</li>
</ul>
<p class="note">Does this influence the validity of criterion 3?
Access to pairlist is synchronized.
Pairs are marked as reduced as soon they are taken from the list.
But the algorithm terminates only after all reductions of pairs have
terminated. So criterion 3 holds.
</p>
<p>New implementation of parallel version of GB.
Removal of pairs is now also in parallel.
But ordering of pair insertion is no more preserved
</p>
<p>Timings are more stable
and slightly better than that of sequential GB.
</p>
<p>Todo: unit tests, comments, ...
</p>
</dd>
<dt>2003, 1, 7-11 </dt>
<dd>
Renamed jas to mas2jas,
new cvs repository for jas, import and checkout.
<p>Improved parallel version of GB.
</p>
<ul>
<li>The sequence of polynomials added to the pair list is kept
stable. i.e. a pair scheduled for reduction at time t
will (if non zero) enter the list before any pair
scheduled at time t+x.
</li>
<li>This limits the parallelism since polynomials which reduce to zero
keep a reducer thread occupied until older polynomials are
finally reduced. One could eventualy hand over the blocking
object to the next thread.
</li>
<li>The number of pairs scheduled for reduction is now also limited
to the number of parallel reduction threads. this avoids
that to many pairs with high lcm will be scheduled before
eventually new created pairs with lower lcm.
</li>
<li>The limiting of scheduled pairs could also be implemented using
a BoundedBuffer/Queue for the ThreadPool workpile.
then addJob() would block until free Threads are avalilable.
</li>
<li>The sequencing and limiting could eventually also
achieved when the reducing threads take the pairs by
themselves instead of the master thread.
The main thread should then simply wait until all
threads are idle.
</li>
<li>The final reduction of the GB to a minimal GB is now
also parallelized.
</li>
</ul>
<p>
Todo: CVS, comments,
polynomial implementation using LinkedList,
parallel GB simplify
</p>
<p>With the improved algorithm the running time of the parallel GB
becomes more stable and not slower than the sequential GB.
However there is still no significant speedup.
</p>
<div align="center" >
<table border="1" cellpadding="10"
summary="number of reductions" >
<caption>parallel GB on one cpu</caption>
<tr>
<th># Threads</th>
<td>1</td>
<td>2</td>
<td>3</td>
<td>4</td>
<td>5</td>
<td>6</td>
<td>7</td>
<td>8</td>
<td>16</td>
</tr>
<tr>
<th># Reductions</th>
<td>25</td>
<td>25</td>
<td>27</td>
<td>25</td>
<td>25</td>
<td>25</td>
<td>25</td>
<td>25</td>
<td>25</td>
</tr>
</table>
</div>
<p></p>
<div align="center" >
<table border="1" cellpadding="10"
summary="number of reductions" >
<caption>parallel GB on 4 cpus</caption>
<tr>
<th># Threads</th>
<td>1</td>
<td>2</td>
<td>3</td>
<td>4</td>
<td>5</td>
<td>6</td>
<td>7</td>
<td>8</td>
<td>16</td>
</tr>
<tr>
<th># Reductions</th>
<td>22</td>
<td>24</td>
<td>30, 28, 24, 29</td>
<td>28</td>
<td>29</td>
<td>42</td>
<td>32</td>
<td>32</td>
<td>37</td>
</tr>
</table>
</div>
<p></p>
</dd>
<dt>2003, 1, 6 </dt>
<dd>implemented parallel version of GB using ThreadPool from tnj
<p>
parallel results: <br />
Trinks 7: mas 0.598 sec, jas 0.918 sec, jas par 0.955 sec <br />
Trinks 6: mas 26.935 sec, jas 3.211 sec, jas par 3.656 sec <br />
mas: including startup and gc time,
jas: excluding startup of jvm and including gc time,
jas par on single processor
timing on P-3@450
</p>
this make for a penality of 12 percent,
all tests with output to files,
</dd>
<dt>2003, 1, 5 </dt>
<dd>timing benchmarks between BigRational and Coefficient versions
of the algorithms,
the difference seems to be less than 1 percent with
no clear advantage of one side
<br />
the sum and product algorithms have not jet optimal complexity,
sum has 2 l log(l) instead of 2 l
because of TreeMap.remove() and because of TreeMap.put(),
prod has l^2 log(l^2/2) instead of l^2 because of TreeMap.put()
<br />
TreeMap cannot used for this,
some kind of SortedLinkedList or SortedHashMap would be required,
the last would in turn require a hashValue() of an ExpVector
<p>
implemented edu.jas.arith.BigInteger which implements Coefficient,
tested with IntPolynomial which extends Polynomial
</p>
todo: alternative Implementations, cleanup RatPolynomial, parallel GB,
conversion RatPolynomial <--> IntPolynomial
</dd>
<dt>2003, 1, 4 </dt>
<dd>added reading of PolynomialLists and Variable Lists to
PolynomialTokenizer,
implemented PolynomialList
<br />
refactoring RatPolynomial to extend Polynomial,
implementing IntPolynomial extends Polynomial
<br />
to make BigInteger implement Coefficient will require
a delegation extension of BigInteger
</dd>
<!-- -->
<dt>2003, 1, 3 </dt>
<dd>implemented PolynomialTokenizer to read RatPolynomials
</dd>
<dt>2003, 1, 2</dt>
<dd>file RatPolynomial split into RatGBase,
criterion 3 implemented with BitSet
<p>
second results (with new criterion 3 in jas): <br />
Trinks 7: mas 0.598 sec, jas 1.159 sec <br />
Trinks 6: mas 26.935 sec, jas 6.468 sec <br />
mas: including startup and gc time,
jas: excluding startup of jvm and including gc time
</p>
implemented DIGBMI, H-polynomal was not monic in DIRPGB
<p>
third results (with new criterion 3 in jas and GBminimal): <br />
Trinks 7: mas 0.598 sec, jas 0.918 sec <br />
Trinks 6: mas 26.935 sec, jas 3.211 sec <br />
mas: including startup and gc time,
jas: excluding startup of jvm and including gc time
timing on P-3@450
</p>
<p>
this makes for a factor of 8-9 better,
all tests with output to files,
startup of JVM is approx. 1.0-1.2 sec,
most time is spent in BigInteger:
</p>
<pre>
java -Xrunhprof:cpu=times,format=a
CPU TIME (ms) BEGIN (total = 136) Thu Jan 2 18:33:53 2003
rank self accum count trace method
1 15,44% 15,44% 596610 21 java.math.MutableBigInteger.rightShift
2 13,24% 28,68% 582132 15 java.math.MutableBigInteger.difference
3 12,50% 41,18% 612760 19 java.math.MutableBigInteger.getLowestSetBit
4 9,56% 50,74% 2 9 java.lang.Object.wait
5 9,56% 60,29% 5271 22 java.math.MutableBigInteger.binaryGCD
6 6,62% 66,91% 612760 23 java.math.BigInteger.trailingZeroCnt
7 5,88% 72,79% 592152 18 java.math.BigInteger.bitLen
8 5,88% 78,68% 6018 20 java.math.MutableBigInteger.binaryGCD
9 5,15% 83,82% 578887 25 java.math.MutableBigInteger.normalize
10 4,41% 88,24% 550992 24 java.math.MutableBigInteger.primitiveRightShift
11 4,41% 92,65% 1 10 java.lang.Object.wait
12 3,68% 96,32% 582132 12 java.math.MutableBigInteger.compare
13 0,74% 97,06% 35965 13 edu.jas.poly.ExpVector.EVILCP
14 0,74% 97,79% 11612 14 java.math.BigInteger.divide
15 0,74% 98,53% 5866 11 java.math.MutableBigInteger.divide
16 0,74% 99,26% 9032 16 java.math.MutableBigInteger.divide
17 0,74% 100,00% 9032 17 java.math.BigInteger.divide
CPU TIME (ms) END
</pre>
</dd>
<dt>2003, 1, 1</dt>
<dd>renaming packages to edu.jas,
renaming to arith, poly and ring,
new Makefile, project dokumentation in XHTML,
using JDK 1.4 with JIT
<p>
first results (without criterion 3 in jas): <br />
Trinks 7: mas 0.598 sec, jas 1.373 sec <br />
Trinks 6: mas 26.935 sec, jas 30.935 sec <br />
mas: including startup and gc time,
jas: excluding startup of jvm and including gc time.
timing on P-3@450
</p>
</dd>
<dt>2002, 12, 31</dt>
<dd>starting with extraction of relevant files in new directory <br />
</dd>
<dt>2000, 7, 21</dt>
<dd>keySet/get replaced by entrySet/getval. <br />
Implemented S-Polynomial, normal form, irreducible set.
Implemented Groebner base with criterion 4. Criterion 3 left to to.
</dd>
<dt>2000, 7, 16</dt>
<dd>Implemented and tested BigRational based on Javas BigInteger.<br />
With and without I/O BigRational addition, multiplication and
comparison is approx. 10 times faster than respective
SACRN functions.<br />
<p>Implemented and testet ExpVector based on Javas int arrays.
</p>
<p>Implemented and testet RatPolynomial based on Javas TreeMap. <br />
static methods: DIRPDF, DIRPWR via toString, DIRPON, DIRPMC,
DIRPPR, DIRPSM, DIRRAS.<br />
Consider replacing keySet/get by entrySet/getval where appropriate.
Can there be an generic Polynomial class?
</p>
</dd>
<dt>2000, 7, 15</dt>
<dd>Some testing with Javas builtin BigInteger class.<br />
Without I/O builtin multiplication is approx. 15 times faster
than SAC product.<br />
With much I/O builtin multiplication is approx. 3 times faster
than SAC product.<br />
Builtin uses also twos-complement representation, which is
bad for decimal printing.
<p>This will be the end of list processing for Jas.</p>
<p>
DIPRNGB needs DIRPDF, DIRPWR, DIRPON, DIRPMC, DIRPPR, DIRPSM.<br />
These need RNDIF, RNDWR, RNINT, RNSIGN, ISRNONE, RNONE, RNZERO,
RNINV (and DIRPRP), RNPROD, RNSUM.
</p>
</dd>
<dt>2000, 7, 14</dt>
<dd>Class BigInteger based on SACI with toString().<br />
Class List based on MASSTOR with toString(). <br />
Problem with Modula-2 module initialization with main(args)
method: initialization of static variables.
</dd>
<dt>2000, 7, 5</dt>
<dd>Finished testing most of masarith.
</dd>
<dt>2000, 7, 2</dt>
<dd>Finished porting masarith.
Testing needs still to be done. MASAPF is ok.
</dd>
<dt>2000, 6, 24</dt>
<dd>Perl script getc.pl to grab comments in Modula-2 source
and add to Java source.
Comments grabbed on most working files so far.
Generated new documentation.
</dd>
<dt>2000, 6, 22</dt>
<dd>Future directions:
<ul>
<li>Parallel GB.
</li>
<li>Move to Java without Modula-2.
</li>
<li>Develop an applet version.
</li>
<li>Implement more of Mas.
</li>
<li>Replace SACI by Java BigInteger.
</li>
<li>Setup for real objects: <br />
implement constructor, <br />
implement methods: a.method(b) as STATIC_METHOD(a,b), <br />
use real objects instead of only Cell objects <br />
define interfaces e.g. for ring, polynomial ring,
module, group, field
</li>
<li>Small additions: <br />
toString equivalents of xWRITEs
</li>
</ul>
Problems identified:
<ul>
<li>LISTs over Beta-Integers are diffrent to LISTs over LISTs,
when implementing LISTs as Java Types
LISTs over other types will require also special handling.
</li>
</ul>
</dd>
<dt>2000, 6, 22</dt>
<dd>GB running on Trinks (small and big).
Jas ist about 5-8 times slower than MAS in GB computation.
Using JDK 1.1.7 without JIT on Linux, PII-300.
Using JDK 1.2.2-RC3 without JIT on Linux, PII-300 is
about 6-9 times slower.
Using JDK 1.2.2-RC4 with JIT (sunwjit) on Linux, PII-300 is
about 2-4 times slower.
Implemented Java input via BufferedReader.
</dd>
<dt>2000, 6, 21</dt>
<dd>Got GB running. Problem was in EQUAL.
</dd>
<dt>2000, 6, 17</dt>
<dd>Placed under control of CVS.
Begining with a clean version from Uni Passau.
Incorporated Java specific changes up to now.
</dd>
<dt>2000, 6, 10</dt>
<dd>Transformation of DIPRNGB finished.
Important parts of maspoly finished.
</dd>
<dt>2000, 6, 4</dt>
<dd>Transformation of SACPRIM finished.
Most of maskern finished.
Important parts of masarith finished.
</dd>
<dt>2000, 5, 29</dt>
<dd>MASSTOR: Mapping MAS list direkt to a Java list class and using
of the garbage collector from Java.
Data types LIST and GAMMAINT are now distinct.
Buying the MHC Compiler (UK Pound 59).
</dd>
<dt>2000, 5, 28</dt>
<dd>MASSTOR: First attempt to use list class with own garbage collection.
Using the constructor to record list pointers.
</dd>
<dt>2000, 5, 27: </dt>
<dd>Beginning of the first tests.
Conversion of .md to .def, .mi to .mod.
</dd>
<dt>2000, 5, 26: </dt>
<dd>Discovery of the MHC Modula-2 to Java compiler.
Mill Hill & Canterbury Corporation, Ltd, URL
<a href="http://www.mhccorp.com">http://www.mhccorp.com</a>
</dd>
</dl>
<!--
<h2>To Do</h2>
<ul>
<li>Applet front-end.
</li>
<li><del>Reimplementing MASBIOS for streams.</del>
</li>
<li>Copying the comments to java.
</li>
</ul>
-->
<h2>Done bevore 2003</h2>
<ul>
<li>JUnit checker for every class.
</li>
<li>Switching to Java and abandoning Modula-2.
</li>
<li>Removal of the mas prefix in directory names.
</li>
<li>Improved Makefiles.
</li>
</ul>
<hr />
<address><a href="mailto:kredel@at@rz.uni-mannheim.de">Heinz Kredel</a></address>
<p>
<!-- Created: Sun Jun 4 12:58:30 MEST 2000 -->
<!-- hhmts start -->
Last modified: Tue Jul 4 09:58:27 CEST 2023
<!-- hhmts end -->
</p>
<!--p align="right" >
$Id$
</p-->
</body>
</html>
|
