Unwanted re-evaluation of a variable inside Manipulate












2












$begingroup$


In the below Manipulate expression:



Discretize=Function[{f,steps,x1},Table[f[x],{x,0,x1,Floor[x1/steps]}]];
MakePoints=Function[var,Table[x^2+RandomReal[{-var,var}],{x,0,15,1}]];
Manipulate[
GetDiff = Function[
Total[dta] - Total[mdl]
];
dta = MakePoints[15];
mdl = Discretize[Function[x, τ*x^2], Length[dta] - 1,
Length[dta] - 1];
ListLinePlot[{dta, mdl},
PlotRange -> {{0, Length[dta] - 1}, {0, 250}},
PlotLegends -> {"data", "model"}],
{{τ, 1}, .01, 3, .01},
Dynamic[
diff = GetDiff;
"τ: " <> ToString[τ] <>
"nΣdata: " <> ToString[Total[dta]] <>
"nΣmodel: " <> ToString[Total[mdl]] <>
"nΣdata-Σmodel: " <> ToString[diff]
]
]


Why does varying the parameter seemingly reevaluate dta? I get a constantly changing dta line while I vary the parameter.



Manipulate plot










share|improve this question











$endgroup$

















    2












    $begingroup$


    In the below Manipulate expression:



    Discretize=Function[{f,steps,x1},Table[f[x],{x,0,x1,Floor[x1/steps]}]];
    MakePoints=Function[var,Table[x^2+RandomReal[{-var,var}],{x,0,15,1}]];
    Manipulate[
    GetDiff = Function[
    Total[dta] - Total[mdl]
    ];
    dta = MakePoints[15];
    mdl = Discretize[Function[x, τ*x^2], Length[dta] - 1,
    Length[dta] - 1];
    ListLinePlot[{dta, mdl},
    PlotRange -> {{0, Length[dta] - 1}, {0, 250}},
    PlotLegends -> {"data", "model"}],
    {{τ, 1}, .01, 3, .01},
    Dynamic[
    diff = GetDiff;
    "τ: " <> ToString[τ] <>
    "nΣdata: " <> ToString[Total[dta]] <>
    "nΣmodel: " <> ToString[Total[mdl]] <>
    "nΣdata-Σmodel: " <> ToString[diff]
    ]
    ]


    Why does varying the parameter seemingly reevaluate dta? I get a constantly changing dta line while I vary the parameter.



    Manipulate plot










    share|improve this question











    $endgroup$















      2












      2








      2





      $begingroup$


      In the below Manipulate expression:



      Discretize=Function[{f,steps,x1},Table[f[x],{x,0,x1,Floor[x1/steps]}]];
      MakePoints=Function[var,Table[x^2+RandomReal[{-var,var}],{x,0,15,1}]];
      Manipulate[
      GetDiff = Function[
      Total[dta] - Total[mdl]
      ];
      dta = MakePoints[15];
      mdl = Discretize[Function[x, τ*x^2], Length[dta] - 1,
      Length[dta] - 1];
      ListLinePlot[{dta, mdl},
      PlotRange -> {{0, Length[dta] - 1}, {0, 250}},
      PlotLegends -> {"data", "model"}],
      {{τ, 1}, .01, 3, .01},
      Dynamic[
      diff = GetDiff;
      "τ: " <> ToString[τ] <>
      "nΣdata: " <> ToString[Total[dta]] <>
      "nΣmodel: " <> ToString[Total[mdl]] <>
      "nΣdata-Σmodel: " <> ToString[diff]
      ]
      ]


      Why does varying the parameter seemingly reevaluate dta? I get a constantly changing dta line while I vary the parameter.



      Manipulate plot










      share|improve this question











      $endgroup$




      In the below Manipulate expression:



      Discretize=Function[{f,steps,x1},Table[f[x],{x,0,x1,Floor[x1/steps]}]];
      MakePoints=Function[var,Table[x^2+RandomReal[{-var,var}],{x,0,15,1}]];
      Manipulate[
      GetDiff = Function[
      Total[dta] - Total[mdl]
      ];
      dta = MakePoints[15];
      mdl = Discretize[Function[x, τ*x^2], Length[dta] - 1,
      Length[dta] - 1];
      ListLinePlot[{dta, mdl},
      PlotRange -> {{0, Length[dta] - 1}, {0, 250}},
      PlotLegends -> {"data", "model"}],
      {{τ, 1}, .01, 3, .01},
      Dynamic[
      diff = GetDiff;
      "τ: " <> ToString[τ] <>
      "nΣdata: " <> ToString[Total[dta]] <>
      "nΣmodel: " <> ToString[Total[mdl]] <>
      "nΣdata-Σmodel: " <> ToString[diff]
      ]
      ]


      Why does varying the parameter seemingly reevaluate dta? I get a constantly changing dta line while I vary the parameter.



      Manipulate plot







      manipulate






      share|improve this question















      share|improve this question













      share|improve this question




      share|improve this question








      edited 4 hours ago









      m_goldberg

      85.4k872196




      85.4k872196










      asked 10 hours ago









      pedroospedroos

      354




      354






















          3 Answers
          3






          active

          oldest

          votes


















          2












          $begingroup$

          Your MakePoints[ ] function has a RandomReal[ ] function call in it, so it is randomizing each time you move the Manipulate slider. Just move it outside.



          dta = MakePoints[15];

          Manipulate[GetDiff = Function[Total[dta] - Total[mdl]];
          (*dta=MakePoints[15];*)
          ...Etc.]


          or you can wrap the internal random call with a BlockRandom[ ]



          Manipulate[GetDiff = Function[Total[dta] - Total[mdl]];
          dta = BlockRandom@MakePoints[15];
          .... Etc. ]





          share|improve this answer











          $endgroup$













          • $begingroup$
            Can I ask if there is a way to not re-evaluate a variable that's independent from the parameter being manipulated? Thanks.
            $endgroup$
            – pedroos
            9 hours ago






          • 1




            $begingroup$
            When you use Manipulate, the internals of the body of the command get evaluated no matter which parameter you are manipulating, so you have to use some tricks to suppress the random call. Somebody else smarter than I am may have a solution.
            $endgroup$
            – MikeY
            9 hours ago





















          3












          $begingroup$

          Your code can be fixed and made much simpler and more efficient, all at the same time. Like so;



          Discretize = Function[{f, steps, x1}, Table[f[x], {x, 0, x1, Floor[x1/steps]}]];

          MakePoints = Function[var, Table[x^2 + RandomReal[{-var, var}], {x, 0, 15, 1}]];

          SeedRandom[1];
          Manipulate[
          mdl = Discretize[Function[x, τ x^2], Length[dta] - 1, Length[dta] - 1];
          tmdl = Total[mdl];
          Column[{
          ListLinePlot[{dta, mdl},
          PlotRange -> {{0, Length[dta] - 1}, {0, 250}},
          PlotLegends -> {"data", "model"},
          ImageSize -> Medium],
          Row[{"Σdata: ", tdta}],
          Row[{"Σmodel: ", tmdl}],
          Row[{"Σdata-Σmodel: ", tdta - tmdl}]}],
          {{dta, MakePoints[15]}, None},
          {{tdta, Total[dta]}, None},
          {mdl, None},
          {tmdl, None},
          {{τ, 1}, .01, 3, .01, Appearance -> "Labeled"},
          TrackedSymbols :> {τ}]]


          ,



          Notes





          1. GetDiff is not needed.

          2. Introducing some local variables with specifications of the form {varspec, None}, which are automatically dynamic, makes for cleaner code and makes it easy to set static values for data and tdta.

          3. Calling MakePoints as an initializer in the specification of dta fixes you problem of unwanted re-evaluation.

          4. Only τ need be tracked, which reduces the load on the front-end.

          5. Introducing Column and Row much simplifies the formatting of the output.

          6. Adding the Appearance -> "Labeled" option to the specification of τ eliminates the need to write code to show τ in the output,

          7. This approach does not require calling Dynamic explicitly anywhere in the Manipulate expression.






          share|improve this answer











          $endgroup$





















            1












            $begingroup$

            Another option using DynamicModule which is the proper tool for interfaces that have local variables:



            DynamicModule[
            {MakePoints, Discretize, dta, tdta, mdl, tmdl},
            Manipulate[
            mdl = Discretize[Function[x, τ x^2], Length[dta] - 1,
            Length[dta] - 1];
            tmdl = Total[mdl];
            Grid[
            {
            {
            ListLinePlot[
            {dta, mdl},
            PlotRange -> {{0, Length[dta] - 1}, {All, 250}},
            PlotLegends -> {"data", "model"}, ImageSize -> Medium
            ],
            SpanFromLeft
            },
            {Subscript["Σ", "data"], ":", tdta},
            {Subscript["Σ", "model"], ":", tmdl},
            {
            Row@{Subscript["Σ", "data"], "-",
            Subscript["Σ", "model"]}, ":",
            tdta - tmdl
            }
            },
            Alignment -> Left
            ],
            {{τ, 1}, .01, 3, .01, Appearance -> "Labeled"},
            TrackedSymbols :> {τ}
            ],
            Initialization :> {
            MakePoints =
            Function[var, Range[0, 15]^2 + RandomReal[{-var, var}, 16]],
            Discretize =
            Function[{f, steps, x1}, Table[f[x], {x, 0, x1, Floor[x1/steps]}]],
            dta = MakePoints[15],
            tdta = Total[dta]
            }
            ]





            share|improve this answer









            $endgroup$













              Your Answer





              StackExchange.ifUsing("editor", function () {
              return StackExchange.using("mathjaxEditing", function () {
              StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
              StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["$", "$"], ["\\(","\\)"]]);
              });
              });
              }, "mathjax-editing");

              StackExchange.ready(function() {
              var channelOptions = {
              tags: "".split(" "),
              id: "387"
              };
              initTagRenderer("".split(" "), "".split(" "), channelOptions);

              StackExchange.using("externalEditor", function() {
              // Have to fire editor after snippets, if snippets enabled
              if (StackExchange.settings.snippets.snippetsEnabled) {
              StackExchange.using("snippets", function() {
              createEditor();
              });
              }
              else {
              createEditor();
              }
              });

              function createEditor() {
              StackExchange.prepareEditor({
              heartbeatType: 'answer',
              autoActivateHeartbeat: false,
              convertImagesToLinks: false,
              noModals: true,
              showLowRepImageUploadWarning: true,
              reputationToPostImages: null,
              bindNavPrevention: true,
              postfix: "",
              imageUploader: {
              brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
              contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
              allowUrls: true
              },
              onDemand: true,
              discardSelector: ".discard-answer"
              ,immediatelyShowMarkdownHelp:true
              });


              }
              });














              draft saved

              draft discarded


















              StackExchange.ready(
              function () {
              StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f190484%2funwanted-re-evaluation-of-a-variable-inside-manipulate%23new-answer', 'question_page');
              }
              );

              Post as a guest















              Required, but never shown

























              3 Answers
              3






              active

              oldest

              votes








              3 Answers
              3






              active

              oldest

              votes









              active

              oldest

              votes






              active

              oldest

              votes









              2












              $begingroup$

              Your MakePoints[ ] function has a RandomReal[ ] function call in it, so it is randomizing each time you move the Manipulate slider. Just move it outside.



              dta = MakePoints[15];

              Manipulate[GetDiff = Function[Total[dta] - Total[mdl]];
              (*dta=MakePoints[15];*)
              ...Etc.]


              or you can wrap the internal random call with a BlockRandom[ ]



              Manipulate[GetDiff = Function[Total[dta] - Total[mdl]];
              dta = BlockRandom@MakePoints[15];
              .... Etc. ]





              share|improve this answer











              $endgroup$













              • $begingroup$
                Can I ask if there is a way to not re-evaluate a variable that's independent from the parameter being manipulated? Thanks.
                $endgroup$
                – pedroos
                9 hours ago






              • 1




                $begingroup$
                When you use Manipulate, the internals of the body of the command get evaluated no matter which parameter you are manipulating, so you have to use some tricks to suppress the random call. Somebody else smarter than I am may have a solution.
                $endgroup$
                – MikeY
                9 hours ago


















              2












              $begingroup$

              Your MakePoints[ ] function has a RandomReal[ ] function call in it, so it is randomizing each time you move the Manipulate slider. Just move it outside.



              dta = MakePoints[15];

              Manipulate[GetDiff = Function[Total[dta] - Total[mdl]];
              (*dta=MakePoints[15];*)
              ...Etc.]


              or you can wrap the internal random call with a BlockRandom[ ]



              Manipulate[GetDiff = Function[Total[dta] - Total[mdl]];
              dta = BlockRandom@MakePoints[15];
              .... Etc. ]





              share|improve this answer











              $endgroup$













              • $begingroup$
                Can I ask if there is a way to not re-evaluate a variable that's independent from the parameter being manipulated? Thanks.
                $endgroup$
                – pedroos
                9 hours ago






              • 1




                $begingroup$
                When you use Manipulate, the internals of the body of the command get evaluated no matter which parameter you are manipulating, so you have to use some tricks to suppress the random call. Somebody else smarter than I am may have a solution.
                $endgroup$
                – MikeY
                9 hours ago
















              2












              2








              2





              $begingroup$

              Your MakePoints[ ] function has a RandomReal[ ] function call in it, so it is randomizing each time you move the Manipulate slider. Just move it outside.



              dta = MakePoints[15];

              Manipulate[GetDiff = Function[Total[dta] - Total[mdl]];
              (*dta=MakePoints[15];*)
              ...Etc.]


              or you can wrap the internal random call with a BlockRandom[ ]



              Manipulate[GetDiff = Function[Total[dta] - Total[mdl]];
              dta = BlockRandom@MakePoints[15];
              .... Etc. ]





              share|improve this answer











              $endgroup$



              Your MakePoints[ ] function has a RandomReal[ ] function call in it, so it is randomizing each time you move the Manipulate slider. Just move it outside.



              dta = MakePoints[15];

              Manipulate[GetDiff = Function[Total[dta] - Total[mdl]];
              (*dta=MakePoints[15];*)
              ...Etc.]


              or you can wrap the internal random call with a BlockRandom[ ]



              Manipulate[GetDiff = Function[Total[dta] - Total[mdl]];
              dta = BlockRandom@MakePoints[15];
              .... Etc. ]






              share|improve this answer














              share|improve this answer



              share|improve this answer








              edited 9 hours ago

























              answered 9 hours ago









              MikeYMikeY

              2,522412




              2,522412












              • $begingroup$
                Can I ask if there is a way to not re-evaluate a variable that's independent from the parameter being manipulated? Thanks.
                $endgroup$
                – pedroos
                9 hours ago






              • 1




                $begingroup$
                When you use Manipulate, the internals of the body of the command get evaluated no matter which parameter you are manipulating, so you have to use some tricks to suppress the random call. Somebody else smarter than I am may have a solution.
                $endgroup$
                – MikeY
                9 hours ago




















              • $begingroup$
                Can I ask if there is a way to not re-evaluate a variable that's independent from the parameter being manipulated? Thanks.
                $endgroup$
                – pedroos
                9 hours ago






              • 1




                $begingroup$
                When you use Manipulate, the internals of the body of the command get evaluated no matter which parameter you are manipulating, so you have to use some tricks to suppress the random call. Somebody else smarter than I am may have a solution.
                $endgroup$
                – MikeY
                9 hours ago


















              $begingroup$
              Can I ask if there is a way to not re-evaluate a variable that's independent from the parameter being manipulated? Thanks.
              $endgroup$
              – pedroos
              9 hours ago




              $begingroup$
              Can I ask if there is a way to not re-evaluate a variable that's independent from the parameter being manipulated? Thanks.
              $endgroup$
              – pedroos
              9 hours ago




              1




              1




              $begingroup$
              When you use Manipulate, the internals of the body of the command get evaluated no matter which parameter you are manipulating, so you have to use some tricks to suppress the random call. Somebody else smarter than I am may have a solution.
              $endgroup$
              – MikeY
              9 hours ago






              $begingroup$
              When you use Manipulate, the internals of the body of the command get evaluated no matter which parameter you are manipulating, so you have to use some tricks to suppress the random call. Somebody else smarter than I am may have a solution.
              $endgroup$
              – MikeY
              9 hours ago













              3












              $begingroup$

              Your code can be fixed and made much simpler and more efficient, all at the same time. Like so;



              Discretize = Function[{f, steps, x1}, Table[f[x], {x, 0, x1, Floor[x1/steps]}]];

              MakePoints = Function[var, Table[x^2 + RandomReal[{-var, var}], {x, 0, 15, 1}]];

              SeedRandom[1];
              Manipulate[
              mdl = Discretize[Function[x, τ x^2], Length[dta] - 1, Length[dta] - 1];
              tmdl = Total[mdl];
              Column[{
              ListLinePlot[{dta, mdl},
              PlotRange -> {{0, Length[dta] - 1}, {0, 250}},
              PlotLegends -> {"data", "model"},
              ImageSize -> Medium],
              Row[{"Σdata: ", tdta}],
              Row[{"Σmodel: ", tmdl}],
              Row[{"Σdata-Σmodel: ", tdta - tmdl}]}],
              {{dta, MakePoints[15]}, None},
              {{tdta, Total[dta]}, None},
              {mdl, None},
              {tmdl, None},
              {{τ, 1}, .01, 3, .01, Appearance -> "Labeled"},
              TrackedSymbols :> {τ}]]


              ,



              Notes





              1. GetDiff is not needed.

              2. Introducing some local variables with specifications of the form {varspec, None}, which are automatically dynamic, makes for cleaner code and makes it easy to set static values for data and tdta.

              3. Calling MakePoints as an initializer in the specification of dta fixes you problem of unwanted re-evaluation.

              4. Only τ need be tracked, which reduces the load on the front-end.

              5. Introducing Column and Row much simplifies the formatting of the output.

              6. Adding the Appearance -> "Labeled" option to the specification of τ eliminates the need to write code to show τ in the output,

              7. This approach does not require calling Dynamic explicitly anywhere in the Manipulate expression.






              share|improve this answer











              $endgroup$


















                3












                $begingroup$

                Your code can be fixed and made much simpler and more efficient, all at the same time. Like so;



                Discretize = Function[{f, steps, x1}, Table[f[x], {x, 0, x1, Floor[x1/steps]}]];

                MakePoints = Function[var, Table[x^2 + RandomReal[{-var, var}], {x, 0, 15, 1}]];

                SeedRandom[1];
                Manipulate[
                mdl = Discretize[Function[x, τ x^2], Length[dta] - 1, Length[dta] - 1];
                tmdl = Total[mdl];
                Column[{
                ListLinePlot[{dta, mdl},
                PlotRange -> {{0, Length[dta] - 1}, {0, 250}},
                PlotLegends -> {"data", "model"},
                ImageSize -> Medium],
                Row[{"Σdata: ", tdta}],
                Row[{"Σmodel: ", tmdl}],
                Row[{"Σdata-Σmodel: ", tdta - tmdl}]}],
                {{dta, MakePoints[15]}, None},
                {{tdta, Total[dta]}, None},
                {mdl, None},
                {tmdl, None},
                {{τ, 1}, .01, 3, .01, Appearance -> "Labeled"},
                TrackedSymbols :> {τ}]]


                ,



                Notes





                1. GetDiff is not needed.

                2. Introducing some local variables with specifications of the form {varspec, None}, which are automatically dynamic, makes for cleaner code and makes it easy to set static values for data and tdta.

                3. Calling MakePoints as an initializer in the specification of dta fixes you problem of unwanted re-evaluation.

                4. Only τ need be tracked, which reduces the load on the front-end.

                5. Introducing Column and Row much simplifies the formatting of the output.

                6. Adding the Appearance -> "Labeled" option to the specification of τ eliminates the need to write code to show τ in the output,

                7. This approach does not require calling Dynamic explicitly anywhere in the Manipulate expression.






                share|improve this answer











                $endgroup$
















                  3












                  3








                  3





                  $begingroup$

                  Your code can be fixed and made much simpler and more efficient, all at the same time. Like so;



                  Discretize = Function[{f, steps, x1}, Table[f[x], {x, 0, x1, Floor[x1/steps]}]];

                  MakePoints = Function[var, Table[x^2 + RandomReal[{-var, var}], {x, 0, 15, 1}]];

                  SeedRandom[1];
                  Manipulate[
                  mdl = Discretize[Function[x, τ x^2], Length[dta] - 1, Length[dta] - 1];
                  tmdl = Total[mdl];
                  Column[{
                  ListLinePlot[{dta, mdl},
                  PlotRange -> {{0, Length[dta] - 1}, {0, 250}},
                  PlotLegends -> {"data", "model"},
                  ImageSize -> Medium],
                  Row[{"Σdata: ", tdta}],
                  Row[{"Σmodel: ", tmdl}],
                  Row[{"Σdata-Σmodel: ", tdta - tmdl}]}],
                  {{dta, MakePoints[15]}, None},
                  {{tdta, Total[dta]}, None},
                  {mdl, None},
                  {tmdl, None},
                  {{τ, 1}, .01, 3, .01, Appearance -> "Labeled"},
                  TrackedSymbols :> {τ}]]


                  ,



                  Notes





                  1. GetDiff is not needed.

                  2. Introducing some local variables with specifications of the form {varspec, None}, which are automatically dynamic, makes for cleaner code and makes it easy to set static values for data and tdta.

                  3. Calling MakePoints as an initializer in the specification of dta fixes you problem of unwanted re-evaluation.

                  4. Only τ need be tracked, which reduces the load on the front-end.

                  5. Introducing Column and Row much simplifies the formatting of the output.

                  6. Adding the Appearance -> "Labeled" option to the specification of τ eliminates the need to write code to show τ in the output,

                  7. This approach does not require calling Dynamic explicitly anywhere in the Manipulate expression.






                  share|improve this answer











                  $endgroup$



                  Your code can be fixed and made much simpler and more efficient, all at the same time. Like so;



                  Discretize = Function[{f, steps, x1}, Table[f[x], {x, 0, x1, Floor[x1/steps]}]];

                  MakePoints = Function[var, Table[x^2 + RandomReal[{-var, var}], {x, 0, 15, 1}]];

                  SeedRandom[1];
                  Manipulate[
                  mdl = Discretize[Function[x, τ x^2], Length[dta] - 1, Length[dta] - 1];
                  tmdl = Total[mdl];
                  Column[{
                  ListLinePlot[{dta, mdl},
                  PlotRange -> {{0, Length[dta] - 1}, {0, 250}},
                  PlotLegends -> {"data", "model"},
                  ImageSize -> Medium],
                  Row[{"Σdata: ", tdta}],
                  Row[{"Σmodel: ", tmdl}],
                  Row[{"Σdata-Σmodel: ", tdta - tmdl}]}],
                  {{dta, MakePoints[15]}, None},
                  {{tdta, Total[dta]}, None},
                  {mdl, None},
                  {tmdl, None},
                  {{τ, 1}, .01, 3, .01, Appearance -> "Labeled"},
                  TrackedSymbols :> {τ}]]


                  ,



                  Notes





                  1. GetDiff is not needed.

                  2. Introducing some local variables with specifications of the form {varspec, None}, which are automatically dynamic, makes for cleaner code and makes it easy to set static values for data and tdta.

                  3. Calling MakePoints as an initializer in the specification of dta fixes you problem of unwanted re-evaluation.

                  4. Only τ need be tracked, which reduces the load on the front-end.

                  5. Introducing Column and Row much simplifies the formatting of the output.

                  6. Adding the Appearance -> "Labeled" option to the specification of τ eliminates the need to write code to show τ in the output,

                  7. This approach does not require calling Dynamic explicitly anywhere in the Manipulate expression.







                  share|improve this answer














                  share|improve this answer



                  share|improve this answer








                  edited 4 hours ago

























                  answered 5 hours ago









                  m_goldbergm_goldberg

                  85.4k872196




                  85.4k872196























                      1












                      $begingroup$

                      Another option using DynamicModule which is the proper tool for interfaces that have local variables:



                      DynamicModule[
                      {MakePoints, Discretize, dta, tdta, mdl, tmdl},
                      Manipulate[
                      mdl = Discretize[Function[x, τ x^2], Length[dta] - 1,
                      Length[dta] - 1];
                      tmdl = Total[mdl];
                      Grid[
                      {
                      {
                      ListLinePlot[
                      {dta, mdl},
                      PlotRange -> {{0, Length[dta] - 1}, {All, 250}},
                      PlotLegends -> {"data", "model"}, ImageSize -> Medium
                      ],
                      SpanFromLeft
                      },
                      {Subscript["Σ", "data"], ":", tdta},
                      {Subscript["Σ", "model"], ":", tmdl},
                      {
                      Row@{Subscript["Σ", "data"], "-",
                      Subscript["Σ", "model"]}, ":",
                      tdta - tmdl
                      }
                      },
                      Alignment -> Left
                      ],
                      {{τ, 1}, .01, 3, .01, Appearance -> "Labeled"},
                      TrackedSymbols :> {τ}
                      ],
                      Initialization :> {
                      MakePoints =
                      Function[var, Range[0, 15]^2 + RandomReal[{-var, var}, 16]],
                      Discretize =
                      Function[{f, steps, x1}, Table[f[x], {x, 0, x1, Floor[x1/steps]}]],
                      dta = MakePoints[15],
                      tdta = Total[dta]
                      }
                      ]





                      share|improve this answer









                      $endgroup$


















                        1












                        $begingroup$

                        Another option using DynamicModule which is the proper tool for interfaces that have local variables:



                        DynamicModule[
                        {MakePoints, Discretize, dta, tdta, mdl, tmdl},
                        Manipulate[
                        mdl = Discretize[Function[x, τ x^2], Length[dta] - 1,
                        Length[dta] - 1];
                        tmdl = Total[mdl];
                        Grid[
                        {
                        {
                        ListLinePlot[
                        {dta, mdl},
                        PlotRange -> {{0, Length[dta] - 1}, {All, 250}},
                        PlotLegends -> {"data", "model"}, ImageSize -> Medium
                        ],
                        SpanFromLeft
                        },
                        {Subscript["Σ", "data"], ":", tdta},
                        {Subscript["Σ", "model"], ":", tmdl},
                        {
                        Row@{Subscript["Σ", "data"], "-",
                        Subscript["Σ", "model"]}, ":",
                        tdta - tmdl
                        }
                        },
                        Alignment -> Left
                        ],
                        {{τ, 1}, .01, 3, .01, Appearance -> "Labeled"},
                        TrackedSymbols :> {τ}
                        ],
                        Initialization :> {
                        MakePoints =
                        Function[var, Range[0, 15]^2 + RandomReal[{-var, var}, 16]],
                        Discretize =
                        Function[{f, steps, x1}, Table[f[x], {x, 0, x1, Floor[x1/steps]}]],
                        dta = MakePoints[15],
                        tdta = Total[dta]
                        }
                        ]





                        share|improve this answer









                        $endgroup$
















                          1












                          1








                          1





                          $begingroup$

                          Another option using DynamicModule which is the proper tool for interfaces that have local variables:



                          DynamicModule[
                          {MakePoints, Discretize, dta, tdta, mdl, tmdl},
                          Manipulate[
                          mdl = Discretize[Function[x, τ x^2], Length[dta] - 1,
                          Length[dta] - 1];
                          tmdl = Total[mdl];
                          Grid[
                          {
                          {
                          ListLinePlot[
                          {dta, mdl},
                          PlotRange -> {{0, Length[dta] - 1}, {All, 250}},
                          PlotLegends -> {"data", "model"}, ImageSize -> Medium
                          ],
                          SpanFromLeft
                          },
                          {Subscript["Σ", "data"], ":", tdta},
                          {Subscript["Σ", "model"], ":", tmdl},
                          {
                          Row@{Subscript["Σ", "data"], "-",
                          Subscript["Σ", "model"]}, ":",
                          tdta - tmdl
                          }
                          },
                          Alignment -> Left
                          ],
                          {{τ, 1}, .01, 3, .01, Appearance -> "Labeled"},
                          TrackedSymbols :> {τ}
                          ],
                          Initialization :> {
                          MakePoints =
                          Function[var, Range[0, 15]^2 + RandomReal[{-var, var}, 16]],
                          Discretize =
                          Function[{f, steps, x1}, Table[f[x], {x, 0, x1, Floor[x1/steps]}]],
                          dta = MakePoints[15],
                          tdta = Total[dta]
                          }
                          ]





                          share|improve this answer









                          $endgroup$



                          Another option using DynamicModule which is the proper tool for interfaces that have local variables:



                          DynamicModule[
                          {MakePoints, Discretize, dta, tdta, mdl, tmdl},
                          Manipulate[
                          mdl = Discretize[Function[x, τ x^2], Length[dta] - 1,
                          Length[dta] - 1];
                          tmdl = Total[mdl];
                          Grid[
                          {
                          {
                          ListLinePlot[
                          {dta, mdl},
                          PlotRange -> {{0, Length[dta] - 1}, {All, 250}},
                          PlotLegends -> {"data", "model"}, ImageSize -> Medium
                          ],
                          SpanFromLeft
                          },
                          {Subscript["Σ", "data"], ":", tdta},
                          {Subscript["Σ", "model"], ":", tmdl},
                          {
                          Row@{Subscript["Σ", "data"], "-",
                          Subscript["Σ", "model"]}, ":",
                          tdta - tmdl
                          }
                          },
                          Alignment -> Left
                          ],
                          {{τ, 1}, .01, 3, .01, Appearance -> "Labeled"},
                          TrackedSymbols :> {τ}
                          ],
                          Initialization :> {
                          MakePoints =
                          Function[var, Range[0, 15]^2 + RandomReal[{-var, var}, 16]],
                          Discretize =
                          Function[{f, steps, x1}, Table[f[x], {x, 0, x1, Floor[x1/steps]}]],
                          dta = MakePoints[15],
                          tdta = Total[dta]
                          }
                          ]






                          share|improve this answer












                          share|improve this answer



                          share|improve this answer










                          answered 43 mins ago









                          b3m2a1b3m2a1

                          27.5k257161




                          27.5k257161






























                              draft saved

                              draft discarded




















































                              Thanks for contributing an answer to Mathematica Stack Exchange!


                              • Please be sure to answer the question. Provide details and share your research!

                              But avoid



                              • Asking for help, clarification, or responding to other answers.

                              • Making statements based on opinion; back them up with references or personal experience.


                              Use MathJax to format equations. MathJax reference.


                              To learn more, see our tips on writing great answers.




                              draft saved


                              draft discarded














                              StackExchange.ready(
                              function () {
                              StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f190484%2funwanted-re-evaluation-of-a-variable-inside-manipulate%23new-answer', 'question_page');
                              }
                              );

                              Post as a guest















                              Required, but never shown





















































                              Required, but never shown














                              Required, but never shown












                              Required, but never shown







                              Required, but never shown

































                              Required, but never shown














                              Required, but never shown












                              Required, but never shown







                              Required, but never shown







                              Popular posts from this blog

                              Knooppunt Holsloot

                              Altaar (religie)

                              Gregoriusmis