That was easy and clear. I get it :-)

f[a_,x_]

f[a, x] := Sin[a x]

I'm hoping there was some sort of copy error here. That definition is almost certainly not what you want. You probably want this:

f[a_, x_] := Sin[a x]

Ah, yeah, it's just part of markdown syntax. https://daringfireball.net/projects/markdown/syntax

If I want to see the value of a dynamic variable (aa) outside the Dynamic[], I have to use naother Dynamic[aa]

This also is not true. I'm honestly very confused about what you must be doing to be getting these results. Now, without Dynamic, you would have to evaluate an expression to see its results. But that's easy and it's what I do all...of...the...time. This is the beauty of notebook-style interfaces. This is why so many other languages are now adopting a notebook interface. It's like a super convenient REPL. If you want to know what aa is, just type aa into a cell and evaluate it.

But even more, if you want to have Dynamic[aa] somewhere, that's fine. It's great. No problem. But you don't need the other occurences of aa to also be inside a Dynamic. You can have just regular ol' expressions being evaluated using aa, and if aa ever changes, that place where you put the Dynamic[aa] will update automatically.

You can also sprinkle Print expressions inside of other expressions (so aa could get printed out during an evaluation). You can use Trace to see how an expression was evaluated. You can use Information (more useful for functions than simple variables).

I wish we could have some sort of private chat rather than abuse everyone else with this ever-expanding discussion, but oh well. I'd really like to help you, so keep asking questions. I have to admit I'm at a bit of a loss sometimes, because I just can't figure out what you're thinking and trying to do. So, for example you ask "how to see a variable?", but that's the easiest thing in the world to do (and there are myriad ways to do it). So, I must be misunderstanding your question. Can you just start from scratch, and give me the smallest possible example/notebook that demonstrates a situation where you "can't see a variable"?

In the meantime...

In a Manipulate the variables are local. So to see an variable from within the Manipulate, I have to pass it to the outside. Also to use it in a function outside the Manipulate.

The variables are local, yes. That is, the variables specified for that particular Manipulate (the stuff that you put at the end of the Manipulate expression) are local. Within the Manipulate, you can reference any variable that is defined at the global scope. At this point in your journey, just assume that you cannot access any of those Manipulate-specific variable outside of the Manipulate at all. Maybe you're thinking that Manipulate and Dynamic are somehow necessary to control the lifetime of a variable. They aren't. Just drop that whole line of thinking.

In fact, maybe just stop thinking about the concept of variable completely. This might be too abstract right now, but in Mathematica, when you evaluate something like a = 5, you are not allocating memory. You do not have an alias (the "a") to a memory address. You do not have a value (the "5") stored in a memory location. What you have is a new transformation rule in the "computation environment" (I'm sure there's a better technical term). You've basically just told Mathematica, "hey, whenever you're transforming an expression and you see a replace it with 5". In a very literal sense, there is no variable a to look at. There are just transformation rules associated with the symbol a.

PS. I just read how to acces a function outside the Manipulate function :

f[a_, x_] := Sin[a x]
Manipulate[Plot[f[a, x], {x, 0, 10}], {a, 1, 5}]

If I understand this correctly, I have to send the current value of 'a' (inside the Manipulate), together with the value of 'x' to the function 'outside'.

functions ouside a manipulate cannot be called from inside the Manipulate itself

This is not true. Not sure what you're seeing to make you think that.

I am most grateful for yopur extended help, Eric. I also start to feel a bit encumbered (I hope the translate app has provided me with the correct translation) taking so much of your time. Please know, that I won't be 'offended' or anything if you say "it has been enough". I do not always have the time to respond immediately, but your input really helps me a lot.

1. I had found about setting deafsults : {{degree, 3}, 1, 10, 1, Appearance -> "Labeled"}

2. That is great for making a Preset. So I can save settings I like, save the imgage that comes out of these settings, work on the image and if necessary go back to the Preset and tweak the settings.

   Hmm :-) I had tried with a ver simpel example, but now I made a Snapshot with your last corrections: I get a 'DynamicModule' with all the settings in it, as well as the associated image. What I don't get, unfortunately, are the controls to tweak my settings. So I wont be able to tweak my image later on revisiting.

3. I do not notice any difference in behavior between 'Dynamic Module' and 'With'

4. This does not work with me. I'll look into it some more.

After having played some time with Manuipulate for the little thingies I am making, I also came across 'Dynamic'. I read about both Manipulate and Dynamic and decided then, to continue (and even rewriting my Manipulate stuff) with Dynamic. I did reasonably well, that is, I managed to make some 20 little programs with Dynamic. One of the advantages of Dynamic is, that it seems to keep the values of my settings when running again. That is quite important for me. If I have a nice setting (nice image), and I want to load in new Random numbers (and to keep the nice settings), this works in Dynamic (for most settings).

I will study again the documentations on Manipulate and Dynamic, as soon as I have the opportunity to do so :-)

Thanks a million, Beat

[I] would like to retain the settings.

There are a few options.

• You can set defaults in the Manipulate (see the documentation).
• You can also dump out a snapshot of the state of the Manipulate when you have it the way you want it. There is a very subtle "+" symbol in the upper right corner of the Manipulate output. If you click on that, it'll show you some options. If you choose "Paste Snapshot" you'll get a new Input cell that has a DynamicModule expression in it. If you evaluate that cell, you should get the exact same result that your Manipulate is currently displaying, and you'll see that DynamicModule has initialized all of its variables to the values they currently have in the Manipulate. You can now use that DynamicModule expression as a template going forward. You can change the random points and re-evaluate the DynamicModule using those same parameter values.
• You can switch the DynamicModule to With (just change the head), and your parameters will be "fixed".
• You can make the parameters global, just assign them in a different (previous) cell. Extract the body of the Manipulate into its own cell and evaluate it.

I have tried to seperate the Grid[Debug stuff] and the Graphics[graphics stuff], but I get errors again, although the code looks quite all right and logical to me.

I've taken the Graphics from here and put it outuside the Grid but that does not work

But If I comment out the whole Grid[ . . . ], then it works.

I cannot wrap my mind around that. I kept the GHrid[...] the same as when the Graphics part is inside the Grid and the thing works all right. Maybe I messed up with : SpanFromLeft}

I get the idea that I miss something with WL on a very basic level, as many things are totally against my intuition and logic. Some things make perfect sense, some things just don't. I am getting quite sad about that and do not really what to do. I feel bad about taking so much time from you and others before.

I'll look into your other answer tomorrow. I am too frustrated right now :-(

Beat

Attached my try with taking the Graphic part out

Attachments:

Eric Rimbey mani...nb

I replaced the comma with the semi colon and that works. I suppose the semicolon is to 'close off' the Grid[ ] function.

I do not see the values now anymore, but I will look into that tomorrow. It's quite late already where I reside.

Thanks

You previously said that you were able to get the Graphics outside of the grid by replacing the comma with a semi-colon. Eventually I think you'll want to get this bit working, because Grid will add unecessary padding, I think.

Gotcha. Yeah the semi-colon means you have a CompoundExpression, and only the last part of a compound expression gets "returned". I would just put in an If expression and just copy-paste the Graphics bit (actually, it'd be better to assign it to a variable, but whatever). You could even add a debug variable to the Manipulate. Like this:

With[{xCoords = {28, 39, 48, 1, 4, 70, 86, 83, 14, 23}, 
  yCoords = {36, 76, 41, 56, 39, 6, 83, 7, 59, 33}}, 
 With[{pts = Transpose[{xCoords, yCoords}]},
  Manipulate[
   If[debugQ, 
    Grid[{{"pointSubRange", pointSubRange}, {"pointCount", 
       Abs[Subtract @@ pointSubRange]}, {"allPts", 
       pts}, {"selectedPts", 
       Take[pts, pointSubRange]}, {"splineDegree", 
       splineDegree}, {"groupedPoints", 
       Partition[pts, UpTo[groupSize]]}, {"lineThickness", 
       lineThickness}, {"aspectRatio", aspectRatio}, {"curveType", 
       curveType}, {"splineClosedQ", splineClosedQ}, {"showPointsQ", 
       showPointsQ}, {Graphics[{Thickness[lineThickness], 
         curveType[
          Partition[Take[pts, pointSubRange], UpTo[groupSize]], 
          SplineDegree -> splineDegree, 
          SplineClosed -> splineClosedQ], Red, 
         If[showPointsQ, Point[pts], Nothing]}], SpanFromLeft}}],
    Graphics[{Thickness[lineThickness], 
      curveType[Partition[Take[pts, pointSubRange], UpTo[groupSize]], 
       SplineDegree -> splineDegree, SplineClosed -> splineClosedQ], 
      Red, If[showPointsQ, Point[pts], Nothing]}]], {pointSubRange, 1,
     Length@pts, 1, ControlType -> IntervalSlider}, {splineDegree, 1, 
    Length@pts, 1}, {groupSize, 2, Length@pts, 1}, {lineThickness, 
    0.005, 0.05}, {aspectRatio, .1, 
    10, .1}, {curveType, {BSplineCurve, 
     BezierCurve}}, {splineClosedQ, {True, 
     False}}, {showPointsQ, {True, False}},
   {debugQ, {False, True}}]]]

Okay, here is a start on what you seem to be trying to do. I've shown the values of the Manipulate variables explicitly just to demonstrate a sort of validate as you go strategy. I built up each part of the Grid bit by bit, adding each new Manipulate variable only after getting the previous ones to work as I wanted. Once the graphic part of the display was to my liking, then I'd remove (or maybe just comment out) these pseudo-debugging elements.

With[
 {xCoords = {28, 39, 48, 1, 4, 70, 86, 83, 14, 23},
  yCoords = {36, 76, 41, 56, 39, 6, 83, 7, 59, 33}},
 With[
  {pts = Transpose[{xCoords, yCoords}]},
  Manipulate[
   Grid[
    {{"pointSubRange", pointSubRange},
     {"pointCount", Abs[Subtract @@ pointSubRange]},
     {"allPts", pts},
     {"selectedPts", Take[pts, pointSubRange]},
     {"splineDegree", splineDegree},
     {"groupedPoints", Partition[pts, UpTo[groupSize]]},
     {"lineThickness", lineThickness},
     {"aspectRatio", aspectRatio},
     {"curveType", curveType},
     {"splineClosedQ", splineClosedQ},
     {"showPointsQ", showPointsQ},
     {Graphics[{Thickness[lineThickness], 
        curveType[
         Partition[Take[pts, pointSubRange], UpTo[groupSize]], 
         SplineDegree -> splineDegree, SplineClosed -> splineClosedQ],
         Red, If[showPointsQ, Point[pts], Nothing]}], 
      SpanFromLeft}}],
   {pointSubRange, 1, Length@pts, 1, ControlType -> IntervalSlider},
   {splineDegree, 1, Length@pts, 1},
   {groupSize, 2, Length@pts, 1},
   {lineThickness, 0.005, 0.05},
   {aspectRatio, .1, 10, .1},
   {curveType, {BSplineCurve, BezierCurve}},
   {splineClosedQ, {True, False}},
   {showPointsQ, {True, False}}]]]

So, For is a special form. In its documentation you'll find this:

Unless an explicit Return is used, the value returned by For is Null.

And for that specific example, I personally wouldn't have gravitated toward a For loop but instead toward some List restructuring/combining strategy like Riffle.

I find it sometimes very hard to pose a question coherently, because I experience part of WL behavior as errartic and hard to pinpoint where the trouble or unclearness is.

Yes, I have a lot of sympathy for you. It takes quite a bit of practice with Mathematica to get familiar with these things, especially if your previous programming experience was with more imperative languages. Wolfam Language is more similar to Lisp than anything else (as far as my experience goes). You need to try to think more in terms of expressions and transformation rules and less in terms of sequential execution of instructions.

Also, a common pattern I see in this forum is notebooks with all of the code in one gigantic cell. This really does make it difficult to debug. My suggestion would be to build up larger expressions from smaller ones. Do some small things in their own cells until you get those working. Then compose them together into a larger expression in another cell. And so on. Maybe people think they're making it easier to read their code if they have one gigantic cell, but the only practical way to start understanding where things go wrong is to start deconstructing that huge cell into smaller chunks. Then the error messages appear close to the offending expression (and maybe you could have figured out for yourself where the problem with Protected was happening).

Anyway, I think you've dug yourself in too far with your current situation. It would be easier to help if we knew what you were trying to do.

As to the last part of your answer :

I agree. I often try things out in separate modules. The putting it together, especially with the Dynamic wrappers, can still cause problems. And then it is hard to see to which line of code the error message refers, as WL does not show variable names.

It is always a choice as to ask an abstraction of the problem, or as you suggets, a wider view as to what actually should happen. In the latter case, the code I'd need to post would be quite some larger :-)

It might be self explonatory for seasoned users, but alas not for me.

I already am wondering what means : Set::write

I just read about "Down Values" this afternoon, otherwise I would not have understood.

With initiating : numPoints = {1, 6}; the error is gone.

Thanks, this was enlightning :-)

Thanks Eric for your answers, I appreciate.

1. The reason I wanted to sometimes take out the semicolon, was to see what the value(s) at that point was. So to Debug. Now I have been shown that there is a built in debugger, I will study that and hopefully be able to use it, as it looks very different from the debuggers I know - at least at first sight. I will look into that.

2. and 3. You are probably right about my conceptions of Dynamic and certainly about how I've expressed it. I know though that Dynamic is a wrapper. I started of with using Manipulate, but soon got stuck by my scripts becoming too long to make them understandable in a Manipulate wrapper. I could not subdivide my script and lost control in the woods of different kinds of brackets and functions. And I could not test my variables (= intermidiate steps) to see where it fell apart. The error messages are quite cryptic at times :-) So I read the docs about Manipulate and Dynamic and decided to go for Dynamic. If I remember correctly, the Manipulate is a wrapper around a Dynamic script part that is being created by Manipulate. But I'm not totally sure that I say this correctly.

Almost all my scripts are being done with Dynamic and I am sure not in the most effective way. But then again, I am still learning and already glad a script is working :-)

I use many separate variables so I can see (debug) where I go wrong. If I do much in 1 compound function, I have no idea where I mess up. When a script works, I try tyo compact it, but it has not top priority for me. And of course I want to learn better as well.

Thanks, your explanation makes sense. As opposed to the directions on screen :-) I will see if I can Edit my previous post as to 'Attach' the Nb

How to attach a Nb properly?

Agree that it is a bit confusing. "Add" versus "Attach". My experience:

• If you want the notebook contents to appear directly in the post, use the editors menu button "Add Notebook". Which you obviously did.

• If you do not want the notebook to appear directly in the post, use the button "Add a file to this post" at the bottom. That will insert a reference to the notebook which can then be downloaded by the viewer. And opened in Mathematica.

For 1., 2., 3. can you provide a specific example? Is this what you are trying to do?

Row@{Dynamic[x], " ", Slider[Dynamic[x]]}

For 4. have you tried the built-in debugger?