newRPL - build 1255 released! [updated to 1299]

[Claudio L.]

(01-20-2019 07:03 PM)The Shadow Wrote:  I've been thinking some more about equations involving matrices.

Many headaches arise when the matrices aren't square. There's whole classes of things you can't do to them that you can to square ones: inversion and raising to a power, among others. (Though a "pseudo-inverse" can be defined for all matrices, whether rectangular or non-singular, and might be worth implementing.)

But worse yet, there's *three* versions of the identity matrix you'd need for interacting with scalars: one for multiplying from the left, one for multiplying from the right, and one used for addition.

Does anyone actually use non-square matrices in equations? The only examples that are immediately coming to mind are ones in which they're multiplied by their transpose to make them square first.

Any new news, Claudio?

Regarding matrices, I decided to cut the details: we'll identify a variable as a matrix, that's all. This would allow the CAS to not mess the equation by applying commutative rules, etc. but that's all it would do. I don't think the system should apply automatically any rules, we can have special commands for that (like TRIGSIN and friends, commands that all they do is apply a specific rule to an expression).
In the future we can revisit this to add more attributes if we think it's justified.

As far as news: not much, still testing the new rewrite of the engine (works great so far), and adding the needed support for variable attributes that we discussed. The main challenge is to "compute" attributes for expressions, which is quite involved and I'm working on it right now.
For example, let's have an expression like X^(2+2). You want a rule that matches an expression known to be positive (>0). You can specify this in the rule by using attributes in the variable name '.xX₂₃' (here ₂₃ represents a real variable that cannot be infinite and is known to be >0). Now we need the rules engine to analyze the expression X^(2+2) to compute some attributes to see if we can match.
It starts by setting attributes for the constants, 2 is integer, even, >0, non-infinite. Added to the other 2 gives you another integer, even, >0, non-infinite. Then we get the attributes from X (if none given it's assumed finite and real, or finite and complex if complex mode enabled). Now we have a finite real raised to an integer, even power, therefore the engine needs to be smart enough to know this will result in a real, finite, >=0 result.
In this case it won't match, since we want an expression >0, and >=0 doesn't qualify, but my point was to show the kind of inference that this engine needs to be capable of in order for this to be useful.
I'm working case by case all different combinations of all operators to see what conclusions we can get from an expression (and it's taking me a while).