From: meissner@triton.unm.edu (John Meissner)
Newsgroups: comp.sys.hp48
Subject: Laplace Transform utilities (update)
Date: 29 Dec 92 05:12:09 GMT
Organization: University of New Mexico, Albuquerque


	Hello everyone,
Now that I have finished my finals, and the holidays are over
I am ready to revamp my Laplace Transform utilities.

	I have started several new aplications for the routines.
	
	1) It will be a library
	2) It will do plots, including:
		Root Locus
		Nyquist
		Nichols
		Bode
	3) It will return and handle COS(t+45) type arguments
		(useful for interpreting phase.)
	4) It will handle transfer function manipulations 
		such as addition, subtraction, multiplication,
		division, convolution, reduction ...
		

	In addition I plan to add some circuit analysis, and some linear
systems manipulation capabilities.  In order to do this, a few syntax 
problems must be overcome.  First, the routines have to be able to 
distinguish between roots and polinomials.  The easiest way to accomplish
this is to make one an array and the other a list. Second, The routines
need to be able to handle a transfer function as a single object on the
stack.  Making the polinomials an array and the roots a list and then 
combining the two into a list accomplishes this with another added 
benafit -- the transfer function is readable.  This readability is due
to the fact that the calculator adds a <CRLF> to the end of an array
when it is displayed.

What I am trying to say is that if you enter the following on the command
line:

{[1 2 3]{4 5 6}}

and hit ENTER, you will see:

1:{
  [1 2 3]
  {4 5 6}}

if you have the ML-flag on. 

	Which in my opinion is much more readable than:

1: { {1 2 3 } { 4 5 6
  } }

Which is what you get if you lists instead of arrays.

	Now that I have explained what I am planning, I need some feedback.
I want to know what you people think.  Is the added benifit of handling 
transfer functions as a single object worth the effort?  Is the display
format better whith arrays representing polynomials or lists.  I should
point out a few other problems with this idea.
	The first problem is that handling arrays is much more time 
consuming than handling lists, due to inadequate system-RPL entry 
points.  The routines will probably run about twice as slow.  The
slowdown would not be near as bad if the roots were represented by 
arrays instead of the polynomials.  This, however, does not look as nice
when displayed.  Additionally, since all elements of an array must be the
same type, If there is one complex root in the array - the entire array 
must be complex.  In my opinion this looks terrible.

	O.K.  Hopefully you understand what the problems are.  I am 
willing to overcome these problems but I need some input.  I need to 
know What changes to make and I need to know which format to use.

	Since, this involves a major rewrite of almost every funtion,
now is the time to add any other ideas. 

PLEASE, PLEASE, PLEASE!!!  SEND ME YOUR SUGESTIONS, COMMENTS, CRITICISMS
OR APPRECIATION.

	I need to know that the hard work I've put into these routines
is useful to someone so I can more easily find the time to update them.

Looking forward to hearing from you!

John Meissner

meissner@triton.unm.edu
Newsgroups: comp.sys.hp48