I know, this is a feature that has been requested over and over, and over, with many attempts by lots of users to produce a similar outcome. Most of these don't work very well, or are at best extremally tedious use in any practical sense and do not make it easier than just manually doing the substitution.

It seems like this request never really moves forward, and I'm not sure why, since it is always being asked for. I've seen similar requests from as far back as 11 years.

We really need an additional type of optimization.
The current optimization options do not provide for a means to achieve this outcome.

The only current way to make it work is to manually write the formula with the values and units in it, but this totally defeats the point of having a powerful program like SMath!
I can do manual calcs on paper without any programs...

All that is needed is for the display of the initial substitution, with the user defined units, before the final result is shown.
We don't need the formula evaluated with the user defined units, we only need the substitution displayed in the format of the expressed formula, that's it!
Like this:

It's totally fine if the default result is in default units, the user can manually define other units as needed.

I think it makes sense to have this as an additional type of optimization, perhaps called "Substitution"?

It would be the same as numeric, since you still need the formula evaluated, but it would only display the initial substitution before the final result.


I for one would be willing to help pay for the development of this, and I think that there are many other users who would too.
Not having this feature is honestly the biggest draw back to using SMath for engineering calculations.

So please, can I get some support on this? Any other users willing to pitch in for the development of this feature?

I am looking forward to the next release. If the proposed substitution display is going to work, this perhaps implies a lot of changes under the hood.

I wonder whether the optimization (I'd call it evaluation) can be set separately for storage at definition time (as given, simplified) and for display (none, substitution, numerical, symbolical, substitution+numeric).

Storage/assignment:
- As given: stores the expression verbatim without even touching the units (operator # := #)
- simplified: stores the expression with context substituted and simplified symbolically (operator # <- #)

Evaluation:
- none: as stored without substitution or simplification (operator # ≡ #)
- substitution: with substitution of context but without further simplification (operator # = #)
- numerical: with substitution and numeric evaluation (eventually with symbolic evaluation (operator # = #)
- symbolical: with substitution and symbolic simplification (operator # => #, consistent with operator palette)
- substitution + numerical: ternary display operator with first the expression, then substitution, then numeric result (operator # = # = #, optional with two-lines of display and aligned = signs)

What is missing in the above list is an assignment operation with numerical evaluation (mainly for programming to avoid exploding symbolic expressions in loops). One could invent another operator or use the eval() function for just this.

The original request would be handled by defining the inputs with storage "as given" and displaying results with "substitution + numerical"

There is an interesting point on how to handle intermediate results. You may want them to be stored using the custom unit you specified for display. Otherwise, substitution display would use some arbitrary base unit which you can't control and which might be plain wrong (e.g. Hz for angular velocity or J for a torque).

F:=3*'kN
h:=2*'m
M:=F*h (stores F*h)
M.1:=F*h=3*'kN*2*'m=6*'kN*'m (stores 6*'kN*'m)

This raises the problem of how to control the decimal precision of intermediate results. Die-hard pencil-and-paper way would be to store the intermediate results with the precision used for display, but hat is probably something no one wants, because round-off errors would accumulate.
On the other hand full precision decimal fractions would look very ugly in substitution display. But for consistency, this is perhaps the best option.

Edited by user 07 July 2023 19:45:20(UTC)  | Reason: Not specified

So you vote for some mechanism to prevent people from applying substitution display to variables not directly defined by user input?

Just to clarify what I mean when I say I don't want/need "intermediate results".



I don't need SMath to show me algebra and arithmetic steps.

Note: The default output unit for this example is m*Pa, I just changed it for a cleaner look.

Oh, now I understand the misunderstanding. With intermediate result I mean the handling of cascades of equations. E.g. you might want to compute stress by

W = b*h^2/6 being the section modulus, M=F*l being the bending moment.

You can put all this into a single equation or display M and W separately.

If you then write sigma=M/W and ask for display with substitutions, then we both want the same: display the value as it was formatted in earlier displays (as in your example with g.e, where you just set the favourite units.)

Still I think that it would be clean to separate storage (definition) and display (evaluation) options. But that is just for easier explanation/teaching.

Exactly, now we are on the same page. I also agree that we need to separate the definition and display of substitutions, as you have called it. I think the storage definition is going to be much harder than just the display.

Here is a visual of your example:



As for the display for the variables, you can see it right in the html code. Both the user defined units, and the number of decimal places are there.




Remember, we are talking only about the display of the variables substituted into the defined equation exactly as they are displayed before the equation. In the background, the evaluation is still numeric as before.

Significant figures or decimal places are just two ways to format the result. I guess they should not affect the background calculation, otherwise we would go back to the times of the slide rule and accumulate round-off errors.

I absolutely agree with what you displayed, thanks for illustrating my statements.

Are the reviewers fine with the possible difference between full precision background result and a result obtained from using truncated substitutions?

Based on the above discussion I'd modify the above description of the expected features:

Storage/assignment:
- Always store the definition in simplified form and in formatted form.
- The formatted form by default is the verbatim form of the definition.
- The formatted form is updated whenever a variable is displayed (either with default formatting or specific settings including units)
- Thus no need for separate control on storage as given or simplified.

Evaluation:
- none: show the formatted form (operator # ≡ #)
- substitution: substitute formatted form in the expression (operator # = #)
- numerical: use simplified form and apply numeric evaluation (operator # = #)
- symbolical: use simplified form and apply symbolic simplification (operator # => #, consistent with operator palette)
- substitution + numerical: ternary display operator with first the expression, then substitution, then numeric result (operator # = # = #, optional with two-lines of display and aligned = signs)

Access to the formatted form is perhaps the key infrastructure requirement.

This should be backwards compatible, i.e. would not modify existing sheets.

Any update on this?

One of the best features of this forum:


It's almost as good as Adblocker!