(07-13-2017 08:44 PM)Thomas Okken Wrote:  I thought the TI-59 card reader had the same gummy wheel problem as the HP-65/67/97/82104. Does yours still have the original wheel?

Congratulations, BTW. Annoying TI keyboard aside, the 59 was seriously cool in its day! :-)

(07-14-2017 07:13 AM)Werner Wrote:  ... source code of the Pgm-02 (Linear Equations) in the Master Library, and to rewrite it... Will post if someone's interested.

(07-14-2017 07:13 AM)Werner Wrote:  Will post if someone's interested.

Cheers, Werner

(07-14-2017 07:13 AM)Werner Wrote:  I had a TI-58 (no 'c') in the olden days.
I recently purchased RCL-59 on my phone, a fantastic emulator that finally allowed me to view the source code of the Pgm-02 (Linear Equations) in the Master Library, and to rewrite it, just for fun. 640 lines instead of 898, up to 9x9 for both equation solving and inverse (the Master Lib can't handle 9x9 solve), and four times faster for equation solving. Well, on the emulator. Will post if someone's interested.

Cheers, Werner

(07-14-2017 05:34 PM)rprosperi Wrote:  I agree, please post your improved version when convenient. As for the original program, I'm not sure I want to enter 898 lines of a slower and less elegant program... if a better one is available.

(07-14-2017 05:14 PM)toml_12953 Wrote:  If you could post the original as well (for those who can't get the source on their own), it would make a great comparison.

(07-15-2017 04:34 PM)Dieter Wrote:  

(07-14-2017 05:14 PM)toml_12953 Wrote:  If you could post the original as well (for those who can't get the source on their own), it would make a great comparison.

A listing of the original ML-02 program is not required. Listings for all ML programs are included in the Master Library Survival Guide which is available online.

Dieter

1. dot products
   dot products are inherently faster than axpy operations, because they use less STO instructions, and the way the axpy operation was implemented was very inefficient.
   Pgm 02 contained two dot product subroutines (one forward, one backward), but they are not used in the LU-factorisation.
   My version uses a single dot routine, used everywhere.
2. unrolled loops
   .max order = 9, so max dot length = 8
   .speed improvement is about 11%, while it requires 100 extra steps. That does not seem worthwhile.
3. permutation register
   .max order = 9, so permutations can be kept in 1 reg
   .i.o. 1..n, keep delta
   .this allows solving a 9x9 system, and a faster inversion algorithm
4. UXL inversion
   Pgm 02 calculates the inverse from the LU-factorisation as inv(U)*inv(L).
   So it essentially performs three steps:
   - invert U
   - invert L
   - multiply U*L
   The fourth step (re-arranging the columns according to the permutations) is done reading out the columns of the inverted matrix, and is not included in the timing estimates of Pgm 02
   
   UXL inversion calc's X=inv(A) straight away, a row and col at a time, making max use of the dot product's speed and efficiency. It uses a work vector of length n, effectively overwriting the vector b if present
5. HIR
   HIR's 7 and 8 are used. Moreover, the determinant is no longer in REG 06, but in HIR 08, as REG 06 now contains the permutations. As before, though, R07 contains n and R08 the first element of the matrix.
6. interface
   In keeping with the 'minimal' interface, I decided to simplify it even further.
   
   A: input order n
   B: input column. column 0 or n+1 is considered the vector b. This allows
   entering A and b together, then executing D' to solve.
   B' output column (idem for col 0 or n+1)
   C: determinant
   D: solve, returns 0
   D': det+solve, returns 0
   E: invert, returns 1
   E': det + inverse, returns det
   
   D' and E' will return a flashing 0 when the determinant is zero.
   D, D' and E allow reading out the solution x or the inverse matrix by R/S
7. results
   
   - 640 steps instead of 898, through code re-use
   - linear equations up to and including 9x9 systems
   - Determinant and LU-decomposition more than 3x faster
   - Inversion 2x faster
   
   Speed improvements due to inner loop optimisation.
   This does not even take into account that the original code did not put the columns in order after linear equation solve or inversion; rather, the output code showed the entries in the correct order. My version applies the permutations as well, before readout.
   The speeds are measured with RCL59 on my iPhone and may bear no relation to the true speeds. (ie. it is not certain that on a real 58/59 the speed improvements would be the same)
   

(07-17-2017 11:19 AM)Werner Wrote:  See the attached Excel for the code and some colourful aids if you want to understand the code in detail.

(07-17-2017 02:42 PM)Werner Wrote:  Not quite. See point 6. of my post
Werner

(07-19-2017 11:24 AM)Dave Britten Wrote:  The TI-66 is a good option if you want to experiment with programming old TIs, and don't care about using ROM modules. It's essentially a 58C, but much more robust (especially the keyboard), and with alpha display of program steps while editing.

(07-17-2017 05:35 PM)rprosperi Wrote:  I will shortly have a 58C working and look forward to trying it out.

(07-19-2017 03:59 PM)Gene Wrote:  Gene: Won't be able to do that. 640 steps won't fit into a 58C... even IF you jiggle the real TI-58C to add an extra 32 program steps per here: