UBASIC
From Seo Wiki  Search Engine Optimization and Programming Languages
This article is written like a personal reflection or essay and may require cleanup. Please help improve it by rewriting it in an encyclopedic style. (December 2007) 
UBASIC is a freeware BASIC interpreter written by Yuji Kida at Rikkyo University in Japan, specialized on mathematical computing.
Contents 
UBASIC features and discussion
UBASIC is a readytorun language that does not need to be set up with some other advanced language (an alltoocommon problem with multidigit math languages). It runs in DOS or in a DOS box under DOS shell, Windows, etc. It specializes in number theory, primality testing, factoring, and large integers (up to 2600 digits). Being an implementation of BASIC makes it very easy to read programs without having to do extensive study, as BASIC is the language that is closest to ordinary algebra. The help has articles and lessons for beginners.
UBASIC has a builtin online editor with several aids for debugging. It can show cross references to calling lines, lines containing a variable, and lists of variables/arrays. It can renumber lines, change variable names, and append additional programs. It can trace, single step, and time by milliseconds to help determine the fastest way to do highly repetitive sections. It can redefine function keys, either to provide an easy onekeypress function or to prevent a standard function from being accidentally used when it shouldn't. It can shell to DOS or execute a DOS command. It can convert between singlebyte character set and doublebyte character set, but to have much use for these you would probably need an aware operating system. Documents may be added to or modified in UBHELP.HLP.
Although interpreted it is quite fast.
Primality testing with APRTCLE (to 884 digits) (it is best to run this under UBASIC version 8.8F or later): 500 digits said to take 5 hours on a PP200, 150 digits takes about 16 minutes on a 486100, about 2¼ minutes on a K6@233; 250 digits takes about 13½ minutes on a K6@233. Recent machines can be up to 10 times faster. APRTCLE is often the algorithm of choice for testing primality of integers within its range.
Factoring with programs such as ECMX is also quite fast. It can find factors to low20's digits fairly easily, mid20's somewhat less easily, and upper20's with (s)lower chance of success. It has found a 30digit factor. (Finding factors with the elliptic curve method is always chancy for larger factors. The greater the number of curves that are tested the greater the chances of success, but the number needed (on average  you can sometimes get lucky or unlucky) increases rapidly with the size of the factors. Use the fastest machine you can find.) ECMX uses the accepted standards for limits of when to stop working with one curve and switch to the next. It has preliminary primality testing, finding small factors, and powers.
Being interpreted allows modifying a program and then restarting (using GOTO) in the middle of a multiday run without losing accumulated data (not recommended unless the program has already been saving the data safely somewhere or if you forgot to write any way to save data when quitting (perhaps you didn't expect to find any and were trying to prove it)). When doing anything that might lose invaluable data, or if you need to do something else for a while, then you can FREEZE the current program to a file and later MELT it (as long as the lower memory configuration is the same).
This BASIC has line numbers. It does not use indentation to control structure. It has subroutines and user functions with passed parameters and local variables. Parameters can be passed by value or by name. User functions and subroutines may be passed as parameters. It has limited labels. It has various options for conditional functions. You can indent as much as you like or not at all. You can have as much structure as you please or total spaghetti. It would be a mistake to consider this implementation as "not modern" (as might be inferred by a reader of articles that confuse indentation with structure and don't favor line numbers). Having line numbers allows easy jumping to an intermediate point in a routine, which can sometimes save duplication of lines.
Version 8 of UBASIC has the high precision real and complex arithmetic (up to 2600 digits) of previous versions, and adds exact rational arithmetic and arithmetic of singlevariable polynomials with complex, rational, or modulo p coefficients, as well as string handling and limited list handling capabilities. In addition UBASIC has contextsensitive online documentation (read UBHELP.DOC for information). The file that this uses is ASCII and can be printed for a paper document.
Note that the currently available versions of the help file have many errors. A tenyear project to rewrite/correct it is nearly ready for publication (probably by late summer 2005): look for help file with new extension '.hlp' , and eventually package name u3d748f*. There is an available list of updates but many changes remain unreported.
Version 8.8 has different precision than 8.74
There are still some commands that have no documentation: SCHOOL KEYSCAN MODMUL( There is a new command from version 8.8C POLYCONV( that converts polynomials between modulus=0 and modulus=prime. There are no formatting specifications. WARNING: Never test out any of these when while anything important is (or might be) running or suspended somewhere else, as lockups may be expected, particularly for KEYSCAN. See: FREEZE, ROLL, MELT. (for similar warning)
UBASIC has several types of arrays, logical operators, bit operators, 4 standard loop structures, and combined operators. It can call machine language routines for increased speed (ECMX does this), but you must know assembly language to even understand the instructions  just being able to write TSR's in DEBUG is not enough.
You can compute a string's value if it represents a math formula.
You can usually execute a string if it represents a UBASIC command.
Variables holding strings may usually be substituted for the strings.
Strings can be alphabetized using MIN or MAX.
UBASIC can be used to process just about any kind of data. For example: .WAV files. It can process text files to convert tabs to spaces or spaces to tabs (some programs can't generate tabs and some actually choke on them).
Variable types include: 1: integer 2: rational 3: real 4: complex number 5: string 6: packet (mixed from any types including other packets) 7: polynomial 8: mod polynomial (coefficients integers modulo a prime)
An early 2005 Internet search turned up versions 8.74(32), 8.74(16), 8.71(4000(16)), 9.0ZE, 9.0ZC, 9.0E, 8.8F(32), 8.8F(16), 8.8F(C), 8.7E(32), 8.7E(16), 8.30(32), 8.30(16), 7.25(32), 7.25(16), 8.8A(32), 8,8A(16), 8.8A(C), 8.8C(32), 8.8C(16), 8.8C(C), 8.8E(32), 8.8E(16), 8.8E(C). 12 versions out of 52 known numbers. Many of these are not directly identified. (The (16) and (32) refer to the number of bits in the multiplication engine. (4000) refers to special versions that can go up to over 4000 digits (some users may need one of these, such as to generate the first 792 Bernoulli numbers to double index 1584: the latest version can only get 540/1080). The (C) is for CGA machines. The versions in italics are not recommended.)
Most users would only need 8.8F.
If you are already using a version later than 8.74 and especially if you are using a version later than 8.7E then you are strongly advised to switch to the latest version (8.8F). Some programs (fancy display, for example) written for 8.74 may not work in 8.8F without considerable rewriting. The latest versions do not strip carriage returns/line feeds from ASCII files, and programs such as UBH (even the one in 8.8F) need added lines to strip them. Any program written for one version should not be used in another version without checking.
Certain programs such as NFS will only run on experimental version 9.**.
The ppmpx36e version of the multipolynomial quadratic sieve needs 8.8F and Windows.
Some versions of UBASIC came with a defective UBCONST7.DAT file. You should check yours against the one supplied in 8.8F. If it is not identical then you should switch.
UBASIC is available for 1: IBMPC/AT and compatibles 2: NEC PC9801 3: NEC PCH98 4: Fujitsu FMR 5: Toshiba J3100 6: AX 7: DOS/V
For obtaining the latest version of UBASIC, see external links sections. Many internet math pages have the language/packages on their own sites.
UBASIC was written by: Prof. Yuji Kida Department of Mathematics Rikkyo University NishiIkebukuro 3, Tokyo 171, JAPAN. (email: kida@rkmath.rikkyo.ac.jp)
Sample program
The following is a short simple program for the partition count function. Although it doesn't have many of the fancier structures, it is a real program, not invented for this article. On a modern fast Athlon it should calculate the partition counts from p(0) to p(1000) in about ½ second. Contrast that to over ½ century the first time through. To save the result to a file, uncomment line 40 (remove leading apostrophe).
10 console:console 1,24,0:locate 1,0 20 print chr(2);"n","p(n)","Partition Count" 30 word 19:point 8:H%=11:'for N up to ~1200 40 'print=print+"partn5.txt":'output redirect 50 N=0:'input N 60 clr time 70 Mu=pi(sqrt(24*N1)/6) 80 clr S 90 for K=1 to H% 100 '110 to 160 is Selberg formula 110 clr C 120 for L=0 to 2*K1 130 if ((3*L^2+L)\2)@K=(N)@K 140 :C+=(1)^L*cos(pi((6*L+1)/(6*K))) 150 next 160 'to get A(K,N), multiply C by sqrt(K/3) 170 U=exp(Mu/K) 180 R=(Mu+K)/U:'Rademacher's convergence term 190 S+=((MuK)*U+R)*C 200 next 210 S=round(abs(S*2/(Mu*(24*N1)))) 220 print cutspc(str(N)); 230 locate 38alen(S):print S 240 if N<1000:inc N:goto 70 250 Tt=time1000:print=print:print Tt/1000 260 '~1.7% faster if N,K,L changed to N%,K%,L%
Accuracy
The large accuracy of UBASIC allows patterns to be strikingly apparent. Carl Friedrich Gauss, using just pencil and paper, is said to have always worked to at least 20 fraction digit accuracy. This helps the patterns to stand out from the mud. Many discoveries in math and science come from recognizing a pattern.
When working with continued fractions, the number of terms is limited by the available accuracy and by the size of each term. An approximate formula is 2 decimal fraction digit accuracy for each (term times the base ten logarithm of the term). The only way to do such work safely is to do it twice, in parallel, with the initial input to one dithered in the final several digits (at least 1 word). Then when the two calculations do not give identical terms, stop at the previous term. UBASIC is very handy for continued fraction work.
UBASIC can calculate the partition function to over p(1330521). (In 8.74 up to p(1361911) and the 4000 digit versions should get many more.)
Features
 Strong emphasis on number theory
 Has readymade application programs such as primality test, factoring, Bernoulli numbers, zeta function, etc.
 Versions from 8.74 have graphics
 Can work with numbers up to 2600 digits (bignums), but with functions and complex numbers the digit limit is less
 Has online contextsensitive help
See also
 BASIC programming language
 List of BASIC dialects by platform
 Lenstra elliptic curve factorization
 complex numbers
 Prime number
 Jørgen Pedersen Gram
 Logarithmic integral function
 Prime number#Prime gaps
 Integrated development environment
References
Essential features consists of the following:
 The Near Repdigit Primes, A(n)B, AB(n), and UBASIC; Caldwell, Chris K.; Journal of RECREATIONAL MATHEMATICS, Vol. 22(2) 101109, 1990
 UBASIC: a PublicDomain BASIC for Mathematics; Neumann, Walter D.; Notices of the American Mathematical Society, May/June 1989, volume 36, number 5, p. 557559
 UBASIC Update; Neumann, Walter D.; Notices of the American Mathematical Society, March 1991, volume 38, number 3, p. 196197
 2 and 3 are somewhat old, and Mr. Neumann says "public domain" when he should say "freeware".
External links
 UBASIC 9.0w homepage (French)
 UBASIC86 catalogue (Vector) (Japanese)
 UBASIC Homepage (Japanese)
 English UBASIC homepage
 Nondefective version 8.74
