@MAJP Each iteration through the loop , do you want to be defining y[i] in term of the previous value y[i-1] ?

Trying to assign y[i] in terms of a formula with y[i] is not right.

You'll  also need to consider whether the other indexed names in the formulas in the loop should use the current iteration's values indexed by i, or the previous iteration's values indexed by i-1.

I feel sure that, by thinking about this aspect, you'll understand what the iteration is supposed to accomplish.

@sand15 

Whenever I install Maple the next thing I do is edit the properties of the launcher, to add (along with a blank space as separator) the option
   -standalone
to the end of the invocation of the GUI executable.

This has the effect that I can launch separate worksheets under separate Java jvm processes. And if one of them stalls or freezes or crashes (in the GUI sense) then the other one(s) stay ok.

It'll even let me open the same worksheet twice.

Memory is cheap. Back around Maple 10 the few hundred MB footprint of the GUI+jvm seemed huge. Now it seems modest.
 

@erdisayar 

The code for the module J is in the Startup Code of this attachment.  (Use the menubar's Edit->Startup Code to see it, or modify it.)  The whole point is that the input is 1D and the pretty-printed names appear in the 2D output.

You can make the commands as long as you wish, or as short as a single character. You could add additional commands like J:-dash which puts a bar over a name, so that you don't have to remember HTML entity names. Or you could add  additional commands like J:-o which puts anything over anything. Or you could could add additional commands like, say. br for bottom-right or tl for top-left.

You can assign the marked up names to any other variable of your choice.

If you really wanted to you could add additional options to allow you to specify the color, boldness, or upright vs italic.

Of course it involves more typing, but you can create your own procedure names for custom mnemonics. If you also utilize use and uses (see examples) then it's not that much more typing than LaTeX.

Download Mark.mw

@C1Ron 

Download op_examp.mw

Every one of your queries submitted to this site has been a Post. And someone has had to convert each to a Question. I don't think that is very considerate of you.

Could you please use the Question form in future? It's right there at the top right of this site, right beside the Post form.

@erdisayar You mentioned LaTeX, for comparison, which entails a more verbose 1D plaintext form.

That makes it sound as if you are willing to use a 1D plaintext syntax for marking up your symbols/names with immutable subscripts and overscripts. If that's true then I can show you how. But, as input, it will require more typing/keystrokes.

I have always found 2D Input mode to be awkwardly impractical at best, and buggy at worst. I don't know how people manage to use it, even with keyboard shortcuts. It's curious to me that you're still trying to find a way to work with it easily.

I resisted changing everything to my own taste, since I believe that the OP is learning by doing.

Otherwise, a somewhat similar effect could be had with, say,

restart;

F:=proc(u,a,b,c,d)
  local expr, x;
  if u="   y = a sin(b x + c) + d " then
    expr := evalf[3](a*sin(b*x + c) + d);
    plot(expr, x=-2*Pi..2*Pi,
         ':-title'=expr,
         ':-view'=-3 .. 6);
  elif u="   y = sin(a x) + cos(b x) " then
    expr :=  evalf[3](sin(a*x) + cos(b*x));
    plot(expr, x=-2*Pi..2*Pi,
         ':-title'=expr,
         ':-view'=-2..2);
  else error u;
  end if;
end proc:

Explore( F(`function :`,a,b,c,d),
         parameters=[ [`function :`=["   y = a sin(b x + c) + d ",
                                     "   y = sin(a x) + cos(b x) "],
                       #controller="listbox",
                       placement=top]
                    ],
         a = 1.0 .. 3.0, b = 1.0 .. 3.0,
         c = 0.0 .. 2*Pi, d = 0.0 .. 3.0,
         placement = right
         #, newsheet, showbanner=false, startupdefinitions=[F]
       );

Could you upload your data here as an attachment (green up-arrow)?

@Ramakrishnan One of the problems with your original was that MyApp did not export ChangeE. So when you called ChangeE() in the code of the Sliders nothing happened.

If you are interested in using different formulas and radio buttons:  doubt2_MathContainer_ac2.mw

@Ramakrishnan You mean you're posting the same question twice? Please don't do that.

The first thing to clarify is the format of your data. It looks like the three columns denote four points of [x,y,z] data, rather than a 3x4=12 collection of [x,y] data points. Is that right?

What version of Maple are you using?

Is this a toy example, and you plan on wanting to do it for larger sets of points (possibly with surface smoothing)? Or do you just need to deal with this kind of simple 3D polygon with a quadrilateral base?

@dorna01 Tacking that comment onto a 9 year old message thread is not helpful. Post your example as a new Question.

Don't say that you could upload the worksheet or code later, if needed. Just include the relevant materials and details when you post.

@Carl Love I'm not aware of any mechanism by which Library code could robustly compute the display-width of rendered, 2D prettyprinted output (at 100% zoom, say).

And I have tried pretty hard to find one.

Rough approximations can be constructed, using offset values for fractions, max of numer and denom, offsets for fencing, Int/Sum/Product symbols, radicals, etc.

But really the only thing that might be true to form is the result from a new GUI streamcall. The Typesetting package is not enough.

It's  not clear to me that a rough kluge would be better than nothing. But, I agree that it would be an improvement to have the weighting be set automatically, if it could be done reliably.

There would be other, related uses for the display-width information.

@Carl Love Very nice, vote up.

You could get a printing effect with,

Tabulate(Table(
   [Bin(n,p), DiscrUni(a,b), Poiss(lambda), NegBin(p)],
   [Unity, Mean, Variance, Skewness, Kurtosis]
)):

Tabulate(Table(
   [Bin(n,p), DiscrUni(a,b), Poiss(lambda), NegBin(p)],
   [Unity, Mean, Variance, Skewness, Kurtosis]
), weights=[3,1,2,3,3,5]):

(I was a little disappointed that the `lambda` in the row headers isn't typeset when Tabulated, but it doesn't detract too much.)

@mmcdara There are concrete benefits which support this point of view.

The representation is sparse, and so can take less space or memory.

That can hold for line-printing. It can also hold for round trip programmatic recreation, using `rtable`, `rtable_indfns`, `rtable_elems`, and `rtable_options`.