Wolfram Blog https://blog.wolfram.com:443 News, views, and ideas from the front lines at Wolfram Research. Fri, 11 Sep 2020 20:33:28 +0000 en hourly 1 http://wordpress.org/?v=3.2.1 Wolfram|Alpha Notebook Edition Turns One: Now with Support for Chemistry, Demonstrations and More https://blog.wolfram.com:443/2020/09/11/wolframalpha-notebook-edition-turns-one-now-with-support-for-chemistry-demonstrations-and-more/ https://blog.wolfram.com:443/2020/09/11/wolframalpha-notebook-edition-turns-one-now-with-support-for-chemistry-demonstrations-and-more/#comments Fri, 11 Sep 2020 19:44:03 +0000 Brad Janes https://blog.internal.wolfram.com/?p=68441 Wolfram|Alpha Notebook Edition Turns One: Now with Support for Chemistry, Demonstrations and More

Wolfram|Alpha Notebook Edition was released nearly a year ago, and we’re proud to share what the team has been working on since. In addition to the improvements made to Wolfram|Alpha itself, new input and output suggestions were added. There were parsing fixes, additions to the Wolfram|Alpha-to-Wolfram Language translation and some of the normal improvements one would expect. There are also some bigger features and interesting new capabilities that we will explore in a bit more detail here.

If you haven’t checked out Wolfram|Alpha Notebook Edition in a while, we’d like to invite you to revisit. With education looking a little different for many people right now, this could be a great time to explore this exciting new way to interface with Wolfram technologies.

One of the most useful features of any notebook-based computational environment is the ability to reuse the result of a prior calculation as the input to a new one. Using this, computations can be built up using an intuitive “step-by-step” approach and the need for cutting/pasting or retyping is reduced. In Wolfram|Alpha Notebook Edition, previous outputs can be referenced in a variety of ways, ranging from familiar Wolfram Language constructs such as %n or Out[n] to natural language expressions such as “simplify the last result,” “plot the above” or “square it.” In certain cases, an explicit reference needn’t even appear: e.g. if you input “y = sin(x^3)” followed by “make a plot,” Wolfram|Alpha Notebook Edition will infer that you want to make a plot of the previous equation. This functionality, which has been under continuous development since the release of this product, has recently been extended to leverage the powerful semantic capabilities that power the Suggestions Bar. This allows for context-dependent tailoring of results containing references to previous outputs based on the semantic types of those results. As we build out this functionality, you can expect to see Wolfram|Alpha Notebook Edition becoming even smarter in helping you to build up your computations.

Next is an example of a chain of inputs covering topics through a first-semester calculus course.

Compute a simple limit. If no value to approach is specified, the default is 0.

lim x^2/(1 - cos(x))
&#10005


Cell[CellGroupData[{Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "lim x^2/(1 - cos(x))", "assumptions" -> {}, "parse" ->
   Defer[
     Limit[$CellContext`x^2/(1 - Cos[$CellContext`x]), $CellContext`x ->
      0]], "inputpredictions" -> {{"InputMathOperation$Limits",
      Predictions`Prediction[0.99, "limits", "", {{
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline], " = ", 

           Pane[
            Style[
             HoldForm[0], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}],
         HoldComplete[

          Limit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x -> 0]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline], " = ", 

           Pane[
            Style[
             HoldForm[
              DirectedInfinity[-1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}],
         HoldComplete[

          Limit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x ->
           DirectedInfinity[-1]]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline], " = ", 

           Pane[
            Style[
             HoldForm[
              DirectedInfinity[1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}],
         HoldComplete[

          Limit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x ->
           DirectedInfinity[1]]]& }}], Predictions`InInput}, {
     "InputMathOperation$ChangeDirection",
      Predictions`Prediction[
      0.98, "limits", "", {{"limit from above", HoldComplete[
          Limit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x -> 0, Direction ->
           "FromAbove"]]& }, {"limit from below", HoldComplete[

          Limit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x -> 0, Direction ->
           "FromBelow"]]& }}], Predictions`InInput}, {
     "InputMathOperation$AlternativeLimits",
      Predictions`Prediction[
      0.97, "limits", "", {{"min limit", HoldComplete[

          MinLimit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x -> 0]]& }, {
        "max limit", HoldComplete[

          MaxLimit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x -> 0]]& }}],
      Predictions`InInput}, {
     "InputMathOperation$AnalogousDiscreteLimit",
      Predictions`Prediction[0.96, "limits", "", {{
         Row[{"discrete limit at ",
           Pane[
            Style[
             HoldForm["\[Infinity]"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}],
         HoldComplete[

          DiscreteLimit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x ->
           DirectedInfinity[1]]]& }, {
         Row[{"discrete limit at ",
           Pane[
            Style[
             HoldForm["-\[Infinity]"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}],
         HoldComplete[

          DiscreteLimit[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), $CellContext`x ->
           DirectedInfinity[-1]]]& }}], Predictions`InInput}, {
     "InputMathOperation$TrigAlgebra",
      Predictions`Prediction[
      0.5, "trigonometry", "", {{"expand trig functions", HoldComplete[
          Limit[

           TrigExpand[$CellContext`x^2/(1 -
            Cos[$CellContext`x])], $CellContext`x -> 0]]& }, {
        "factor trig functions", HoldComplete[
          Limit[

           TrigFactor[$CellContext`x^2/(1 -
            Cos[$CellContext`x])], $CellContext`x -> 0]]& }, {
        "reduce trig products and powers", HoldComplete[
          Limit[

           TrigReduce[$CellContext`x^2/(1 -
            Cos[$CellContext`x])], $CellContext`x -> 0]]& }, {
        "convert trig functions to exponentials", HoldComplete[
          Limit[

           TrigToExp[$CellContext`x^2/(1 -
            Cos[$CellContext`x])], $CellContext`x -> 0]]& }}],
      Predictions`InInput}, {"InputMathOperation$ExtractFunction",
      Predictions`Prediction[
      0.5, "structural operations", "extract function", Apply[
       HoldComplete,
        Hold[$CellContext`x^2/(1 - Cos[$CellContext`x])]]& ],
      Predictions`InInput}, {"InputMathOperation$FunctionDomain",
      Predictions`Prediction[
      0.5, "properties", "", {{"function domain", HoldComplete[

          FunctionDomain[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), {$CellContext`x}]]& }, {
        "function range", HoldComplete[

          FunctionRange[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), {$CellContext`x}, {$CellContext`y}]]& \
}}], Predictions`InInput}, {"InputMathOperation$InflectionPoints",
      Predictions`Prediction[
      0.5, "analysis", "inflection points",
       Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction[
         "InflectionPoints"][$CellContext`x^2/(1 -
          Cos[$CellContext`x]),
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$IntegralToInfinity",
      Predictions`Prediction[
      0.5, "integration",
       "", {{"integral from 0 to \[Infinity]", HoldComplete[

          Integrate[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), {$CellContext`x, 0,
            DirectedInfinity[1]}]]& }, {
        "integral from -\[Infinity] to 0", HoldComplete[

          Integrate[$CellContext`x^2/(1 -
           Cos[$CellContext`x]), {$CellContext`x,
            DirectedInfinity[-1], 0}]]& }}], Predictions`InInput}, {
     "InputMathOperation$InvertFunction",
      Predictions`Prediction[
      0.5, "solving", "invert function", HoldComplete[
        Reduce[$CellContext`y == $CellContext`x^2/(1 -
          Cos[$CellContext`x]), $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$Rotate90",
      Predictions`Prediction[
      0.5, "trigonometry", "make trig function arguments imaginary",
       HoldComplete[
        Limit[(Complex[0, 1] $CellContext`x)^2/(1 - Cos[
         Complex[0, 1] $CellContext`x]), $CellContext`x -> 0]]& ],
      Predictions`InInput}, {"InputMathOperation$PlotFunction",
      Predictions`Prediction[
      0.5, "plotting", "plot function", HoldComplete[
        Plot[$CellContext`x^2/(1 -
         Cos[$CellContext`x]), {$CellContext`x, \
-21.2057504117311026448`3., 21.2057504117311026448`3.}]]& ],
      Predictions`InInput}, {"InputMathOperation$Zeros",
      Predictions`Prediction[
      0.5, "analysis", "real zeros", Predictions`Private`ReleaseHolds[

        HoldComplete[
         Solve[$CellContext`x^2/(1 - Cos[$CellContext`x]) == 0, {
           Hold[$CellContext`x]}, Reals]]]& ], Predictions`InInput}, {
     "InputMathOperation$ComplementTrigFunctions",
      Predictions`Prediction[
      0.5, "trigonometry",
       "replace trig functions by their cofunctions", HoldComplete[
        Limit[$CellContext`x^2/(1 -
         Sin[$CellContext`x]), $CellContext`x -> 0]]& ],
      Predictions`InInput}, {
     "InputMathOperation$InverseTrigFunctions",
      Predictions`Prediction[
      0.5, "trigonometry", "replace trig functions by their inverses",
        HoldComplete[
        Limit[$CellContext`x^2/(1 -
         ArcCos[$CellContext`x]), $CellContext`x -> 0]]& ],
      Predictions`InInput}, {
     "InputMathOperation$ReciprocalTrigFunctions",
      Predictions`Prediction[
      0.5, "trigonometry",
       "replace trig functions by their reciprocals", HoldComplete[
        Limit[$CellContext`x^2/(1 -
         Sec[$CellContext`x]), $CellContext`x -> 0]]& ],
      Predictions`InInput}, {"InputMathOperation$StationaryPoints",
      Predictions`Prediction[
      0.5, "analysis", "stationary points",
       Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction[
         "StationaryPoints"][$CellContext`x^2/(1 -
          Cos[$CellContext`x]),
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$Derivatives",
      Predictions`Prediction[0.5, "derivatives",
       Row[{"derivative wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline]}],
       HoldComplete[
        D[$CellContext`x^2/(1 -
         Cos[$CellContext`x]), $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$IndefiniteIntegrals",
      Predictions`Prediction[0.5, "integration",
       Row[{"indefinite integral wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline]}],
       HoldComplete[
        Integrate[$CellContext`x^2/(1 -
         Cos[$CellContext`x]), $CellContext`x]]& ],
      Predictions`InInput}, {
     "InputMathOperation$DerivativeAtLimitPoint",
      Predictions`Prediction[0.5, "derivatives",
       Row[{"derivative at ",
         Pane[
          Style[
           HoldForm[$CellContext`x], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline], " = ",
         Pane[
          Style[
           HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
           BaselinePosition -> Baseline]}], HoldComplete[
        ReplaceAll[

         D[$CellContext`x^2/(1 -
          Cos[$CellContext`x]), $CellContext`x], $CellContext`x ->
         0]]& ], Predictions`InInput}, {"InputMathOperation$Series",
      Predictions`Prediction[0.5, "series",
       Row[{"series expansion at ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline], " = ",
         Pane[
          Style[
           HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
           BaselinePosition -> Baseline]}], HoldComplete[
        Series[$CellContext`x^2/(1 -
         Cos[$CellContext`x]), {$CellContext`x, 0, 5}]]& ],
      Predictions`InInput}},
   "otherpredictions" -> {"StepByStep", "FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {44., 20.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[2]:=",
 CellID->673659406],

Cell[BoxData[
 RowBox[{"Limit", "[",
  RowBox[{
   RowBox[{
    RowBox[{"x", "^", "2"}], "/",
    RowBox[{"(",
     RowBox[{"1", " ", "-", " ",
      RowBox[{"Cos", "[", "x", "]"}]}], ")"}]}], ",", " ",
   RowBox[{"x", " ", "->", " ", "0"}]}], "]"}]], "DeployedWLInput",
 CellChangeTimes->{3.807873027370891*^9},
 CellLabel->"In[2]:=",
 CellID->476579879]
}, Open  ]]

Define a function, such as .

set f(x) equal x^2/(1-cos(x))
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "set f(x) equal x^2/(1-cos(x))", "assumptions" -> {}, "parse" ->
   Defer[$CellContext`f[
       Pattern[$CellContext`x,
        Blank[]]] := $CellContext`x^2/(1 - Cos[$CellContext`x])],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[11]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{"CellSettings"->Association["HideDetails" -> False]},
 CellLabel->"In[2]:=",
 CellID->294391203]

Users can refer to when further investigating its behavior.

limit of f(x) as x goes to Pi
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "limit of f(x) as x goes to Pi", "assumptions" -> {}, "parse" ->
   Defer[
     Limit[
      $CellContext`f[$CellContext`x], $CellContext`x -> Pi]],
   "inputpredictions" -> {{"InputMathOperation$Limits",
      Predictions`Prediction[0.99, "limits", "", {{
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Limit[
           $CellContext`f[$CellContext`x], $CellContext`x -> 0]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              DirectedInfinity[-1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          Limit[
           $CellContext`f[$CellContext`x], $CellContext`x ->
           DirectedInfinity[-1]]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              DirectedInfinity[1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          Limit[
           $CellContext`f[$CellContext`x], $CellContext`x ->
           DirectedInfinity[1]]]& }}], Predictions`InInput}, {
     "InputMathOperation$ChangeDirection",
      Predictions`Prediction[
      0.98, "limits", "", {{"limit from above", HoldComplete[
          Limit[
           $CellContext`f[$CellContext`x], $CellContext`x -> Pi, Direction ->
           "FromAbove"]]& }, {"limit from below", HoldComplete[
          Limit[
           $CellContext`f[$CellContext`x], $CellContext`x -> Pi, Direction ->
           "FromBelow"]]& }}], Predictions`InInput}, {
     "InputMathOperation$AlternativeLimits",
      Predictions`Prediction[0.97, "limits", "", {{"min limit", HoldComplete[
          MinLimit[
           $CellContext`f[$CellContext`x], $CellContext`x -> Pi]]& }, {
        "max limit", HoldComplete[
          MaxLimit[
           $CellContext`f[$CellContext`x], $CellContext`x -> Pi]]& }}],
      Predictions`InInput}, {"InputMathOperation$AnalogousDiscreteLimit",
      Predictions`Prediction[0.96, "limits", "", {{
         Row[{"discrete limit at ",
           Pane[
            Style[
             HoldForm["\[Infinity]"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          DiscreteLimit[
           $CellContext`f[$CellContext`x], $CellContext`x ->
           DirectedInfinity[1]]]& }, {
         Row[{"discrete limit at ",
           Pane[
            Style[
             HoldForm["-\[Infinity]"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          DiscreteLimit[
           $CellContext`f[$CellContext`x], $CellContext`x ->
           DirectedInfinity[-1]]]& }}], Predictions`InInput}, {
     "InputMathOperation$ExtractFunction",
      Predictions`Prediction[
      0.5, "structural operations", "extract function", Apply[HoldComplete,
        Hold[
         $CellContext`f[$CellContext`x]]]& ], Predictions`InInput}, {
     "InputMathOperation$FunctionDomain",
      Predictions`Prediction[
      0.5, "properties", "", {{"function domain", HoldComplete[
          FunctionDomain[
           $CellContext`f[$CellContext`x], {$CellContext`x}]]& }, {
        "function range", HoldComplete[
          FunctionRange[
           $CellContext`f[$CellContext`x], {$CellContext`x}, \
{$CellContext`y}]]& }}], Predictions`InInput}, {
     "InputMathOperation$InflectionPoints",
      Predictions`Prediction[
      0.5, "analysis", "inflection points", Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction["InflectionPoints"][
          $CellContext`f[$CellContext`x],
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$IntegralToInfinity",
      Predictions`Prediction[
      0.5, "integration",
       "", {{"integral from 0 to \[Infinity]", HoldComplete[
          Integrate[
           $CellContext`f[$CellContext`x], {$CellContext`x, 0,
            DirectedInfinity[1]}]]& }, {
        "integral from -\[Infinity] to 0", HoldComplete[
          Integrate[
           $CellContext`f[$CellContext`x], {$CellContext`x,
            DirectedInfinity[-1], 0}]]& }}], Predictions`InInput}, {
     "InputMathOperation$InvertFunction",
      Predictions`Prediction[0.5, "solving", "invert function", HoldComplete[
        Reduce[$CellContext`y == $CellContext`f[$CellContext`x], \
$CellContext`x]]& ], Predictions`InInput}, {
     "InputMathOperation$PlotFunction",
      Predictions`Prediction[0.5, "plotting", "plot function", HoldComplete[
        Plot[$CellContext`x^2/(1 -
         Cos[$CellContext`x]), {$CellContext`x, -21.2057504117311026448`3.,
          21.2057504117311026448`3.}]]& ], Predictions`InInput}, {
     "InputMathOperation$Zeros",
      Predictions`Prediction[
      0.5, "analysis", "real zeros", Predictions`Private`ReleaseHolds[
        HoldComplete[
         Solve[$CellContext`f[$CellContext`x] == 0, {
           Hold[$CellContext`x]}, Reals]]]& ], Predictions`InInput}, {
     "InputMathOperation$StationaryPoints",
      Predictions`Prediction[
      0.5, "analysis", "stationary points", Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction["StationaryPoints"][
          $CellContext`f[$CellContext`x],
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$Derivatives",
      Predictions`Prediction[0.5, "derivatives",
       Row[{"derivative wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        D[
         $CellContext`f[$CellContext`x], $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$IndefiniteIntegrals",
      Predictions`Prediction[0.5, "integration",
       Row[{"indefinite integral wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        Integrate[
         $CellContext`f[$CellContext`x], $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$DerivativeAtLimitPoint",
      Predictions`Prediction[0.5, "derivatives",
       Row[{"derivative at ",
         Pane[
          Style[
           HoldForm[$CellContext`x], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline], " = ",
         Pane[
          Style[
           HoldForm[Pi], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        ReplaceAll[
         D[
          $CellContext`f[$CellContext`x], $CellContext`x], $CellContext`x ->
         Pi]]& ], Predictions`InInput}, {"InputMathOperation$Series",
      Predictions`Prediction[0.5, "series", "", {{
         Row[{"series expansion at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Series[
           $CellContext`f[$CellContext`x], {$CellContext`x, 0, 5}]]& }, {
         Row[{"series expansion at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[Pi], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Series[
           $CellContext`f[$CellContext`x], {$CellContext`x, Pi, 5}]]& }}],
      Predictions`InInput}},
   "otherpredictions" -> {"StepByStep", "FullResults"}, "allassumptions" -> {},
    "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[11]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {43., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{"CellSettings"->Association["HideDetails" -> False]},
 CellLabel->"In[3]:=",
 CellID->1705528146]

Quickly plot the computed limit and .

plot this and f(x)
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "plot this and f(x)", "assumptions" -> {}, "parse" -> Defer[
     Plot[{Pi^2/2,
       $CellContext`f[$CellContext`x]}, {$CellContext`x, -6., 6.}, Evaluated ->
      True]], "inputpredictions" -> {{"InputMathOperation$AlternativePlot",
      Predictions`Prediction[0.99, "plotting", "", {{"log plot", HoldComplete[
          LogPlot[{Pi^2/2,
            $CellContext`f[$CellContext`x]}, {$CellContext`x, -6., 6.},
           Evaluated -> True]]& }, {"log-log plot", HoldComplete[
          LogLogPlot[{Pi^2/2,
            $CellContext`f[$CellContext`x]}, {$CellContext`x, -6., 6.},
           Evaluated -> True]]& }, {"log-linear plot", HoldComplete[
          LogLinearPlot[{Pi^2/2,
            $CellContext`f[$CellContext`x]}, {$CellContext`x, -6., 6.},
           Evaluated -> True]]& }}], Predictions`InInput}, {
     "InputMathOperation$FunctionDomain",
      Predictions`Prediction[
      0.9299999999999999, "properties", "function domain", HoldComplete[
        FunctionDomain[{Pi^2/2,
          $CellContext`f[$CellContext`x]}, {$CellContext`x}]]& ],
      Predictions`InInput}, {"InputMathOperation$AreaBetweenCurves",
      Predictions`Prediction[
      0.91, "applications of calculus", "area between curves", HoldComplete[
        ResourceFunction["AreaBetweenCurves"][{Pi^2/2,
          $CellContext`f[$CellContext`x]}, {$CellContext`x, -6., 6.}]]& ],
      Predictions`InInput}, {"InputMathOperation$ExtractFunction",
      Predictions`Prediction[
      0.5, "structural operations", "extract function", Apply[HoldComplete,
        Hold[{Pi^2/2,
          $CellContext`f[$CellContext`x]}]]& ], Predictions`InInput}, {
     "InputMathOperation$IntegralToInfinity",
      Predictions`Prediction[
      0.5, "integration",
       "", {{"integral from 0 to \[Infinity]", HoldComplete[
          Integrate[{Pi^2/2,
            $CellContext`f[$CellContext`x]}, {$CellContext`x, 0,
            DirectedInfinity[1]}]]& }, {
        "integral from -\[Infinity] to 0", HoldComplete[
          Integrate[{Pi^2/2,
            $CellContext`f[$CellContext`x]}, {$CellContext`x,
            DirectedInfinity[-1], 0}]]& }}], Predictions`InInput}, {
     "InputMathOperation$IntegrateOverPlotRange",
      Predictions`Prediction[
      0.5, "integration", "integrate over plot range", HoldComplete[
        Integrate[{Pi^2/2,
          $CellContext`f[$CellContext`x]}, {$CellContext`x, -6., 6.}]]& ],
      Predictions`InInput}, {"InputMathOperation$Derivatives",
      Predictions`Prediction[0.5, "derivatives",
       Row[{"derivative wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        D[{Pi^2/2,
          $CellContext`f[$CellContext`x]}, $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$IndefiniteIntegrals",
      Predictions`Prediction[0.5, "integration",
       Row[{"indefinite integral wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        Integrate[{Pi^2/2,
          $CellContext`f[$CellContext`x]}, $CellContext`x]]& ],
      Predictions`InInput}}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[13]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {43., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{"CellSettings"->Association["HideDetails" -> False]},
 CellLabel->"In[4]:=",
 CellID->348012345]

Use the limit of the difference quotient to compute the derivative of .

limit
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "limit (f(x+h) - f(x))/h as h->0", "assumptions" -> {}, "parse" ->
   Defer[
     Limit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h -> 0]],
   "inputpredictions" -> {{"InputMathOperation$Limits",
      Predictions`Prediction[0.99, "limits", "", {{
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[

          Limit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`x -> 0]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              DirectedInfinity[-1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[

          Limit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`x ->
           DirectedInfinity[-1]]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              DirectedInfinity[1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[

          Limit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`x ->
           DirectedInfinity[1]]]& }}], Predictions`InInput}, {
     "InputMathOperation$ChangeDirection",
      Predictions`Prediction[
      0.98, "limits", "", {{"limit from above", HoldComplete[

          Limit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h -> 0, Direction ->
           "FromAbove"]]& }, {"limit from below", HoldComplete[

          Limit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h -> 0, Direction ->
           "FromBelow"]]& }}], Predictions`InInput}, {
     "InputMathOperation$AlternativeLimits",
      Predictions`Prediction[0.97, "limits", "", {{"min limit", HoldComplete[

          MinLimit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h -> 0]]& }, {
        "max limit", HoldComplete[

          MaxLimit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h -> 0]]& }}],
      Predictions`InInput}, {"InputMathOperation$AnalogousDiscreteLimit",
      Predictions`Prediction[0.96, "limits", "", {{
         Row[{"discrete limit at ",
           Pane[
            Style[
             HoldForm["\[Infinity]"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[

          DiscreteLimit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h ->
           DirectedInfinity[1]]]& }, {
         Row[{"discrete limit at ",
           Pane[
            Style[
             HoldForm["-\[Infinity]"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[

          DiscreteLimit[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h ->
           DirectedInfinity[-1]]]& }}], Predictions`InInput}, {
     "InputMathOperation$ExtractFunction",
      Predictions`Prediction[
      0.5, "structural operations", "extract function", Apply[HoldComplete,
        Hold[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h]]& ], Predictions`InInput}, {
     "InputMathOperation$FunctionDomain",
      Predictions`Prediction[0.5, "properties", "function domain", HoldComplete[
        FunctionDomain[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, {$CellContext`x}]]& ],
      Predictions`InInput}, {"InputMathOperation$InflectionPoints",
      Predictions`Prediction[
      0.5, "analysis", "inflection points", Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction[
         "InflectionPoints"][($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h,
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$IntegralToInfinity",
      Predictions`Prediction[
      0.5, "integration",
       "", {{"integral from 0 to \[Infinity]", HoldComplete[

          Integrate[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, {$CellContext`x, 0,
            DirectedInfinity[1]}]]& }, {
        "integral from -\[Infinity] to 0", HoldComplete[

          Integrate[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, {$CellContext`x,
            DirectedInfinity[-1], 0}]]& }}], Predictions`InInput}, {
     "InputMathOperation$InvertFunction",
      Predictions`Prediction[0.5, "solving", "invert function", HoldComplete[
        Reduce[$CellContext`y == ($CellContext`f[$CellContext`x + \
$CellContext`h] - $CellContext`f[$CellContext`x])/$CellContext`h, \
$CellContext`x]]& ], Predictions`InInput}, {
     "InputMathOperation$PlotFunction",
      Predictions`Prediction[0.5, "plotting", "plot function", HoldComplete[
        Manipulate[
         Plot[$CellContext`h^(-1) ((-$CellContext`x^2)/(1 -
            Cos[$CellContext`x]) + ($CellContext`h + $CellContext`x)^2/(1 -
            Cos[$CellContext`h + $CellContext`x])), {$CellContext`x, \
-2.2882456112707374452`3.,
           2.2882456112707374452`3.}], {$CellContext`h, \
-5.7071067811865479058`3., 5.7071067811865479058`3.}]]& ],
      Predictions`InInput}, {"InputMathOperation$Zeros",
      Predictions`Prediction[
      0.5, "analysis", "real zeros", Predictions`Private`ReleaseHolds[
        HoldComplete[
         Solve[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h == 0, {
           Hold[$CellContext`x]}, Reals]]]& ], Predictions`InInput}, {
     "InputMathOperation$StationaryPoints",
      Predictions`Prediction[
      0.5, "analysis", "stationary points", Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction[
         "StationaryPoints"][($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h,
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$Derivatives",
      Predictions`Prediction[0.5, "derivatives",
       Row[{"derivative wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        D[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$IndefiniteIntegrals",
      Predictions`Prediction[0.5, "integration",
       Row[{"indefinite integral wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        Integrate[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$DerivativeAtLimitPoint",
      Predictions`Prediction[0.5, "derivatives",
       Row[{"derivative at ",
         Pane[
          Style[
           HoldForm[$CellContext`h], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline], " = ",
         Pane[
          Style[
           HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        ReplaceAll[
         D[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, $CellContext`h], \
$CellContext`h -> 0]]& ], Predictions`InInput}, {"InputMathOperation$Series",
      Predictions`Prediction[0.5, "series",
       Row[{"series expansion at ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline], " = ",
         Pane[
          Style[
           HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        Series[($CellContext`f[$CellContext`x + $CellContext`h] - \
$CellContext`f[$CellContext`x])/$CellContext`h, {$CellContext`x, 0, 5}]]& ],
      Predictions`InInput}},
   "otherpredictions" -> {"StepByStep", "FullResults"}, "allassumptions" -> {},
    "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[3]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {43., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[5]:=",
 CellID->2029885181]

Verify.

is this equal to f'(x)
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "is this equal to f'(x)", "assumptions" -> {}, "parse" -> Defer[
     TrueQ[
      Simplify[Out[-1] == Derivative[1][$CellContext`f][$CellContext`x]]]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[2]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[6]:=",
 CellID->118336516]

Let us build up another chain of queries, starting with a challenge problem from the Math Olympiad competition. The problem states:

Math Olympiad

First, set up a definition that defines the sequence.

set a(n)=a(n-1)+a(n-2)+a(n-3)
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "set a(n)=a(n-1)+a(n-2)+a(n-3)", "assumptions" -> {}, "parse" ->
   Defer[$CellContext`a[
       Pattern[$CellContext`n,
        Blank[]]] := $CellContext`a[$CellContext`n -
        1] + $CellContext`a[$CellContext`n -
        2] + $CellContext`a[$CellContext`n - 3]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[4]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[68]:=",
 CellID->550316403]

Next, initialize the given values.

set a(1)=1, a(2)=2, a(3)=3
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "set a(1)=1, a(2)=2, a(3)=3", "assumptions" -> {}, "parse" ->
   Defer[$CellContext`a[1] = 1; $CellContext`a[2] = 2; $CellContext`a[3] = 3],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[69]:=",
 CellID->2143246125]

To make sure that Wolfram|Alpha Notebook Edition is interpreting everything in the expected way, try evaluating the next element in the sequence.

a(4)
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "a(4)", "assumptions" -> {}, "parse" -> Defer[
     $CellContext`a[4]], "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
    "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[3]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[1, Typeset`querydata$$, Typeset`update$$],
     StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association["HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[78]:=",
 CellID->2095238551]

You can also test your function to see if it matches your intuition, here adding together the given initial values for and , plus your computed value for .

does a[5] = 2+3+6
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "does a[5] = 2+3+6", "assumptions" -> {}, "parse" -> Defer[
     TrueQ[
      Simplify[$CellContext`a[5] == 2 + 3 + 6]]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[5]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[77]:=",
 CellID->1776498819]

Finally, evaluate the sum to answer the initial question.

sum a(i) from i = 1 to 25
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "sum a(i) from i = 1 to 25", "assumptions" -> {}, "parse" -> Defer[
     Sum[
      $CellContext`a[$CellContext`i], {$CellContext`i, 1, 25}]],
   "inputpredictions" -> {{"InputMathOperation$ExtractFunction",
      Predictions`Prediction[
      0.99, "structural operations", "extract function", Apply[HoldComplete,
        Hold[
         $CellContext`a[$CellContext`i]]]& ], Predictions`InInput}, {
     "InputMathOperation$TestConvergence",
      Predictions`Prediction[
      0.54, "sums and products", "test for convergence", HoldComplete[
        SumConvergence[
         $CellContext`a[$CellContext`i], $CellContext`i]]& ],
      Predictions`InInput}, {"InputMathOperation$SumAbsoluteValues",
      Predictions`Prediction[
      0.52, "sums and products", "sum absolute values", HoldComplete[
        Sum[
         Abs[
          $CellContext`a[$CellContext`i]], {$CellContext`i, 1, 25}]]& ],
      Predictions`InInput}, {"InputMathOperation$TableOfSummands",
      Predictions`Prediction[0.51, "sums and products", "", {{
         Row[{"list of first ",
           Pane[
            Style[
             HoldForm[6], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " ",
           Pane[
            Style[
             HoldForm["summands"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          Table[
           $CellContext`a[$CellContext`i], {$CellContext`i, 1, 6}]]& }, {
         Row[{"table of first ",
           Pane[
            Style[
             HoldForm[6], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " ",
           Pane[
            Style[
             HoldForm["summands"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          Grid[
           Prepend[
            Table[{$CellContext`i,
              $CellContext`a[$CellContext`i]}, {$CellContext`i, 1, 6}], {
             HoldForm[$CellContext`i],
             HoldForm[
              $CellContext`a[$CellContext`i]]}],
           Dividers -> {2 -> True, 2 -> True}]]& }, {
         Row[{"plot of first ",
           Pane[
            Style[
             HoldForm[6], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " ",
           Pane[
            Style[
             HoldForm["summands"], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          ListPlot[
           Table[
            $CellContext`a[$CellContext`i], {$CellContext`i, 1, 6}], PlotRange ->
           All]]& }}], Predictions`InInput}, {
     "InputMathOperation$DiscreteLimitOfSum",
      Predictions`Prediction[0.5, "limits",
       Row[{"discrete limit as ",
         Pane[
          Style[
           HoldForm[$CellContext`i], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline],
         "->\[Infinity]"}], HoldComplete[
        DiscreteLimit[
         $CellContext`a[$CellContext`i], $CellContext`i -> Infinity]]& ],
      Predictions`InInput}, {"InputMathOperation$LimitOfSum",
      Predictions`Prediction[0.49, "limits",
       Row[{"limit as ",
         Pane[
          Style[
           HoldForm[$CellContext`i], LineBreakWithin -> False],
          ImageSize -> {150}, BaselinePosition -> Baseline], "->",
         Pane[
          Style[
           HoldForm[25], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        Limit[
         $CellContext`a[$CellContext`i], $CellContext`i -> 25]]& ],
      Predictions`InInput}, {"InputMathOperation$SwapSumAndProduct",
      Predictions`Prediction[
      0.48, "sums and products", "product of summands", HoldComplete[
        Product[
         $CellContext`a[$CellContext`i], {$CellContext`i, 1, 25}]]& ],
      Predictions`InInput}, {"InputMathOperation$ChangeUpperBound",
      Predictions`Prediction[0.47, "sums and products", "", {{
         Row[{"increase upper bound to ",
           Pane[
            Style[
             HoldForm[50], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Sum[
           $CellContext`a[$CellContext`i], {$CellContext`i, 1, 50}]]& }, {
         Row[{"decrease upper bound to ",
           Pane[
            Style[
             HoldForm[12], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Sum[
           $CellContext`a[$CellContext`i], {$CellContext`i, 1, 12}]]& }}],
      Predictions`InInput}}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {43., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[65]:=",
 CellID->1495082103]

These are the same steps that a computer science student might take to solve such a problem, but no computer language or coding was required. Only simple natural language statements were used to set up, test and solve the desired problem.

One of the aspects of Wolfram|Alpha Notebook Edition that has been greatly expanded over the past year is the use of resource functions that are developed and submitted by staff members. Similar to what Bob expressed in his recent blog post, we are also fans of the Wolfram Function Repository and have been hard at work making useful tools more accessible. These functions, while submitted by internal staff, go through the exact same review process as that of externally submitted resource functions, and are all publicly accessible via the Function Repository. With the release of Wolfram|Alpha Notebook Edition, the challenge arose of concisely representing the many highly specific kinds of computations that are available through the many pods returned for an input in Wolfram|Alpha.

For example, a topic frequently covered in calculus classes is calculating the arc length of a curve, say given some bounds. This is easily done in the Wolfram Language by running the following:

ArcLength
&#10005

ArcLength[x^2, {x, 0, 1}]

This acts as a bit of a black box to students who may be asked to set up an integral and then evaluate it. Through the use of resource functions, Wolfram|Alpha Notebook Edition is able to do this exactly.

arc length of x^2 for 0<x<1
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "arc length of x^2 for 0 {}", "parse" -> Defer[
     ResourceFunction["ArcLengthIntegral"][$CellContext`x^2, {$CellContext`x, 0, 1}]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[6]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[1, Typeset`querydata$$, Typeset`update$$],
     StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association["HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[5]:=",
 CellID->1121786887]

evaluate that
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "evaluate that", "assumptions" -> {}, "parse" -> Defer[
     Integrate[
      Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x, 0, 1}]],
   "inputpredictions" -> {{
     "InputMathOperation$PlotFunctionWithIntegralDefinite",
      Predictions`Prediction[
      0.99, "plotting", "plot function and integral", HoldComplete[
        Plot[{(1 + 4 $CellContext`x^2)^
          Rational[
           1, 2], (Rational[1, 2] $CellContext`x) (1 + 4 $CellContext`x^2)^
            Rational[1, 2] +
          Rational[1, 4] ArcSinh[2 $CellContext`x]}, {$CellContext`x, 0, 1},
         PlotLegends -> {"f", "\[Integral]f"}]]& ], Predictions`InInput}, {
     "InputMathOperation$PlotOverIntegralRange",
      Predictions`Prediction[
      0.98, "plotting", "plot function over integral range", HoldComplete[
        Plot[
         Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x, 0, 1}]]& ],
      Predictions`InInput}, {"InputMathOperation$IndefiniteIntegrals",
      Predictions`Prediction[0.97, "integration",
       Row[{"indefinite integral wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        Integrate[
         Sqrt[1 + 4 $CellContext`x^2], $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$Derivatives",
      Predictions`Prediction[0.96, "derivatives",
       Row[{"derivative wrt ",
         Pane[
          Style[
           HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[
        D[
         Sqrt[1 + 4 $CellContext`x^2], $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$ExtractFunction",
      Predictions`Prediction[
      0.95, "structural operations", "extract function", Apply[HoldComplete,
        Hold[
         Sqrt[1 + 4 $CellContext`x^2]]]& ], Predictions`InInput}, {
     "InputMathOperation$FunctionDomain",
      Predictions`Prediction[
      0.9299999999999999, "properties", "", {{"function domain", HoldComplete[
          FunctionDomain[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x}]]& }, {
        "function range", HoldComplete[
          FunctionRange[
           Sqrt[
           1 + 4 $CellContext`x^2], {$CellContext`x}, {$CellContext`y}]]& }}],
      Predictions`InInput}, {"InputMathOperation$Discontinuities",
      Predictions`Prediction[
      0.5, "analysis", "discontinuities", Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction["FunctionDiscontinuities"][
          Sqrt[1 + 4 $CellContext`x^2],
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$InflectionPoints",
      Predictions`Prediction[
      0.5, "analysis", "inflection points", Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction["InflectionPoints"][
          Sqrt[1 + 4 $CellContext`x^2],
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$IntegralToInfinity",
      Predictions`Prediction[
      0.5, "integration",
       "", {{"integral from 0 to \[Infinity]", HoldComplete[
          Integrate[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x, 0,
            DirectedInfinity[1]}]]& }, {
        "integral from -\[Infinity] to 0", HoldComplete[
          Integrate[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x,
            DirectedInfinity[-1], 0}]]& }}], Predictions`InInput}, {
     "InputMathOperation$InvertFunction",
      Predictions`Prediction[0.5, "solving", "invert function", HoldComplete[
        Reduce[$CellContext`y ==
         Sqrt[1 + 4 $CellContext`x^2], $CellContext`x]]& ],
      Predictions`InInput}, {"InputMathOperation$PlotFunction",
      Predictions`Prediction[0.5, "plotting", "plot function", HoldComplete[
        Plot[(1 + 4 $CellContext`x^2)^
         Rational[1, 2], {$CellContext`x, -16.9866666666666681351`3.,
          16.9866666666666681351`3.}]]& ], Predictions`InInput}, {
     "InputMathOperation$Zeros",
      Predictions`Prediction[
      0.5, "analysis", "real zeros", Predictions`Private`ReleaseHolds[
        HoldComplete[
         Solve[Sqrt[1 + 4 $CellContext`x^2] == 0, {
           Hold[$CellContext`x]}, Reals]]]& ], Predictions`InInput}, {
     "InputMathOperation$StationaryPoints",
      Predictions`Prediction[
      0.5, "analysis", "stationary points", Predictions`Private`ReleaseHolds[
        HoldComplete[
         ResourceFunction["StationaryPoints"][
          Sqrt[1 + 4 $CellContext`x^2],
          Hold[$CellContext`x]]]]& ], Predictions`InInput}, {
     "InputMathOperation$AlternativePowers",
      Predictions`Prediction[
      0.5, "algebra", "", {{"substitute square for power", HoldComplete[
          Integrate[(1 + 4 $CellContext`x^2)^2, {$CellContext`x, 0, 1}]]& }, {
        "substitute square root for power", HoldComplete[
          Integrate[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x, 0, 1}]]& }, {
        "substitute cube root for power", HoldComplete[

          Integrate[(1 + 4 $CellContext`x^2)^(1/3), {$CellContext`x, 0,
            1}]]& }}], Predictions`InInput}, {
     "InputMathOperation$IntegralAverage",
      Predictions`Prediction[0.5, "integration",
       Row[{"average value of function on ",
         Pane[
          Style[
           HoldForm["[0, 1]"], LineBreakWithin -> False], ImageSize -> {150},
          BaselinePosition -> Baseline]}], HoldComplete[Integrate[
          Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x, 0, 1}]/(1 + 0)]& ],
      Predictions`InInput}, {"InputMathOperation$EvaluateIntegrandAtLimits",
      Predictions`Prediction[0.5, "integration", "", {{
         Row[{"evaluate integrand at ",
           Pane[
            Style[
             HoldForm["x = 0"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          ReplaceAll[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x -> 0}]]& }, {
         Row[{"evaluate integrand at ",
           Pane[
            Style[
             HoldForm["x = 1"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          ReplaceAll[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x -> 1}]]& }}],
      Predictions`InInput}, {"InputMathOperation$Limits",
      Predictions`Prediction[0.5, "limits", "", {{
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Limit[
           Sqrt[1 + 4 $CellContext`x^2], $CellContext`x -> 0]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              DirectedInfinity[-1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          Limit[
           Sqrt[1 + 4 $CellContext`x^2], $CellContext`x ->
           DirectedInfinity[-1]]]& }, {
         Row[{"limit at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              DirectedInfinity[1]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          Limit[
           Sqrt[1 + 4 $CellContext`x^2], $CellContext`x ->
           DirectedInfinity[1]]]& }}], Predictions`InInput}, {
     "InputMathOperation$Series",
      Predictions`Prediction[0.5, "series", "", {{
         Row[{"series expansion at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[0], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Series[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x, 0, 5}]]& }, {
         Row[{"series expansion at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              Complex[0,
               Rational[-1, 2]]], LineBreakWithin -> False],
            ImageSize -> {150}, BaselinePosition -> Baseline]}], HoldComplete[
          Series[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x,
            Complex[0,
             Rational[-1, 2]], 5}]]& }, {
         Row[{"series expansion at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[
              Complex[0,
               Rational[1, 2]]], LineBreakWithin -> False], ImageSize -> {150},
             BaselinePosition -> Baseline]}], HoldComplete[
          Series[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x,
            Complex[0,
             Rational[1, 2]], 5}]]& }, {
         Row[{"series expansion at ",
           Pane[
            Style[
             HoldForm["x"], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline], " = ",
           Pane[
            Style[
             HoldForm[1], LineBreakWithin -> False], ImageSize -> {150},
            BaselinePosition -> Baseline]}], HoldComplete[
          Series[
           Sqrt[1 + 4 $CellContext`x^2], {$CellContext`x, 1, 5}]]& }}],
      Predictions`InInput}},
   "otherpredictions" -> {"StepByStep", "FullResults"}, "allassumptions" -> {},
    "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {43., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[27]:=",
 CellID->398998877]

While this may seem like a number of extra steps, it fills a pedagogical role in granting students the ability to, in some way, peek under the hood of math that otherwise is so efficiently done with built-in functions.

The use of resource functions in Wolfram|Alpha Notebook Edition also eases the transition into learning Wolfram Language syntax that might be a stumbling block for students and educators new to Wolfram technologies. One example of this is the setup of an interactive plot to visualize the scaling and translation of a function as you vary parameters—something not possible on the web at this time.

b + Sin[a*x]
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "plot b+Sin[a x] varying a and b from 0 to 2", "assumptions" -> {}, "parse" ->
   Defer[
     ResourceFunction[
     "ManipulatePlot"][$CellContext`b +
      Sin[$CellContext`a $CellContext`x], {$CellContext`x, -5.4,
       5.4}, {{$CellContext`a, 1}, 0, 2}, {{$CellContext`b, 1}, 0, 2}]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[20]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[1, Typeset`querydata$$, Typeset`update$$],
     StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association["HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[1]:=",
 CellID->923091347]

Seeing the Wolfram Language interpretation of this input introduces users to the syntax of this ManipulatePlot function so they might be able to build up something more complicated themselves, and also introduces them to Wolfram Language syntax proper. This highlights one of the key elements of the development of resource functions for use in Wolfram|Alpha Notebook Edition: creating highly functional code that does specific tasks that might not fit within the overall Wolfram Language. Such functions provide easy access points to high-level content that is particularly useful in the education world. Another key question in this development process is how to represent all of the information that is accessible from a single input to Wolfram|Alpha. Consider the information accessible from a simple input “sin(x)”. There are resource functions (and corresponding Wolfram|Alpha Notebook Edition inputs) like the following, which not only produce similar information, but can also present it in interactive ways to build intuition and understanding.

function overview Sin[x]
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "function overview Sin[x]", "assumptions" -> {}, "parse" ->
   Defer[
     ResourceFunction["FunctionOverview"][
      Sin[$CellContext`x], $CellContext`x, Reals, Dataset]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[3]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[2]:=",
 CellID->169532030]

curve analysis sin[x]
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "curve analysis sin[x]", "assumptions" -> {}, "parse" -> Defer[
     ResourceFunction["CurveAnalysis"][
      Sin[$CellContext`x], $CellContext`x]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[7]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[1]:=",
 CellID->188415816]

As seen here, through the use of high-level resource functions, Wolfram|Alpha Notebook Edition is able to serve content similar to Wolfram|Alpha, but reformatted and restructured for the desktop environment.

Our implementation of the Wolfram Function Repository functions goes beyond purely mathematical exploits. Here, we can generate an image.

image of a cat
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "image of a cat", "assumptions" -> {}, "parse" -> Defer[
     Entity["Species", "Species:FelisCatus"][
      EntityProperty["Species", "Image"]]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "Clash", "word" -> "cat", "template" ->
         "Assuming \"${word}\" is ${desc1}. Use as ${desc2} instead", "count" ->
         "2"}, {
         XMLElement[
         "value", {
          "name" -> "Species", "desc" -> "a species specification", "input" ->
           "*C.cat-_*Species-"}, {}],
         XMLElement[
         "value", {
          "name" -> "CatBreedClass", "desc" -> " referring to cat breeds",
           "input" -> "*C.cat-_*CatBreedClass-"}, {}]}]}]},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[6]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {79., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[11]:=",
 CellID->1402703484]

We can then perform some image processing analysis by interpreting the image in various ways.

dog vision of that
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "dog vision of that", "assumptions" -> {}, "parse" -> Defer[
     ResourceFunction["SimulateAnimalVision"]["Dog",
      Out[-1]]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[4]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[12]:=",
 CellID->2117594833]

Of course, the opposite is possible as well.

cat vision of dog image
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "cat vision of a dog image", "assumptions" -> {}, "parse" -> Defer[
     ResourceFunction["SimulateAnimalVision"]["Cat",
      Entity["Species", "Infraspecies:CanisLupusFamiliaris"][
       EntityProperty["Species", "Image"]]]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[1, Typeset`querydata$$, Typeset`update$$],
     StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association["HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[42]:=",
 CellID->1107810711]

There are many other popular Wolfram|Alpha domains that are now directly supported in Wolfram|Alpha Notebook Edition.

orbit of halley's comet
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "orbit of halley's comet", "assumptions" -> {}, "parse" -> Defer[
     WolframAlphaResult[
     "orbit of halley's comet", {{"SolarSystemConfiguration:CometData", 1}, "Content"},
      InputAssumptions -> {}]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "MultiClash", "word" -> "", "template" ->
         "Assuming ${word1} is referring to ${desc1}. Use \"${word2}\" as ${desc2}. Use \
\"${word3}\" as ${desc3}.", "count" -> "3"}, {
         XMLElement[
         "value", {"name" -> "CometPropertyClass", "word" -> "orbit", "desc" ->
           "orbital properties of a comet", "input" ->
           "*MC.%7E-_*CometPropertyClass-"}, {}],
         XMLElement[
         "value", {"name" -> "CometProperty", "word" -> "orbit", "desc" ->
           "orbit circumference of a comet", "input" -> "*MC.%7E-_*CometProperty-"}, {}],
         XMLElement[
         "value", {"name" -> "Formula", "word" -> "", "desc" -> "a formula", "input" ->
           "*MC.%7E-_*Formula-"}, {}]}]}]}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[9]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[1, Typeset`querydata$$, Typeset`update$$],
     StandardForm],
   ImageSizeCache->{530., {87., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association["HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[1]:=",
 CellID->1602796222]

Polaris sky chart from Seattle on 9/13/2020
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "Polaris sky chart from Seattle on 9/13/2020", "assumptions" -> {}, "parse" ->
   Defer[
     ResourceFunction["SkyChart"][
      Entity["Star", "Polaris"],
      Entity["City", {"Seattle", "Washington", "UnitedStates"}]["Position"],
      DateObject[{2020, 9, 13}]]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "MultiClash", "word" -> "", "template" ->
         "Assuming ${word1} is referring to ${desc1}. Use \"${word2}\" as ${desc2}.",
         "count" -> "2"}, {
         XMLElement[
         "value", {"name" -> "TimeSeriesPhrase", "word" -> "chart", "desc" ->
           " referring to a calendar computation", "input" ->
           "*MC.sky+chart-_*TimeSeriesPhrase-"}, {}],
         XMLElement[
         "value", {"name" -> "StarPropertyClass", "word" -> "sky chart", "desc" ->
           "sky chart of a star", "input" ->
           "*MC.sky+chart-_*StarPropertyClass-"}, {}]}]}]}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[14]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[1, Typeset`querydata$$, Typeset`update$$],
     StandardForm],
   ImageSizeCache->{530., {87., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association["HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[28]:=",
 CellID->1583322521]

play sin(x*Floor(100x^2)) for 5 seconds
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "play sin(x*Floor(100x^2)) for 5 seconds", "assumptions" -> {},
   "parse" -> Defer[
     Play[
      Sin[$CellContext`x Floor[100 $CellContext`x^2]], {$CellContext`x,
       0.3203475194016502, 5.3203475194016505`}, SampleRate -> 44100]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[3]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[23]:=",
 CellID->287802117]

plot eternatus curve
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "plot eternatus curve", "assumptions" -> {}, "parse" -> Defer[
     Entity["PopularCurve", "EternatusCurve"][
      EntityProperty["PopularCurve", "Plot"]]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[25]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellChangeTimes->{{3.8067485702832212`*^9, 3.8067485706277514`*^9}},
 CellLabel->"In[28]:=",
 CellID->1441622532]

make the background pink
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "make the background pink", "assumptions" -> {}, "parse" ->
   Defer[
     Show[
      Out[-1], Background -> Pink]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "SubCategory", "word" -> "pink", "template" ->
         "Assuming ${desc1}. Use ${desc2} instead", "count" -> "2"}, {
         XMLElement[
         "value", {
          "name" -> "{WolframLanguage, Pink}", "desc" -> "basic pink", "input" ->
           "*DPClash.ColorE.pink-_**WolframLanguage.Pink--"}, {}],
         XMLElement[
         "value", {
          "name" -> "{HTML, Pink}", "desc" -> "HTML pink", "input" ->
           "*DPClash.ColorE.pink-_**HTML.Pink--"}, {}]}]}]},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {79., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[29]:=",
 CellID->1665329757]

One of the major new content areas that we’ve added support for in Wolfram|Alpha Notebook Edition is chemistry. How does the Wolfram|Alpha chemistry team prioritize which chemistry problems to support? We try to maximize the breadth of support while focusing on topics that are encountered in middle-school, high-school and college chemistry courses. Currently, we are working our way toward buffer problems by building up the prerequisite topics of solution preparation:

Prepare a 0.02 M KOH solution
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "Prepare a 0.02 M KOH solution", "assumptions" -> {}, "parse" ->
   Defer[
     WolframAlphaResult[
     "Prepare a 0.02 M KOH solution", {{"Result", 1}, "Content"},
      InputAssumptions -> {}]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[3]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[12]:=",
 CellID->1597933442]

… chemical equation balancing:

Balance Oxalic acid
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" ->
   "Balance Oxalic acid (s) + water (l) -> hydronium ion (aq) + oxalate ion \
(aq)", "assumptions" -> {}, "parse" -> Defer[
     WolframAlphaResult[
     "Balance Oxalic acid (s) + water (l) -> hydronium ion (aq) + oxalate ion \
(aq)", {{"BalancedEquationPod:ChemicalReactionData", 1}, "Content"},
      InputAssumptions -> {}]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[2]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[17]:=",
 CellID->2100650035]

… and construction of the equilibrium constant expression:

equilibrium constant acetic acid
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" ->
   "equilibrium constant acetic acid (l) + water (l) -> hydronium ion (aq) + \
acetate ion (aq)", "assumptions" -> {}, "parse" -> Defer[
     WolframAlphaResult[
     "equilibrium constant acetic acid (l) + water (l) -> hydronium ion (aq) + \
acetate ion (aq)", {{"ReactionKineticsConstant:ChemicalReactionData", 1},
       "Content"}, InputAssumptions -> {}]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "SubCategory", "word" -> "acetate ion", "template" ->
         "Assuming ${desc1}. Use ${desc2} instead", "count" -> "2"}, {
         XMLElement[
         "value", {
          "name" -> "IonAcetate", "desc" -> "acetate anion", "input" ->
           "*DPClash.ChemicalIntermediateE.acetate+ion-_*IonAcetate-"}, {}],
         XMLElement[
         "value", {
          "name" -> "IonCyanide", "desc" -> "cyanide anion", "input" ->
           "*DPClash.ChemicalIntermediateE.acetate+ion-_*IonCyanide-"}, \
{}]}]}]}, "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
    "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[2]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {88., 30.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[18]:=",
 CellID->1455453525]

You can also see the step-by-step procedure of computing the previous chemistry results. We’ve also added support for the chemical capabilities newly added to the Wolfram Language in Version 12.

caffeine
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "caffeine", "assumptions" -> {}, "parse" -> Defer[
     Entity["Chemical", "Caffeine"]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "Clash", "word" -> "caffeine", "template" ->
         "Assuming \"${word}\" is ${desc1}. Use as ${desc2} instead", "count" ->
         "4"}, {
         XMLElement[
         "value", {
          "name" -> "Chemical", "desc" -> "a chemical compound", "input" ->
           "*C.caffeine-_*Chemical-"}, {}],
         XMLElement[
         "value", {
          "name" -> "Molecule", "desc" -> " referring to molecule", "input" ->
           "*C.caffeine-_*Molecule-"}, {}],
         XMLElement[
         "value", {
          "name" -> "Word", "desc" -> "a word", "input" ->
           "*C.caffeine-_*Word-"}, {}],
         XMLElement[
         "value", {
          "name" -> "Movie", "desc" -> "a movie", "input" ->
           "*C.caffeine-_*Movie-"}, {}]}]}]}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[10]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {87., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[5]:=",
 CellID->536225153]

molecule of that
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "molecule of that", "assumptions" -> {}, "parse" -> Defer[
     Molecule[
      Out[-1]]], "inputpredictions" -> {},
   "otherpredictions" -> {"FullResults"}, "allassumptions" -> {},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[7]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[6]:=",
 CellID->352448835]

We are still building the kinds of chemical properties that work via session referencing, but many properties already work as a single-line input. These and more will be working via session referencing as well in the coming weeks.

(2R)-2-acetamido-3-methylbutanoic acid mesh region
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "(2R)-2-acetamido-3-methylbutanoic acid mesh region",
   "assumptions" -> {}, "parse" -> Defer[
     ResourceFunction["MoleculeMeshRegion"][
      Molecule["(2R)-2-acetamido-3-methylbutanoic acid"]]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[7]:=",
 CellID->4107428]

(2R)-2-acetamido-3-methylbutanoic acid principal moments of inertia
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" ->
   "(2R)-2-acetamido-3-methylbutanoic acid principal moments of inertia",
   "assumptions" -> {}, "parse" -> Defer[
     MoleculeValue[
      Molecule["(2R)-2-acetamido-3-methylbutanoic acid"], "PrincipalMoments"]],
    "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[8]:=",
 CellID->286397275]

Another tool in the Wolfram family that we have been able to add support for in Wolfram|Alpha Notebook Edition that is unavailable on the Wolfram|Alpha website is the Wolfram Demonstrations Project. In Wolfram|Alpha Notebook Edition, you can ask for a specific Demonstration by name. Clicking the entity blob will return the fully interactive Demonstration in a new window.

Mondrian Four-Coloring demonstration
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "Mondrian Four-Coloring demonstration", "assumptions" -> {},
   "parse" -> Defer[
     Entity["WolframDemonstration", "MondrianFourColoring"]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[3]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {41., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[21]:=",
 CellID->287512350]

Mondrian Four-Coloring

You can also search Demonstrations by category if you are looking for a particular topic to, for instance, show off to your classroom. First, enter a query for Demonstrations of a particular category.

Derivatives demonstrations
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "Derivatives demonstrations ", "assumptions" -> {}, "parse" ->
   Defer[
     EntityClass["WolframDemonstration", "Derivatives"]],
   "inputpredictions" -> {}, "otherpredictions" -> {"FullResults"},
   "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "MultiClash", "word" -> "", "template" ->
         "Assuming ${word1} is referring to ${desc1}. Use as ${desc2} instead. \
Use \"${word3}\" as ${desc3}.", "count" -> "3"}, {
         XMLElement[
         "value", {
          "name" -> "WolframDemonstrationClass", "word" -> "the input", "desc" ->
           " referring to wolfram demonstration data", "input" ->
           "*MC.%7E-_*WolframDemonstrationClass-"}, {}],
         XMLElement[
         "value", {
          "name" -> "WordData", "word" -> "the input", "desc" ->
           " referring to English words", "input" ->
           "*MC.%7E-_*WordData-"}, {}],
         XMLElement[
         "value", {
          "name" -> "MathWorld", "word" -> "Derivatives", "desc" ->
           " referring to a mathematical definition", "input" ->
           "*MC.%7E-_*MathWorld-"}, {}]}]}]}, "summarizeassumptions" ->
   FrontEnd`SuppressEvaluationHash[Automatic], "summarizepredictions" ->
   FrontEnd`SuppressEvaluationHash[True]], Typeset`update$$ =
  FrontEnd`SuppressEvaluationHash[6]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {87., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[9]:=",
 CellID->462304110]

The first item on the generated Suggestions Bar should be “entity list.” Click that to see the full EntityList of Demonstrations from that category.

EntityList
&#10005

EntityList[EntityClass["WolframDemonstration", "Derivatives"]]

Beyond the Demonstrations, there are more ways to use Wolfram|Alpha Notebook Edition as a learning tool. Entering in a generic topic will, just as with the Wolfram|Alpha website, return a page with examples. This similarly pops up in a new notebook, pre-filled with sample natural language inputs in the domain that you were asking about.

differential equations
&#10005


Cell[BoxData[
 DynamicModuleBox[{Typeset`querydata$$ = Association[
  "query" -> "differential equations", "assumptions" -> {}, "parse" ->
   XMLElement[
    "examplepage", {
     "category" -> "DifferentialEquations", "url" ->
      "https://www.current.wolframalpha.com/examples/DifferentialEquations-\
content.html"}, {}], "inputpredictions" -> {}, "otherpredictions" -> {},
   "allassumptions" -> {
     XMLElement["assumptions", {"count" -> "1"}, {
       XMLElement[
       "assumption", {
        "type" -> "Clash", "word" -> "differential equations", "template" ->
         "Assuming \"${word}\" is ${desc1}. Use as ${desc2} instead", "count" ->
         "4"}, {
         XMLElement[
         "value", {
          "name" -> "ExamplePage", "desc" -> "a general topic", "input" ->
           "*C.differential+equations-_*ExamplePage-"}, {}],
         XMLElement[
         "value", {
          "name" -> "Calculator", "desc" -> "a computation", "input" ->
           "*C.differential+equations-_*Calculator-"}, {}],
         XMLElement[
         "value", {
          "name" -> "MathWorld", "desc" ->
           " referring to a mathematical definition", "input" ->
           "*C.differential+equations-_*MathWorld-"}, {}],
         XMLElement[
         "value", {
          "name" -> "Periodical", "desc" -> "a periodical", "input" ->
           "*C.differential+equations-_*Periodical-"}, {}]}]}]},
   "summarizeassumptions" -> FrontEnd`SuppressEvaluationHash[Automatic],
   "summarizepredictions" -> FrontEnd`SuppressEvaluationHash[True]],
  Typeset`update$$ = FrontEnd`SuppressEvaluationHash[1]},
  DynamicBox[ToBoxes[
    AlphaIntegration`NaturalLanguageInputBoxes[
    1, Typeset`querydata$$, Typeset`update$$], StandardForm],
   ImageSizeCache->{530., {87., 21.}},
   TrackedSymbols:>{}],
  BaseStyle->{Deployed -> True},
  DynamicModuleValues:>{}]], "DeployedNLInput",
 PrivateCellOptions->{
 "CellSettings"->Association[
  "HideDetails" -> FrontEnd`SuppressEvaluationHash[False]]},
 CellLabel->"In[61]:=",
 CellID->86442253]

Differential equations notebook

This will encourage further exploration, as you will still see the same input and output suggestions as you would with your own inputs. And speaking of example pages, a new project we’re working on that will be particularly useful for educators in the US is curated examples pages catered to the US Common Core Math Standards. An example of what that will look like follows, and we are planning on releasing pages for all the US standards in the coming months.

US Common Core Math Standards

Perhaps our latest and most exciting addition to the world of Wolfram|Alpha Notebook Edition is the migration of our Wolfram|Alpha notebook capabilities to the Wolfram Cloud. Now you can do all kinds of computational exploration from your browser. To access this feature, navigate to File > New > Wolfram|Alpha-Mode Notebook. You should see the familiar natural language input box, and you can now enter the same kinds of queries, view input and output suggestions and even interact with our Demonstrations and built-in Function Repository functions!

We are proud of the progress we have made in the last year, and we are especially encouraged by the number of people trying Wolfram|Alpha Notebook Edition and the kinds of computations that they are using it for. We hope it will continue to be a useful tool for students, educators, parents, independent researchers and enthusiasts. Please let us know what else you’d like to see in Wolfram|Alpha Notebook Edition!

Also keep an eye out for upcoming book releases from Wolfram Media:

  • Click here to receive updates about the third edition of Hands-on Start to Wolfram Mathematica and Programming with the Wolfram Language.
  • Click here to receive updates about Hands-on Start to Wolfram|Alpha Notebook Edition.
Want to give it a try? Sign up for a trial of Wolfram|Alpha Notebook Edition.
Engage with the code in this post by downloading the Wolfram Notebook
]]> https://blog.wolfram.com:443/2020/09/11/wolframalpha-notebook-edition-turns-one-now-with-support-for-chemistry-demonstrations-and-more/feed/ 0 Wolfram Community Takes on Current Events: COVID-19 Data, Green Spaces, Homeschool Puzzles and More https://blog.wolfram.com:443/2020/09/04/wolfram-community-takes-on-current-events-covid-19-data-green-spaces-homeschool-puzzles-and-more/ https://blog.wolfram.com:443/2020/09/04/wolfram-community-takes-on-current-events-covid-19-data-green-spaces-homeschool-puzzles-and-more/#comments Fri, 04 Sep 2020 14:46:58 +0000 Mads Bahrami https://blog.internal.wolfram.com/?p=68362 Wolfram Community Takes on Current Events: COVID-19 Data, Green Spaces, Homeschool Puzzles and More

This roundup of Wolfram Community contributions features several different functions and tools related to current times, from the global pandemic to sustainable spaces and homeschool puzzles. Read on to see just a few creative examples from some of our favorite Community members and Wolfram Language wizzes.

Epidemiological Models for Influenza and COVID-19

Robert Nachbar

Epidemiological Models for Influenza and COVID-19

Robert Nachbar takes an in-depth look at how compartmental models of epidemiology can be used to study the spread of a contagious disease. He has provided a very detailed pedagogical approach, starting from a simple influenza example and then extending it to the COVID-19 outbreak. This post also has a follow-up, Stochastic Epidemiology Models with Applications to COVID-19, to include the inherent randomness of events into the modeling.

For more coronavirus resources and updates, visit this collection of contributions.

Fun with Perspective Anamorphism: A Coke Can, a Coffee Cup and Lady Liberty

Erik Mahieu

Using a few different functions, Erik Mahieu explains the popular art concept of perspective anamorphism and has some fun with examples featuring—you guessed it—a Coke can, a coffee mug and the Statue of Liberty. We also get an interesting history lesson on World War I–era “living photographs” made by Arthur Mole, who used thousands of people to recreate various images.

Visualizing the Unified Geologic Map of the Moon from the USGS

Jeff Bryant

Visualizing the Unified Geologic Map of the Moon from the USGS

Jeff Bryant discusses how to import the newly published data on lunar geology from the United States Geological Survey (USGS) and combine it with the GeoGraphics functionality in the Wolfram Language. This labeled data mainly covers geological ages for the Moon, and Jeff explains how to project this data onto a sphere to construct a 3D texture map of the Moon. He then discusses how this sphere can be moved around the equator to create an animation that can be directly embedded in a Wolfram Notebook.

How Black Holes and Accretion Disks around Them Actually Look

Jingxian Wang

How Black Holes and Accretion Disks around Them Actually Look

You may have seen the weird shape of the black hole Gargantua and its accretion disk in the movie Interstellar (shown in the first of the two previous images). But does the film really get the science right? Jingxian Wang discusses this issue and shows that movie creators only got the outline of the accretion disk right (which can be considered good science for a Hollywood movie). He tried to render an accretion disk around a Schwarzschild black hole and generated the corresponding shapes (shown in the second of the two images).

Population Density Map

Mads Bahrami

Population Density Map

This entry discusses how to create a population density map with a desired shape and size of grid tile for any country using publicly accessible datasets and the Wolfram Language. The code proves useful in studying the spread of disease, such as COVID-19, and can be generated using small datasets (like Qatar, shown here) or larger datasets from the Humanitarian Data Exchange (HDX).

GreenUP Green Space Detector

Jessica Shi, Anwesha Das, Aranyo Ray and Claire Morton

GreenUP Green Space Detector

Wolfram Summer Camp participant Jessica Shi shares a project that she and her teammates created using the Wolfram Language to map and grade green spaces in local communities. This tool was built by four then-high-school students from the US and India and entered earlier this year in the sustainability-themed Hack the Helyx Hackathon. The students were able to expand their project into an interactive website where you can check out the green space in your own area.

Elliptic Curve Integrated Encryption Scheme

Dariia Porechna

Join Dariia Porechna and cryptography favorites Alice and Bob in exploring a hybrid encryption scheme based on the idea of combining asymmetric elliptic curve security with symmetric encryption. By using the Wolfram Language, Dariia explains how two parties can compute the same secret key without having to ever share or expose it to unprotected channels of communication.

Cryptograms for Homeschoolers

Todd Rowland

Cryptograms for Homeschoolers

A great tool for teachers and students alike, these cryptograms can be created with and without the answers immediately revealed. Todd Rowland gives examples of different types of cipher-based puzzles and how they can be generated and solved using the Wolfram Language. Check out his code for customizable puzzle learning or as preparation for entering the world of programming!

3D Modeling of the SARS-CoV-2 Virus in the Wolfram Language

Jeff Bryant

3D Modeling of the SARS-CoV-2 Virus in the Wolfram Language

In a different but interesting look at the current pandemic, Jeff Bryant explains that although SARS-CoV-2 (severe acute respiratory syndrome coronavirus 2) is tiny, modeling the virus from its constituent molecules is a task that can be tackled. Jeff shows us step by step how to model the virus in various ways, including as a 3D cross-section and sample with color-coded internal structures.

The Cuckoo’s Egg and the Cosmological Theorem

Henry Jaspars

The Cuckoo’s Egg and the Cosmological Theorem

In a tribute to the late English mathematician John Horton Conway, contributor Henry Jaspars walks us through a colorful representation of the audioactive (or Cuckoo’s Egg) sequence using a numerical riddle. The entry continues with Conway’s constant and cosmological theorem, which is the idea that long sequences, called elements, will decompose into other elements.

TraCOV: Personalized COVID-19 Risk Analysis Tool

Jessica Shi, Anwesha Das, Aranyo Ray and Claire Morton

TraCOV: Personalized COVID-19 Risk Analysis Tool

This team of high-school students designed, coded and presented the TraCOV tool in an impressive 24 hours. Using the Wolfram Language, they created a web application that individuals can use to measure their risk levels of contracting coronavirus. The tool takes into account factors like age, location, gender and preexisting conditions.

Get Inspired

If these snippets interest you and you haven’t joined Wolfram Community, now is the time! You can discover a wealth of tools and code using the Wolfram Language, submit your own content or read through the complete list of Staff Picks.

Want to get information about similar Wolfram Community posts delivered straight to your inbox? Subscribe to the Wolfram Community Insider here.
]]> https://blog.wolfram.com:443/2020/09/04/wolfram-community-takes-on-current-events-covid-19-data-green-spaces-homeschool-puzzles-and-more/feed/ 0 Wolfram Plans to Offer Classes for Homeschoolers This Semester, and We Want to Hear from You! https://blog.wolfram.com:443/2020/09/02/wolfram-plans-to-offer-classes-for-homeschoolers-this-semester-and-we-want-to-hear-from-you/ https://blog.wolfram.com:443/2020/09/02/wolfram-plans-to-offer-classes-for-homeschoolers-this-semester-and-we-want-to-hear-from-you/#comments Wed, 02 Sep 2020 23:38:12 +0000 Arben Kalziqi https://blog.internal.wolfram.com/?p=68314 Wolfram Plans to Offer Homeschooling Options, and We Want to Hear from You!

Schooling looks a little different in 2020. Whether it’s technical issues with the transition to online courses, decreased physical attendance or delayed and last-minute openings, we’re all feeling the pressure caused by the COVID-19 pandemic.

At Wolfram Research, we’ve been involved in education for decades and count millions of parents, teachers and students as both our customers and our friends. Because of this longstanding commitment to learning, we have content, experts and platforms at the ready to help parents and students who are looking for ways to augment their learning.

To this end, we are currently planning a homeschool education initiative, which will focus on mathematics, programming and computational thinking, aimed roughly at the high-school level. We plan to offer free “self-serve” courses covering these subjects, as well as paid interactive courses taught by talented instructors. Our goal is to offer students unique and meaningful instruction, enabled by a combination of our technology and interaction with experts. We also plan to host occasional “colloquia,” where students can engage in Q&As with scientists, mathematicians and computer scientists, connecting what they learn in their classes back to the real world that lies ahead of them.

Your thoughts on this initiative are welcome. If you have any ideas or feedback or are interested in signing up for any of these courses, we’d love to hear from you. If you’re interested in becoming an instructor for these courses, you can apply here.

Apply here to teach a course or give feedback on at-home options you’d like to see from Wolfram.
]]> https://blog.wolfram.com:443/2020/09/02/wolfram-plans-to-offer-classes-for-homeschoolers-this-semester-and-we-want-to-hear-from-you/feed/ 0 You Can’t Have a Function Repository without Having Some Fun https://blog.wolfram.com:443/2020/08/25/you-cant-have-a-function-repository-without-having-somefun/ https://blog.wolfram.com:443/2020/08/25/you-cant-have-a-function-repository-without-having-somefun/#comments Tue, 25 Aug 2020 18:35:58 +0000 Bob Sandheinrich https://blog.internal.wolfram.com/?p=68215 You Can’t Have a Function Repository without Having Some Fun

While programming in the Wolfram Language, I am able to quickly and easily get results—one of the best aspects of writing code in a high-level language. The Wolfram Language is so easy to use that I have the freedom to pursue ideas on a whim, even if I know those ideas may not accomplish anything great or work toward a larger goal. In most cases, within a few minutes I figure out if the idea is a dead end. I also figure out if I am on the path to creating something useful or, better yet, fun.

This kind of willingness to experiment with code doesn’t happen with every programming language. When I’m not working with code in a very serious way for a living, I’ve been able to create a team-making tool for my recreational sports league and a GIF-making tool to amuse friends. Sometimes, I am arrogant enough to think that these kinds of tools would be useful (or fun!) to other people.

The Wolfram Language is large and august. It contains thousands of symbols for performing computations in many domains. With each version release, the language grows at an increasing rate. Wolfram Language users can usually maintain an expertise within a limited domain and read documentation whenever they want to explore outward. But for developers at Wolfram who are tasked with expanding the Wolfram Language, a broad understanding is crucial. The durability of the language over decades depends on consistency among all domains. Because of this requirement, the design of new functions is a very deliberate and serious endeavor. Adding a quick, hacky side project, even if it is useful and interesting to the Wolfram Language, is not a simple task, and it may never reach the standard required to be included.

When you look at Wolfram Language documentation, you see very serious function names like CircularQuaternionMatrixDistribution and NDEigensystem. These are not side projects or frivolities. With some exceptions, the documentation is unlikely to inspire mirth in the reader.

Luckily, for over a year now we have had an outlet that is perfect for lighthearted code, the Wolfram Function Repository. To paraphrase a well-coiffed man, I’m not just a developer of the Function Repository; I’m also a client. I can submit the fun code I write that has almost no chance of making it into the Wolfram Language because the Function Repository does not have the rigid requirements of the Wolfram Language.

You may have some questions about whether or not to submit your own imperfect or frivolous code. Maybe this quick Q&A will give you the inspiration you need:

  • Q: What if the design is inconsistent with other domains of the Wolfram Language?
    A: That’s fine.
  • Q: Is exhaustive error handling a requirement?
    A: No big deal.
  • Q: What if the function won’t handle edge cases?
    A: There are almost always tricky edge cases! We will take it anyway.
  • Q: What if it’s silly?
    A: Please submit it now.
  • Q: What if it involves anthropomorphized birds?
    A: I will email you every day until you submit it.

The following are some of my favorite playful Function Repository entries. As you will see, I am not the only one who has found this to be a useful outlet for spreading computational joy. But since, as I said, I am arrogant, I’ll start with one of my creations, which I call “Junior.”

Bob

The Bob resource function makes things bob up and down in a notebook. Yes, it’s stupid. And I can say that because I created it. If you find a serious use case, congratulations! Still, it makes me smile, and I hope it makes others smile too.

&#10005

ListPlot[Table[Callout[i, ResourceFunction["Bob"][i, 3]], {i, 1, 5}]]

WolfieSay and Friends

There are several fun ways to display content in a notebook, and fun ways to generate the content. Rather than show each function alone, I will make a single masterpiece.

ResourceFunction
&#10005

ResourceFunction["WoodFramed"][
 Column[{ResourceFunction["WolfieSay"][
    ResourceFunction["Wiggled"]@
     ResourceFunction["RandomEnglishHaiku"][]],
   ResourceFunction["BirdSay"][
    ResourceFunction["RainbowText"]@
     ResourceFunction["RandomFortune"][], Right]}]]

If anyone enjoys xkcd as much as me, they will love this one:

ResourceFunction
&#10005

ResourceFunction["XKCDConvert"][DateListStepPlot[{{
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 1}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 2}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 3}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 4}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 5}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 6}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 7}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 8}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 9}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 10}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 11}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 12}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 13}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 14}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 15}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 16}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 17}, {
DateObject[{2018, 8, 15}, "Day", "Gregorian", -5.], 18}, {
DateObject[{2018, 8, 17}, "Day", "Gregorian", -5.], 19}, {
DateObject[{2018, 8, 17}, "Day", "Gregorian", -5.], 20}, {
DateObject[{2018, 8, 17}, "Day", "Gregorian", -5.], 21}, {
DateObject[{2018, 8, 28}, "Day", "Gregorian", -5.], 22}, {
DateObject[{2018, 8, 28}, "Day", "Gregorian", -5.], 23}, {
DateObject[{2018, 8, 31}, "Day", "Gregorian", -5.], 24}, {
DateObject[{2018, 9, 5}, "Day", "Gregorian", -5.], 25}, {
DateObject[{2018, 9, 5}, "Day", "Gregorian", -5.], 26}, {
DateObject[{2018, 10, 8}, "Day", "Gregorian", -5.], 27}, {
DateObject[{2018, 10, 10}, "Day", "Gregorian", -5.], 28}, {
DateObject[{2018, 10, 10}, "Day", "Gregorian", -5.], 29}, {
DateObject[{2018, 10, 10}, "Day", "Gregorian", -5.], 30}, {
DateObject[{2018, 10, 10}, "Day", "Gregorian", -5.], 31}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 32}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 33}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 34}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 35}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 36}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 37}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 38}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 39}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 40}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 41}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 42}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 43}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 44}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 45}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 46}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 47}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 48}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 49}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 50}, {
DateObject[{2018, 10, 11}, "Day", "Gregorian", -5.], 51}, {
DateObject[{2018, 10, 12}, "Day", "Gregorian", -5.], 52}, {
DateObject[{2018, 10, 12}, "Day", "Gregorian", -5.], 53}, {
DateObject[{2018, 10, 12}, "Day", "Gregorian", -5.], 54}, {
DateObject[{2018, 10, 12}, "Day", "Gregorian", -5.], 55}, {
DateObject[{2018, 10, 12}, "Day", "Gregorian", -5.], 56}, {
DateObject[{2018, 10, 12}, "Day", "Gregorian", -5.], 57}, {
DateObject[{2018, 10, 12}, "Day", "Gregorian", -5.], 58}, {
DateObject[{2018, 10, 12}, "Day", "Gregorian", -5.], 59}, {
DateObject[{2018, 10, 12}, "Day", "Gregorian", -5.], 60}, {
DateObject[{2018, 10, 12}, "Day", "Gregorian", -4.], 61}, {
DateObject[{2018, 10, 13}, "Day", "Gregorian", -5.], 62}, {
DateObject[{2018, 11, 7}, "Day", "Gregorian", -6.], 63}, {
DateObject[{2018, 11, 7}, "Day", "Gregorian", -6.], 64}, {
DateObject[{2018, 11, 9}, "Day", "Gregorian", -6.], 65}, {
DateObject[{2018, 11, 9}, "Day", "Gregorian", -6.], 66}, {
DateObject[{2018, 11, 9}, "Day", "Gregorian", -6.], 67}, {
DateObject[{2018, 11, 9}, "Day", "Gregorian", -6.], 68}, {
DateObject[{2018, 11, 9}, "Day", "Gregorian", -6.], 69}, {
DateObject[{2018, 11, 9}, "Day", "Gregorian", -6.], 70}, {
DateObject[{2018, 11, 14}, "Day", "Gregorian", -6.], 71}, {
DateObject[{2018, 11, 14}, "Day", "Gregorian", -6.], 72}, {
DateObject[{2018, 11, 14}, "Day", "Gregorian", -6.], 73}, {
DateObject[{2018, 11, 27}, "Day", "Gregorian", -6.], 74}, {
DateObject[{2018, 11, 27}, "Day", "Gregorian", -6.], 75}, {
DateObject[{2018, 11, 27}, "Day", "Gregorian", -6.], 76}, {
DateObject[{2018, 11, 27}, "Day", "Gregorian", -6.], 77}, {
DateObject[{2018, 11, 27}, "Day", "Gregorian", -6.], 78}, {
DateObject[{2018, 11, 27}, "Day", "Gregorian", -6.], 79}, {
DateObject[{2018, 11, 27}, "Day", "Gregorian", -6.], 80}, {
DateObject[{2018, 11, 29}, "Day", "Gregorian", -6.], 81}, {
DateObject[{2018, 11, 29}, "Day", "Gregorian", -6.], 82}, {
DateObject[{2018, 11, 29}, "Day", "Gregorian", -6.], 83}, {
DateObject[{2018, 11, 29}, "Day", "Gregorian", -6.], 84}, {
DateObject[{2018, 11, 29}, "Day", "Gregorian", -6.], 85}, {
DateObject[{2018, 11, 29}, "Day", "Gregorian", -6.], 86}, {
DateObject[{2018, 12, 3}, "Day", "Gregorian", -6.], 87}, {
DateObject[{2018, 12, 3}, "Day", "Gregorian", -6.], 88}, {
DateObject[{2018, 12, 3}, "Day", "Gregorian", -6.], 89}, {
DateObject[{2018, 12, 3}, "Day", "Gregorian", -6.], 90}, {
DateObject[{2018, 12, 3}, "Day", "Gregorian", -6.], 91}, {
DateObject[{2018, 12, 3}, "Day", "Gregorian", -6.], 92}, {
DateObject[{2018, 12, 3}, "Day", "Gregorian", -6.], 93}, {
DateObject[{2018, 12, 4}, "Day", "Gregorian", -6.], 94}, {
DateObject[{2018, 12, 4}, "Day", "Gregorian", -6.], 95}, {
DateObject[{2018, 12, 4}, "Day", "Gregorian", -6.], 96}, {
DateObject[{2018, 12, 4}, "Day", "Gregorian", -6.], 97}, {
DateObject[{2018, 12, 4}, "Day", "Gregorian", -6.], 98}, {
DateObject[{2018, 12, 4}, "Day", "Gregorian", -6.], 99}, {
DateObject[{2018, 12, 4}, "Day", "Gregorian", -6.], 100}, {
DateObject[{2018, 12, 4}, "Day", "Gregorian", -6.], 101}, {
DateObject[{2018, 12, 10}, "Day", "Gregorian", -6.], 102}, {
DateObject[{2018, 12, 10}, "Day", "Gregorian", -6.], 103}, {
DateObject[{2018, 12, 10}, "Day", "Gregorian", -6.], 104}, {
DateObject[{2018, 12, 10}, "Day", "Gregorian", -6.], 105}, {
DateObject[{2018, 12, 10}, "Day", "Gregorian", -6.], 106}, {
DateObject[{2018, 12, 10}, "Day", "Gregorian", -6.], 107}, {
DateObject[{2018, 12, 11}, "Day", "Gregorian", -6.], 108}, {
DateObject[{2018, 12, 13}, "Day", "Gregorian", -6.], 109}, {
DateObject[{2018, 12, 13}, "Day", "Gregorian", -6.], 110}, {
DateObject[{2018, 12, 13}, "Day", "Gregorian", -6.], 111}, {
DateObject[{2018, 12, 13}, "Day", "Gregorian", -6.], 112}, {
DateObject[{2018, 12, 13}, "Day", "Gregorian", -6.], 113}, {
DateObject[{2018, 12, 17}, "Day", "Gregorian", -6.], 114}, {
DateObject[{2018, 12, 17}, "Day", "Gregorian", -6.], 115}, {
DateObject[{2018, 12, 17}, "Day", "Gregorian", -6.], 116}, {
DateObject[{2018, 12, 17}, "Day", "Gregorian", -6.], 117}, {
DateObject[{2018, 12, 17}, "Day", "Gregorian", -6.], 118}, {
DateObject[{2018, 12, 20}, "Day", "Gregorian", -6.], 119}, {
DateObject[{2018, 12, 20}, "Day", "Gregorian", -6.], 120}, {
DateObject[{2018, 12, 20}, "Day", "Gregorian", -6.], 121}, {
DateObject[{2018, 12, 20}, "Day", "Gregorian", -6.], 122}, {
DateObject[{2018, 12, 20}, "Day", "Gregorian", -6.], 123}, {
DateObject[{2018, 12, 20}, "Day", "Gregorian", -6.], 124}, {
DateObject[{2018, 12, 31}, "Day", "Gregorian", -6.], 125}, {
DateObject[{2018, 12, 31}, "Day", "Gregorian", -6.], 126}, {
DateObject[{2019, 1, 9}, "Day", "Gregorian", -6.], 127}, {
DateObject[{2019, 1, 9}, "Day", "Gregorian", -6.], 128}, {
DateObject[{2019, 1, 9}, "Day", "Gregorian", -6.], 129}, {
DateObject[{2019, 1, 10}, "Day", "Gregorian", -6.], 130}, {
DateObject[{2019, 1, 10}, "Day", "Gregorian", -6.], 131}, {
DateObject[{2019, 1, 10}, "Day", "Gregorian", -6.], 132}, {
DateObject[{2019, 1, 10}, "Day", "Gregorian", -6.], 133}, {
DateObject[{2019, 1, 10}, "Day", "Gregorian", -6.], 134}, {
DateObject[{2019, 1, 10}, "Day", "Gregorian", -6.], 135}, {
DateObject[{2019, 1, 10}, "Day", "Gregorian", -6.], 136}, {
DateObject[{2019, 1, 10}, "Day", "Gregorian", -6.], 137}, {
DateObject[{2019, 1, 14}, "Day", "Gregorian", -6.], 138}, {
DateObject[{2019, 1, 14}, "Day", "Gregorian", -6.], 139}, {
DateObject[{2019, 1, 14}, "Day", "Gregorian", -6.], 140}, {
DateObject[{2019, 1, 14}, "Day", "Gregorian", -6.], 141}, {
DateObject[{2019, 1, 14}, "Day", "Gregorian", -6.], 142}, {
DateObject[{2019, 1, 14}, "Day", "Gregorian", -6.], 143}, {
DateObject[{2019, 1, 14}, "Day", "Gregorian", -6.], 144}, {
DateObject[{2019, 1, 14}, "Day", "Gregorian", -6.], 145}, {
DateObject[{2019, 1, 16}, "Day", "Gregorian", -6.], 146}, {
DateObject[{2019, 1, 16}, "Day", "Gregorian", -6.], 147}, {
DateObject[{2019, 1, 16}, "Day", "Gregorian", -6.], 148}, {
DateObject[{2019, 1, 16}, "Day", "Gregorian", -6.], 149}, {
DateObject[{2019, 1, 16}, "Day", "Gregorian", -6.], 150}, {
DateObject[{2019, 1, 16}, "Day", "Gregorian", -6.], 151}, {
DateObject[{2019, 1, 16}, "Day", "Gregorian", -6.], 152}, {
DateObject[{2019, 1, 16}, "Day", "Gregorian", -6.], 153}, {
DateObject[{2019, 1, 22}, "Day", "Gregorian", -6.], 154}, {
DateObject[{2019, 1, 22}, "Day", "Gregorian", -6.], 155}, {
DateObject[{2019, 1, 22}, "Day", "Gregorian", -6.], 156}, {
DateObject[{2019, 1, 25}, "Day", "Gregorian", -6.], 157}, {
DateObject[{2019, 1, 25}, "Day", "Gregorian", -6.], 158}, {
DateObject[{2019, 1, 29}, "Day", "Gregorian", -6.], 159}, {
DateObject[{2019, 1, 29}, "Day", "Gregorian", -6.], 160}, {
DateObject[{2019, 1, 29}, "Day", "Gregorian", -6.], 161}, {
DateObject[{2019, 1, 29}, "Day", "Gregorian", -6.], 162}, {
DateObject[{2019, 1, 31}, "Day", "Gregorian", -6.], 163}, {
DateObject[{2019, 1, 31}, "Day", "Gregorian", -6.], 164}, {
DateObject[{2019, 1, 31}, "Day", "Gregorian", -6.], 165}, {
DateObject[{2019, 1, 31}, "Day", "Gregorian", -6.], 166}, {
DateObject[{2019, 2, 1}, "Day", "Gregorian", -6.], 167}, {
DateObject[{2019, 2, 1}, "Day", "Gregorian", -6.], 168}, {
DateObject[{2019, 2, 1}, "Day", "Gregorian", -6.], 169}, {
DateObject[{2019, 2, 1}, "Day", "Gregorian", -6.], 170}, {
DateObject[{2019, 2, 1}, "Day", "Gregorian", -6.], 171}, {
DateObject[{2019, 2, 1}, "Day", "Gregorian", -6.], 172}, {
DateObject[{2019, 2, 4}, "Day", "Gregorian", -6.], 173}, {
DateObject[{2019, 2, 4}, "Day", "Gregorian", -6.], 174}, {
DateObject[{2019, 2, 4}, "Day", "Gregorian", -6.], 175}, {
DateObject[{2019, 2, 4}, "Day", "Gregorian", -6.], 176}, {
DateObject[{2019, 2, 4}, "Day", "Gregorian", -6.], 177}, {
DateObject[{2019, 2, 5}, "Day", "Gregorian", -6.], 178}, {
DateObject[{2019, 2, 5}, "Day", "Gregorian", -6.], 179}, {
DateObject[{2019, 2, 5}, "Day", "Gregorian", -6.], 180}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 181}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 182}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 183}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 184}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 185}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 186}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 187}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 188}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 189}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 190}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 191}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 192}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 193}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 194}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 195}, {
DateObject[{2019, 2, 6}, "Day", "Gregorian", -6.], 196}, {
DateObject[{2019, 2, 7}, "Day", "Gregorian", -6.], 197}, {
DateObject[{2019, 2, 7}, "Day", "Gregorian", -6.], 198}, {
DateObject[{2019, 2, 7}, "Day", "Gregorian", -6.], 199}, {
DateObject[{2019, 2, 7}, "Day", "Gregorian", -6.], 200}, {
DateObject[{2019, 2, 7}, "Day", "Gregorian", -6.], 201}, {
DateObject[{2019, 2, 7}, "Day", "Gregorian", -6.], 202}, {
DateObject[{2019, 2, 7}, "Day", "Gregorian", -6.], 203}, {
DateObject[{2019, 2, 8}, "Day", "Gregorian", -6.], 204}, {
DateObject[{2019, 2, 8}, "Day", "Gregorian", -6.], 205}, {
DateObject[{2019, 2, 8}, "Day", "Gregorian", -6.], 206}, {
DateObject[{2019, 2, 8}, "Day", "Gregorian", -6.], 207}, {
DateObject[{2019, 2, 8}, "Day", "Gregorian", -6.], 208}, {
DateObject[{2019, 2, 8}, "Day", "Gregorian", -6.], 209}, {
DateObject[{2019, 2, 8}, "Day", "Gregorian", -6.], 210}, {
DateObject[{2019, 2, 11}, "Day", "Gregorian", -6.], 211}, {
DateObject[{2019, 2, 11}, "Day", "Gregorian", -6.], 212}, {
DateObject[{2019, 2, 11}, "Day", "Gregorian", -6.], 213}, {
DateObject[{2019, 2, 11}, "Day", "Gregorian", -6.], 214}, {
DateObject[{2019, 2, 11}, "Day", "Gregorian", -6.], 215}, {
DateObject[{2019, 2, 11}, "Day", "Gregorian", -6.], 216}, {
DateObject[{2019, 2, 11}, "Day", "Gregorian", -6.], 217}, {
DateObject[{2019, 2, 11}, "Day", "Gregorian", -6.], 218}, {
DateObject[{2019, 2, 11}, "Day", "Gregorian", -6.], 219}, {
DateObject[{2019, 2, 11}, "Day", "Gregorian", -6.], 220}, {
DateObject[{2019, 2, 11}, "Day", "Gregorian", -6.], 221}, {
DateObject[{2019, 2, 12}, "Day", "Gregorian", -6.], 222}, {
DateObject[{2019, 2, 12}, "Day", "Gregorian", -6.], 223}, {
DateObject[{2019, 2, 12}, "Day", "Gregorian", -6.], 224}, {
DateObject[{2019, 2, 12}, "Day", "Gregorian", -6.], 225}, {
DateObject[{2019, 2, 13}, "Day", "Gregorian", -6.], 226}, {
DateObject[{2019, 2, 13}, "Day", "Gregorian", -6.], 227}, {
DateObject[{2019, 2, 13}, "Day", "Gregorian", -6.], 228}, {
DateObject[{2019, 2, 13}, "Day", "Gregorian", -6.], 229}, {
DateObject[{2019, 2, 13}, "Day", "Gregorian", -6.], 230}, {
DateObject[{2019, 2, 13}, "Day", "Gregorian", -6.], 231}, {
DateObject[{2019, 2, 13}, "Day", "Gregorian", -6.], 232}, {
DateObject[{2019, 2, 13}, "Day", "Gregorian", -6.], 233}, {
DateObject[{2019, 2, 13}, "Day", "Gregorian", -6.], 234}, {
DateObject[{2019, 2, 13}, "Day", "Gregorian", -6.], 235}, {
DateObject[{2019, 2, 14}, "Day", "Gregorian", -6.], 236}, {
DateObject[{2019, 2, 14}, "Day", "Gregorian", -6.], 237}, {
DateObject[{2019, 2, 14}, "Day", "Gregorian", -6.], 238}, {
DateObject[{2019, 2, 14}, "Day", "Gregorian", -6.], 239}, {
DateObject[{2019, 2, 14}, "Day", "Gregorian", -6.], 240}, {
DateObject[{2019, 2, 14}, "Day", "Gregorian", -6.], 241}, {
DateObject[{2019, 2, 15}, "Day", "Gregorian", -6.], 242}, {
DateObject[{2019, 2, 15}, "Day", "Gregorian", -6.], 243}, {
DateObject[{2019, 2, 15}, "Day", "Gregorian", -6.], 244}, {
DateObject[{2019, 2, 15}, "Day", "Gregorian", -6.], 245}, {
DateObject[{2019, 2, 15}, "Day", "Gregorian", -6.], 246}, {
DateObject[{2019, 2, 15}, "Day", "Gregorian", -6.], 247}, {
DateObject[{2019, 2, 15}, "Day", "Gregorian", -6.], 248}, {
DateObject[{2019, 2, 15}, "Day", "Gregorian", -6.], 249}, {
DateObject[{2019, 2, 18}, "Day", "Gregorian", -6.], 250}, {
DateObject[{2019, 2, 18}, "Day", "Gregorian", -6.], 251}, {
DateObject[{2019, 2, 18}, "Day", "Gregorian", -6.], 252}, {
DateObject[{2019, 2, 18}, "Day", "Gregorian", -6.], 253}, {
DateObject[{2019, 2, 18}, "Day", "Gregorian", -6.], 254}, {
DateObject[{2019, 2, 18}, "Day", "Gregorian", -6.], 255}, {
DateObject[{2019, 2, 19}, "Day", "Gregorian", -6.], 256}, {
DateObject[{2019, 2, 19}, "Day", "Gregorian", -6.], 257}, {
DateObject[{2019, 2, 19}, "Day", "Gregorian", -6.], 258}, {
DateObject[{2019, 2, 19}, "Day", "Gregorian", -6.], 259}, {
DateObject[{2019, 2, 19}, "Day", "Gregorian", -6.], 260}, {
DateObject[{2019, 2, 19}, "Day", "Gregorian", -6.], 261}, {
DateObject[{2019, 2, 19}, "Day", "Gregorian", -6.], 262}, {
DateObject[{2019, 2, 19}, "Day", "Gregorian", -6.], 263}, {
DateObject[{2019, 2, 19}, "Day", "Gregorian", -6.], 264}, {
DateObject[{2019, 2, 19}, "Day", "Gregorian", -6.], 265}, {
DateObject[{2019, 2, 19}, "Day", "Gregorian", -6.], 266}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 267}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 268}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 269}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 270}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 271}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 272}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 273}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 274}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 275}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 276}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 277}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 278}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 279}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 280}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 281}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 282}, {
DateObject[{2019, 2, 20}, "Day", "Gregorian", -6.], 283}, {
DateObject[{2019, 2, 21}, "Day", "Gregorian", -6.], 284}, {
DateObject[{2019, 2, 21}, "Day", "Gregorian", -6.], 285}, {
DateObject[{2019, 2, 21}, "Day", "Gregorian", -6.], 286}, {
DateObject[{2019, 2, 21}, "Day", "Gregorian", -6.], 287}, {
DateObject[{2019, 2, 22}, "Day", "Gregorian", -6.], 288}, {
DateObject[{2019, 2, 22}, "Day", "Gregorian", -6.], 289}, {
DateObject[{2019, 2, 22}, "Day", "Gregorian", -6.], 290}, {
DateObject[{2019, 2, 22}, "Day", "Gregorian", -6.], 291}, {
DateObject[{2019, 2, 22}, "Day", "Gregorian", -6.], 292}, {
DateObject[{2019, 2, 22}, "Day", "Gregorian", -6.], 293}, {
DateObject[{2019, 2, 22}, "Day", "Gregorian", -6.], 294}, {
DateObject[{2019, 2, 25}, "Day", "Gregorian", -6.], 295}, {
DateObject[{2019, 2, 25}, "Day", "Gregorian", -6.], 296}, {
DateObject[{2019, 2, 25}, "Day", "Gregorian", -6.], 297}, {
DateObject[{2019, 2, 25}, "Day", "Gregorian", -6.], 298}, {
DateObject[{2019, 2, 25}, "Day", "Gregorian", -6.], 299}, {
DateObject[{2019, 2, 25}, "Day", "Gregorian", -6.], 300}, {
DateObject[{2019, 2, 25}, "Day", "Gregorian", -6.], 301}, {
DateObject[{2019, 2, 25}, "Day", "Gregorian", -6.], 302}, {
DateObject[{2019, 2, 25}, "Day", "Gregorian", -6.], 303}, {
DateObject[{2019, 2, 25}, "Day", "Gregorian", -6.], 304}, {
DateObject[{2019, 2, 25}, "Day", "Gregorian", -6.], 305}, {
DateObject[{2019, 2, 25}, "Day", "Gregorian", -6.], 306}, {
DateObject[{2019, 2, 26}, "Day", "Gregorian", -6.], 307}, {
DateObject[{2019, 2, 26}, "Day", "Gregorian", -6.], 308}, {
DateObject[{2019, 2, 26}, "Day", "Gregorian", -6.], 309}, {
DateObject[{2019, 2, 26}, "Day", "Gregorian", -6.], 310}, {
DateObject[{2019, 2, 26}, "Day", "Gregorian", -6.], 311}, {
DateObject[{2019, 2, 26}, "Day", "Gregorian", -6.], 312}, {
DateObject[{2019, 2, 27}, "Day", "Gregorian", -6.], 313}, {
DateObject[{2019, 2, 27}, "Day", "Gregorian", -6.], 314}, {
DateObject[{2019, 2, 27}, "Day", "Gregorian", -6.], 315}, {
DateObject[{2019, 2, 27}, "Day", "Gregorian", -6.], 316}, {
DateObject[{2019, 2, 27}, "Day", "Gregorian", -6.], 317}, {
DateObject[{2019, 2, 27}, "Day", "Gregorian", -6.], 318}, {
DateObject[{2019, 2, 27}, "Day", "Gregorian", -6.], 319}, {
DateObject[{2019, 2, 27}, "Day", "Gregorian", -6.], 320}, {
DateObject[{2019, 2, 27}, "Day", "Gregorian", -6.], 321}, {
DateObject[{2019, 2, 27}, "Day", "Gregorian", -6.], 322}, {
DateObject[{2019, 2, 28}, "Day", "Gregorian", -6.], 323}, {
DateObject[{2019, 2, 28}, "Day", "Gregorian", -6.], 324}, {
DateObject[{2019, 2, 28}, "Day", "Gregorian", -6.], 325}, {
DateObject[{2019, 2, 28}, "Day", "Gregorian", -6.], 326}, {
DateObject[{2019, 2, 28}, "Day", "Gregorian", -6.], 327}, {
DateObject[{2019, 2, 28}, "Day", "Gregorian", -6.], 328}, {
DateObject[{2019, 3, 1}, "Day", "Gregorian", -6.], 329}, {
DateObject[{2019, 3, 1}, "Day", "Gregorian", -6.], 330}, {
DateObject[{2019, 3, 1}, "Day", "Gregorian", -6.], 331}, {
DateObject[{2019, 3, 1}, "Day", "Gregorian", -6.], 332}, {
DateObject[{2019, 3, 1}, "Day", "Gregorian", -6.], 333}, {
DateObject[{2019, 3, 4}, "Day", "Gregorian", -6.], 334}, {
DateObject[{2019, 3, 4}, "Day", "Gregorian", -6.], 335}, {
DateObject[{2019, 3, 4}, "Day", "Gregorian", -6.], 336}, {
DateObject[{2019, 3, 4}, "Day", "Gregorian", -6.], 337}, {
DateObject[{2019, 3, 4}, "Day", "Gregorian", -6.], 338}, {
DateObject[{2019, 3, 4}, "Day", "Gregorian", -6.], 339}, {
DateObject[{2019, 3, 4}, "Day", "Gregorian", -6.], 340}, {
DateObject[{2019, 3, 4}, "Day", "Gregorian", -6.], 341}, {
DateObject[{2019, 3, 4}, "Day", "Gregorian", -6.], 342}, {
DateObject[{2019, 3, 4}, "Day", "Gregorian", -6.], 343}, {
DateObject[{2019, 3, 4}, "Day", "Gregorian", -6.], 344}, {
DateObject[{2019, 3, 5}, "Day", "Gregorian", -6.], 345}, {
DateObject[{2019, 3, 5}, "Day", "Gregorian", -6.], 346}, {
DateObject[{2019, 3, 5}, "Day", "Gregorian", -6.], 347}, {
DateObject[{2019, 3, 5}, "Day", "Gregorian", -6.], 348}, {
DateObject[{2019, 3, 6}, "Day", "Gregorian", -6.], 349}, {
DateObject[{2019, 3, 6}, "Day", "Gregorian", -6.], 350}, {
DateObject[{2019, 3, 6}, "Day", "Gregorian", -6.], 351}, {
DateObject[{2019, 3, 6}, "Day", "Gregorian", -6.], 352}, {
DateObject[{2019, 3, 6}, "Day", "Gregorian", -6.], 353}, {
DateObject[{2019, 3, 6}, "Day", "Gregorian", -6.], 354}, {
DateObject[{2019, 3, 6}, "Day", "Gregorian", -6.], 355}, {
DateObject[{2019, 3, 6}, "Day", "Gregorian", -6.], 356}, {
DateObject[{2019, 3, 6}, "Day", "Gregorian", -6.], 357}, {
DateObject[{2019, 3, 6}, "Day", "Gregorian", -6.], 358}, {
DateObject[{2019, 3, 6}, "Day", "Gregorian", -6.], 359}, {
DateObject[{2019, 3, 6}, "Day", "Gregorian", -6.], 360}, {
DateObject[{2019, 3, 7}, "Day", "Gregorian", -6.], 361}, {
DateObject[{2019, 3, 7}, "Day", "Gregorian", -6.], 362}, {
DateObject[{2019, 3, 7}, "Day", "Gregorian", -6.], 363}, {
DateObject[{2019, 3, 7}, "Day", "Gregorian", -6.], 364}, {
DateObject[{2019, 3, 7}, "Day", "Gregorian", -6.], 365}, {
DateObject[{2019, 3, 7}, "Day", "Gregorian", -6.], 366}, {
DateObject[{2019, 3, 7}, "Day", "Gregorian", -6.], 367}, {
DateObject[{2019, 3, 8}, "Day", "Gregorian", -6.], 368}, {
DateObject[{2019, 3, 8}, "Day", "Gregorian", -6.], 369}, {
DateObject[{2019, 3, 8}, "Day", "Gregorian", -6.], 370}, {
DateObject[{2019, 3, 8}, "Day", "Gregorian", -6.], 371}, {
DateObject[{2019, 3, 8}, "Day", "Gregorian", -6.], 372}, {
DateObject[{2019, 3, 8}, "Day", "Gregorian", -6.], 373}, {
DateObject[{2019, 3, 8}, "Day", "Gregorian", -6.], 374}, {
DateObject[{2019, 3, 8}, "Day", "Gregorian", -6.], 375}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 376}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 377}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 378}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 379}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 380}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 381}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 382}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 383}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 384}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 385}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 386}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 387}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 388}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 389}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 390}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 391}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 392}, {
DateObject[{2019, 3, 11}, "Day", "Gregorian", -5.], 393}, {
DateObject[{2019, 3, 13}, "Day", "Gregorian", -5.], 394}, {
DateObject[{2019, 3, 13}, "Day", "Gregorian", -5.], 395}, {
DateObject[{2019, 3, 13}, "Day", "Gregorian", -5.], 396}, {
DateObject[{2019, 3, 13}, "Day", "Gregorian", -5.], 397}, {
DateObject[{2019, 3, 13}, "Day", "Gregorian", -5.], 398}, {
DateObject[{2019, 3, 14}, "Day", "Gregorian", -5.], 399}, {
DateObject[{2019, 3, 14}, "Day", "Gregorian", -5.], 400}, {
DateObject[{2019, 3, 14}, "Day", "Gregorian", -5.], 401}, {
DateObject[{2019, 3, 14}, "Day", "Gregorian", -5.], 402}, {
DateObject[{2019, 3, 15}, "Day", "Gregorian", -5.], 403}, {
DateObject[{2019, 3, 15}, "Day", "Gregorian", -5.], 404}, {
DateObject[{2019, 3, 15}, "Day", "Gregorian", -5.], 405}, {
DateObject[{2019, 3, 15}, "Day", "Gregorian", -5.], 406}, {
DateObject[{2019, 3, 15}, "Day", "Gregorian", -5.], 407}, {
DateObject[{2019, 3, 15}, "Day", "Gregorian", -5.], 408}, {
DateObject[{2019, 3, 15}, "Day", "Gregorian", -5.], 409}, {
DateObject[{2019, 3, 19}, "Day", "Gregorian", -5.], 410}, {
DateObject[{2019, 3, 19}, "Day", "Gregorian", -5.], 411}, {
DateObject[{2019, 3, 19}, "Day", "Gregorian", -5.], 412}, {
DateObject[{2019, 3, 19}, "Day", "Gregorian", -5.], 413}, {
DateObject[{2019, 3, 19}, "Day", "Gregorian", -5.], 414}, {
DateObject[{2019, 3, 20}, "Day", "Gregorian", -5.], 415}, {
DateObject[{2019, 3, 20}, "Day", "Gregorian", -5.], 416}, {
DateObject[{2019, 3, 20}, "Day", "Gregorian", -5.], 417}, {
DateObject[{2019, 3, 20}, "Day", "Gregorian", -5.], 418}, {
DateObject[{2019, 3, 20}, "Day", "Gregorian", -5.], 419}, {
DateObject[{2019, 3, 20}, "Day", "Gregorian", -5.], 420}, {
DateObject[{2019, 3, 20}, "Day", "Gregorian", -5.], 421}, {
DateObject[{2019, 3, 20}, "Day", "Gregorian", -5.], 422}, {
DateObject[{2019, 3, 22}, "Day", "Gregorian", -5.], 423}, {
DateObject[{2019, 3, 22}, "Day", "Gregorian", -5.], 424}, {
DateObject[{2019, 3, 22}, "Day", "Gregorian", -5.], 425}, {
DateObject[{2019, 3, 27}, "Day", "Gregorian", -5.], 426}, {
DateObject[{2019, 3, 27}, "Day", "Gregorian", -5.], 427}, {
DateObject[{2019, 3, 27}, "Day", "Gregorian", -5.], 428}, {
DateObject[{2019, 3, 27}, "Day", "Gregorian", -5.], 429}, {
DateObject[{2019, 3, 27}, "Day", "Gregorian", -5.], 430}, {
DateObject[{2019, 3, 27}, "Day", "Gregorian", -5.], 431}, {
DateObject[{2019, 3, 28}, "Day", "Gregorian", -5.], 432}, {
DateObject[{2019, 3, 28}, "Day", "Gregorian", -5.], 433}, {
DateObject[{2019, 3, 28}, "Day", "Gregorian", -5.], 434}, {
DateObject[{2019, 3, 28}, "Day", "Gregorian", -5.], 435}, {
DateObject[{2019, 3, 28}, "Day", "Gregorian", -5.], 436}, {
DateObject[{2019, 3, 29}, "Day", "Gregorian", -5.], 437}, {
DateObject[{2019, 3, 29}, "Day", "Gregorian", -5.], 438}, {
DateObject[{2019, 3, 29}, "Day", "Gregorian", -5.], 439}, {
DateObject[{2019, 3, 29}, "Day", "Gregorian", -5.], 440}, {
DateObject[{2019, 3, 29}, "Day", "Gregorian", -5.], 441}, {
DateObject[{2019, 3, 29}, "Day", "Gregorian", -5.], 442}, {
DateObject[{2019, 4, 1}, "Day", "Gregorian", -5.], 443}, {
DateObject[{2019, 4, 1}, "Day", "Gregorian", -5.], 444}, {
DateObject[{2019, 4, 1}, "Day", "Gregorian", -5.], 445}, {
DateObject[{2019, 4, 3}, "Day", "Gregorian", -5.], 446}, {
DateObject[{2019, 4, 3}, "Day", "Gregorian", -5.], 447}, {
DateObject[{2019, 4, 3}, "Day", "Gregorian", -5.], 448}, {
DateObject[{2019, 4, 3}, "Day", "Gregorian", -5.], 449}, {
DateObject[{2019, 4, 3}, "Day", "Gregorian", -5.], 450}, {
DateObject[{2019, 4, 3}, "Day", "Gregorian", -5.], 451}, {
DateObject[{2019, 4, 3}, "Day", "Gregorian", -5.], 452}, {
DateObject[{2019, 4, 3}, "Day", "Gregorian", -5.], 453}, {
DateObject[{2019, 4, 3}, "Day", "Gregorian", -5.], 454}, {
DateObject[{2019, 4, 3}, "Day", "Gregorian", -5.], 455}, {
DateObject[{2019, 4, 11}, "Day", "Gregorian", -5.], 456}, {
DateObject[{2019, 4, 11}, "Day", "Gregorian", -5.], 457}, {
DateObject[{2019, 4, 11}, "Day", "Gregorian", -5.], 458}, {
DateObject[{2019, 4, 11}, "Day", "Gregorian", -5.], 459}, {
DateObject[{2019, 4, 12}, "Day", "Gregorian", -5.], 460}, {
DateObject[{2019, 4, 12}, "Day", "Gregorian", -5.], 461}, {
DateObject[{2019, 4, 12}, "Day", "Gregorian", -5.], 462}, {
DateObject[{2019, 4, 12}, "Day", "Gregorian", -5.], 463}, {
DateObject[{2019, 4, 12}, "Day", "Gregorian", -5.], 464}, {
DateObject[{2019, 4, 12}, "Day", "Gregorian", -5.], 465}, {
DateObject[{2019, 4, 12}, "Day", "Gregorian", -5.], 466}, {
DateObject[{2019, 4, 12}, "Day", "Gregorian", -5.], 467}, {
DateObject[{2019, 4, 12}, "Day", "Gregorian", -5.], 468}, {
DateObject[{2019, 4, 12}, "Day", "Gregorian", -5.], 469}, {
DateObject[{2019, 4, 17}, "Day", "Gregorian", -5.], 470}, {
DateObject[{2019, 4, 17}, "Day", "Gregorian", -5.], 471}, {
DateObject[{2019, 4, 17}, "Day", "Gregorian", -5.], 472}, {
DateObject[{2019, 4, 17}, "Day", "Gregorian", -5.], 473}, {
DateObject[{2019, 4, 17}, "Day", "Gregorian", -5.], 474}, {
DateObject[{2019, 4, 17}, "Day", "Gregorian", -5.], 475}, {
DateObject[{2019, 4, 17}, "Day", "Gregorian", -5.], 476}, {
DateObject[{2019, 4, 17}, "Day", "Gregorian", -5.], 477}, {
DateObject[{2019, 4, 17}, "Day", "Gregorian", -5.], 478}, {
DateObject[{2019, 4, 19}, "Day", "Gregorian", -5.], 479}, {
DateObject[{2019, 4, 19}, "Day", "Gregorian", -5.], 480}, {
DateObject[{2019, 4, 19}, "Day", "Gregorian", -5.], 481}, {
DateObject[{2019, 4, 19}, "Day", "Gregorian", -5.], 482}, {
DateObject[{2019, 4, 19}, "Day", "Gregorian", -5.], 483}, {
DateObject[{2019, 4, 19}, "Day", "Gregorian", -5.], 484}, {
DateObject[{2019, 4, 19}, "Day", "Gregorian", -5.], 485}, {
DateObject[{2019, 4, 19}, "Day", "Gregorian", -5.], 486}, {
DateObject[{2019, 4, 19}, "Day", "Gregorian", -5.], 487}, {
DateObject[{2019, 4, 19}, "Day", "Gregorian", -5.], 488}, {
DateObject[{2019, 4, 19}, "Day", "Gregorian", -5.], 489}, {
DateObject[{2019, 4, 26}, "Day", "Gregorian", -5.], 490}, {
DateObject[{2019, 4, 26}, "Day", "Gregorian", -5.], 491}, {
DateObject[{2019, 4, 26}, "Day", "Gregorian", -5.], 492}, {
DateObject[{2019, 4, 26}, "Day", "Gregorian", -5.], 493}, {
DateObject[{2019, 4, 26}, "Day", "Gregorian", -5.], 494}, {
DateObject[{2019, 4, 26}, "Day", "Gregorian", -5.], 495}, {
DateObject[{2019, 4, 26}, "Day", "Gregorian", -5.], 496}, {
DateObject[{2019, 4, 26}, "Day", "Gregorian", -5.], 497}, {
DateObject[{2019, 4, 26}, "Day", "Gregorian", -5.], 498}, {
DateObject[{2019, 4, 26}, "Day", "Gregorian", -5.], 499}, {
DateObject[{2019, 4, 29}, "Day", "Gregorian", -5.], 500}, {
DateObject[{2019, 5, 3}, "Day", "Gregorian", -5.], 501}, {
DateObject[{2019, 5, 3}, "Day", "Gregorian", -5.], 502}, {
DateObject[{2019, 5, 3}, "Day", "Gregorian", -5.], 503}, {
DateObject[{2019, 5, 3}, "Day", "Gregorian", -5.], 504}, {
DateObject[{2019, 5, 10}, "Day", "Gregorian", -5.], 505}, {
DateObject[{2019, 5, 10}, "Day", "Gregorian", -5.], 506}, {
DateObject[{2019, 5, 10}, "Day", "Gregorian", -5.], 507}, {
DateObject[{2019, 5, 10}, "Day", "Gregorian", -5.], 508}, {
DateObject[{2019, 5, 10}, "Day", "Gregorian", -5.], 509}, {
DateObject[{2019, 5, 10}, "Day", "Gregorian", -5.], 510}, {
DateObject[{2019, 5, 10}, "Day", "Gregorian", -5.], 511}, {
DateObject[{2019, 5, 15}, "Day", "Gregorian", -5.], 512}, {
DateObject[{2019, 5, 17}, "Day", "Gregorian", -5.], 513}, {
DateObject[{2019, 5, 17}, "Day", "Gregorian", -5.], 514}, {
DateObject[{2019, 5, 17}, "Day", "Gregorian", -5.], 515}, {
DateObject[{2019, 5, 22}, "Day", "Gregorian", -5.], 516}, {
DateObject[{2019, 5, 22}, "Day", "Gregorian", -5.], 517}, {
DateObject[{2019, 5, 22}, "Day", "Gregorian", -5.], 518}, {
DateObject[{2019, 5, 22}, "Day", "Gregorian", -5.], 519}, {
DateObject[{2019, 5, 22}, "Day", "Gregorian", -5.], 520}, {
DateObject[{2019, 5, 22}, "Day", "Gregorian", -5.], 521}, {
DateObject[{2019, 5, 22}, "Day", "Gregorian", -5.], 522}, {
DateObject[{2019, 5, 22}, "Day", "Gregorian", -5.], 523}, {
DateObject[{2019, 5, 22}, "Day", "Gregorian", -5.], 524}, {
DateObject[{2019, 5, 22}, "Day", "Gregorian", -5.], 525}, {
DateObject[{2019, 5, 22}, "Day", "Gregorian", -5.], 526}, {
DateObject[{2019, 5, 23}, "Day", "Gregorian", -5.], 527}, {
DateObject[{2019, 5, 23}, "Day", "Gregorian", -5.], 528}, {
DateObject[{2019, 5, 29}, "Day", "Gregorian", -5.], 529}, {
DateObject[{2019, 5, 29}, "Day", "Gregorian", -5.], 530}, {
DateObject[{2019, 5, 29}, "Day", "Gregorian", -5.], 531}, {
DateObject[{2019, 5, 29}, "Day", "Gregorian", -5.], 532}, {
DateObject[{2019, 5, 29}, "Day", "Gregorian", -5.], 533}, {
DateObject[{2019, 5, 29}, "Day", "Gregorian", -5.], 534}, {
DateObject[{2019, 5, 31}, "Day", "Gregorian", -5.], 535}, {
DateObject[{2019, 5, 31}, "Day", "Gregorian", -5.], 536}, {
DateObject[{2019, 5, 31}, "Day", "Gregorian", -5.], 537}, {
DateObject[{2019, 5, 31}, "Day", "Gregorian", -5.], 538}, {
DateObject[{2019, 5, 31}, "Day", "Gregorian", -5.], 539}, {
DateObject[{2019, 5, 31}, "Day", "Gregorian", -5.], 540}, {
DateObject[{2019, 5, 31}, "Day", "Gregorian", -5.], 541}, {
DateObject[{2019, 5, 31}, "Day", "Gregorian", -5.], 542}, {
DateObject[{2019, 5, 31}, "Day", "Gregorian", -5.], 543}, {
DateObject[{2019, 6, 7}, "Day", "Gregorian", -5.], 544}, {
DateObject[{2019, 6, 7}, "Day", "Gregorian", -5.], 545}, {
DateObject[{2019, 6, 7}, "Day", "Gregorian", -5.], 546}, {
DateObject[{2019, 6, 10}, "Day", "Gregorian", -5.], 547}, {
DateObject[{2019, 6, 14}, "Day", "Gregorian", -5.], 548}, {
DateObject[{2019, 6, 14}, "Day", "Gregorian", -5.], 549}, {
DateObject[{2019, 6, 14}, "Day", "Gregorian", -5.], 550}, {
DateObject[{2019, 6, 19}, "Day", "Gregorian", -5.], 551}, {
DateObject[{2019, 6, 19}, "Day", "Gregorian", -5.], 552}, {
DateObject[{2019, 6, 19}, "Day", "Gregorian", -5.], 553}, {
DateObject[{2019, 6, 19}, "Day", "Gregorian", -5.], 554}, {
DateObject[{2019, 6, 19}, "Day", "Gregorian", -5.], 555}, {
DateObject[{2019, 6, 19}, "Day", "Gregorian", -5.], 556}, {
DateObject[{2019, 6, 19}, "Day", "Gregorian", -5.], 557}, {
DateObject[{2019, 6, 21}, "Day", "Gregorian", -5.], 558}, {
DateObject[{2019, 6, 21}, "Day", "Gregorian", -5.], 559}, {
DateObject[{2019, 6, 24}, "Day", "Gregorian", -5.], 560}, {
DateObject[{2019, 6, 24}, "Day", "Gregorian", -5.], 561}, {
DateObject[{2019, 6, 24}, "Day", "Gregorian", -5.], 562}, {
DateObject[{2019, 6, 24}, "Day", "Gregorian", -5.], 563}, {
DateObject[{2019, 6, 24}, "Day", "Gregorian", -5.], 564}, {
DateObject[{2019, 6, 26}, "Day", "Gregorian", -5.], 565}, {
DateObject[{2019, 6, 26}, "Day", "Gregorian", -5.], 566}, {
DateObject[{2019, 6, 26}, "Day", "Gregorian", -5.], 567}, {
DateObject[{2019, 6, 26}, "Day", "Gregorian", -5.], 568}, {
DateObject[{2019, 6, 26}, "Day", "Gregorian", -5.], 569}, {
DateObject[{2019, 6, 26}, "Day", "Gregorian", -5.], 570}, {
DateObject[{2019, 6, 26}, "Day", "Gregorian", -5.], 571}, {
DateObject[{2019, 6, 28}, "Day", "Gregorian", -5.], 572}, {
DateObject[{2019, 6, 28}, "Day", "Gregorian", -5.], 573}, {
DateObject[{2019, 6, 28}, "Day", "Gregorian", -5.], 574}, {
DateObject[{2019, 6, 28}, "Day", "Gregorian", -5.], 575}, {
DateObject[{2019, 6, 28}, "Day", "Gregorian", -5.], 576}, {
DateObject[{2019, 7, 1}, "Day", "Gregorian", -5.], 577}, {
DateObject[{2019, 7, 1}, "Day", "Gregorian", -5.], 578}, {
DateObject[{2019, 7, 1}, "Day", "Gregorian", -5.], 579}, {
DateObject[{2019, 7, 3}, "Day", "Gregorian", -5.], 580}, {
DateObject[{2019, 7, 3}, "Day", "Gregorian", -5.], 581}, {
DateObject[{2019, 7, 3}, "Day", "Gregorian", -5.], 582}, {
DateObject[{2019, 7, 3}, "Day", "Gregorian", -5.], 583}, {
DateObject[{2019, 7, 3}, "Day", "Gregorian", -5.], 584}, {
DateObject[{2019, 7, 3}, "Day", "Gregorian", -5.], 585}, {
DateObject[{2019, 7, 3}, "Day", "Gregorian", -5.], 586}, {
DateObject[{2019, 7, 5}, "Day", "Gregorian", -5.], 587}, {
DateObject[{2019, 7, 5}, "Day", "Gregorian", -5.], 588}, {
DateObject[{2019, 7, 5}, "Day", "Gregorian", -5.], 589}, {
DateObject[{2019, 7, 5}, "Day", "Gregorian", -5.], 590}, {
DateObject[{2019, 7, 5}, "Day", "Gregorian", -5.], 591}, {
DateObject[{2019, 7, 5}, "Day", "Gregorian", -5.], 592}, {
DateObject[{2019, 7, 5}, "Day", "Gregorian", -5.], 593}, {
DateObject[{2019, 7, 5}, "Day", "Gregorian", -5.], 594}, {
DateObject[{2019, 7, 5}, "Day", "Gregorian", -5.], 595}, {
DateObject[{2019, 7, 5}, "Day", "Gregorian", -5.], 596}, {
DateObject[{2019, 7, 5}, "Day", "Gregorian", -5.], 597}, {
DateObject[{2019, 7, 8}, "Day", "Gregorian", -5.], 598}, {
DateObject[{2019, 7, 8}, "Day", "Gregorian", -5.], 599}, {
DateObject[{2019, 7, 8}, "Day", "Gregorian", -5.], 600}, {
DateObject[{2019, 7, 8}, "Day", "Gregorian", -5.], 601}, {
DateObject[{2019, 7, 8}, "Day", "Gregorian", -5.], 602}, {
DateObject[{2019, 7, 8}, "Day", "Gregorian", -5.], 603}, {
DateObject[{2019, 7, 8}, "Day", "Gregorian", -5.], 604}, {
DateObject[{2019, 7, 8}, "Day", "Gregorian", -5.], 605}, {
DateObject[{2019, 7, 8}, "Day", "Gregorian", -5.], 606}, {
DateObject[{2019, 7, 8}, "Day", "Gregorian", -5.], 607}, {
DateObject[{2019, 7, 8}, "Day", "Gregorian", -5.], 608}, {
DateObject[{2019, 7, 8}, "Day", "Gregorian", -5.], 609}, {
DateObject[{2019, 7, 8}, "Day", "Gregorian", -5.], 610}, {
DateObject[{2019, 7, 8}, "Day", "Gregorian", -5.], 611}, {
DateObject[{2019, 7, 9}, "Day", "Gregorian", -5.], 612}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 613}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 614}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 615}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 616}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 617}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 618}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 619}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 620}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 621}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 622}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 623}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 624}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 625}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 626}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 627}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 628}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 629}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 630}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 631}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 632}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 633}, {
DateObject[{2019, 7, 10}, "Day", "Gregorian", -5.], 634}, {
DateObject[{2019, 7, 12}, "Day", "Gregorian", -5.], 635}, {
DateObject[{2019, 7, 12}, "Day", "Gregorian", -5.], 636}, {
DateObject[{2019, 7, 12}, "Day", "Gregorian", -5.], 637}, {
DateObject[{2019, 7, 12}, "Day", "Gregorian", -5.], 638}, {
DateObject[{2019, 7, 12}, "Day", "Gregorian", -5.], 639}, {
DateObject[{2019, 7, 15}, "Day", "Gregorian", -5.], 640}, {
DateObject[{2019, 7, 15}, "Day", "Gregorian", -5.], 641}, {
DateObject[{2019, 7, 15}, "Day", "Gregorian", -5.], 642}, {
DateObject[{2019, 7, 15}, "Day", "Gregorian", -5.], 643}, {
DateObject[{2019, 7, 15}, "Day", "Gregorian", -5.], 644}, {
DateObject[{2019, 7, 23}, "Day", "Gregorian", -5.], 645}, {
DateObject[{2019, 7, 23}, "Day", "Gregorian", -5.], 646}, {
DateObject[{2019, 7, 23}, "Day", "Gregorian", -5.], 647}, {
DateObject[{2019, 7, 23}, "Day", "Gregorian", -5.], 648}, {
DateObject[{2019, 7, 25}, "Day", "Gregorian", -5.], 649}, {
DateObject[{2019, 7, 25}, "Day", "Gregorian", -5.], 650}, {
DateObject[{2019, 7, 25}, "Day", "Gregorian", -5.], 651}, {
DateObject[{2019, 7, 26}, "Day", "Gregorian", -5.], 652}, {
DateObject[{2019, 7, 26}, "Day", "Gregorian", -5.], 653}, {
DateObject[{2019, 7, 26}, "Day", "Gregorian", -5.], 654}, {
DateObject[{2019, 7, 29}, "Day", "Gregorian", -5.], 655}, {
DateObject[{2019, 7, 29}, "Day", "Gregorian", -5.], 656}, {
DateObject[{2019, 7, 30}, "Day", "Gregorian", -5.], 657}, {
DateObject[{2019, 7, 30}, "Day", "Gregorian", -5.], 658}, {
DateObject[{2019, 7, 30}, "Day", "Gregorian", -5.], 659}, {
DateObject[{2019, 7, 31}, "Day", "Gregorian", -5.], 660}, {
DateObject[{2019, 7, 31}, "Day", "Gregorian", -5.], 661}, {
DateObject[{2019, 7, 31}, "Day", "Gregorian", -5.], 662}, {
DateObject[{2019, 7, 31}, "Day", "Gregorian", -5.], 663}, {
DateObject[{2019, 7, 31}, "Day", "Gregorian", -5.], 664}, {
DateObject[{2019, 7, 31}, "Day", "Gregorian", -5.], 665}, {
DateObject[{2019, 7, 31}, "Day", "Gregorian", -5.], 666}, {
DateObject[{2019, 7, 31}, "Day", "Gregorian", -5.], 667}, {
DateObject[{2019, 7, 31}, "Day", "Gregorian", -5.], 668}, {
DateObject[{2019, 7, 31}, "Day", "Gregorian", -5.], 669}, {
DateObject[{2019, 7, 31}, "Day", "Gregorian", -5.], 670}, {
DateObject[{2019, 8, 1}, "Day", "Gregorian", -5.], 671}, {
DateObject[{2019, 8, 1}, "Day", "Gregorian", -5.], 672}, {
DateObject[{2019, 8, 1}, "Day", "Gregorian", -5.], 673}, {
DateObject[{2019, 8, 1}, "Day", "Gregorian", -5.], 674}, {
DateObject[{2019, 8, 2}, "Day", "Gregorian", -5.], 675}, {
DateObject[{2019, 8, 2}, "Day", "Gregorian", -5.], 676}, {
DateObject[{2019, 8, 2}, "Day", "Gregorian", -5.], 677}, {
DateObject[{2019, 8, 2}, "Day", "Gregorian", -5.], 678}, {
DateObject[{2019, 8, 2}, "Day", "Gregorian", -5.], 679}, {
DateObject[{2019, 8, 2}, "Day", "Gregorian", -5.], 680}, {
DateObject[{2019, 8, 2}, "Day", "Gregorian", -5.], 681}, {
DateObject[{2019, 8, 5}, "Day", "Gregorian", -5.], 682}, {
DateObject[{2019, 8, 5}, "Day", "Gregorian", -5.], 683}, {
DateObject[{2019, 8, 5}, "Day", "Gregorian", -5.], 684}, {
DateObject[{2019, 8, 5}, "Day", "Gregorian", -5.], 685}, {
DateObject[{2019, 8, 5}, "Day", "Gregorian", -5.], 686}, {
DateObject[{2019, 8, 6}, "Day", "Gregorian", -5.], 687}, {
DateObject[{2019, 8, 6}, "Day", "Gregorian", -5.], 688}, {
DateObject[{2019, 8, 6}, "Day", "Gregorian", -5.], 689}, {
DateObject[{2019, 8, 6}, "Day", "Gregorian", -5.], 690}, {
DateObject[{2019, 8, 7}, "Day", "Gregorian", -6.], 691}, {
DateObject[{2019, 8, 7}, "Day", "Gregorian", -5.], 692}, {
DateObject[{2019, 8, 7}, "Day", "Gregorian", -5.], 693}, {
DateObject[{2019, 8, 7}, "Day", "Gregorian", -5.], 694}, {
DateObject[{2019, 8, 7}, "Day", "Gregorian", -5.], 695}, {
DateObject[{2019, 8, 7}, "Day", "Gregorian", -5.], 696}, {
DateObject[{2019, 8, 7}, "Day", "Gregorian", -5.], 697}, {
DateObject[{2019, 8, 7}, "Day", "Gregorian", -5.], 698}, {
DateObject[{2019, 8, 8}, "Day", "Gregorian", -5.], 699}, {
DateObject[{2019, 8, 8}, "Day", "Gregorian", -5.], 700}, {
DateObject[{2019, 8, 8}, "Day", "Gregorian", -5.], 701}, {
DateObject[{2019, 8, 8}, "Day", "Gregorian", -5.], 702}, {
DateObject[{2019, 8, 8}, "Day", "Gregorian", -5.], 703}, {
DateObject[{2019, 8, 8}, "Day", "Gregorian", -5.], 704}, {
DateObject[{2019, 8, 8}, "Day", "Gregorian", -5.], 705}, {
DateObject[{2019, 8, 8}, "Day", "Gregorian", -5.], 706}, {
DateObject[{2019, 8, 9}, "Day", "Gregorian", -5.], 707}, {
DateObject[{2019, 8, 9}, "Day", "Gregorian", -5.], 708}, {
DateObject[{2019, 8, 12}, "Day", "Gregorian", -5.], 709}, {
DateObject[{2019, 8, 12}, "Day", "Gregorian", -5.], 710}, {
DateObject[{2019, 8, 12}, "Day", "Gregorian", -5.], 711}, {
DateObject[{2019, 8, 12}, "Day", "Gregorian", -5.], 712}, {
DateObject[{2019, 8, 14}, "Day", "Gregorian", -5.], 713}, {
DateObject[{2019, 8, 14}, "Day", "Gregorian", -5.], 714}, {
DateObject[{2019, 8, 14}, "Day", "Gregorian", -5.], 715}, {
DateObject[{2019, 8, 14}, "Day", "Gregorian", -5.], 716}, {
DateObject[{2019, 8, 14}, "Day", "Gregorian", -5.], 717}, {
DateObject[{2019, 8, 14}, "Day", "Gregorian", -5.], 718}, {
DateObject[{2019, 8, 14}, "Day", "Gregorian", -5.], 719}, {
DateObject[{2019, 8, 14}, "Day", "Gregorian", -5.], 720}, {
DateObject[{2019, 8, 14}, "Day", "Gregorian", -5.], 721}, {
DateObject[{2019, 8, 14}, "Day", "Gregorian", -5.], 722}, {
DateObject[{2019, 8, 14}, "Day", "Gregorian", -5.], 723}, {
DateObject[{2019, 8, 14}, "Day", "Gregorian", -5.], 724}, {
DateObject[{2019, 8, 14}, "Day", "Gregorian", -5.], 725}, {
DateObject[{2019, 8, 14}, "Day", "Gregorian", -5.], 726}, {
DateObject[{2019, 8, 16}, "Day", "Gregorian", -5.], 727}, {
DateObject[{2019, 8, 16}, "Day", "Gregorian", -5.], 728}, {
DateObject[{2019, 8, 16}, "Day", "Gregorian", -5.], 729}, {
DateObject[{2019, 8, 16}, "Day", "Gregorian", -5.], 730}, {
DateObject[{2019, 8, 20}, "Day", "Gregorian", -5.], 731}, {
DateObject[{2019, 8, 20}, "Day", "Gregorian", -5.], 732}, {
DateObject[{2019, 8, 20}, "Day", "Gregorian", -5.], 733}, {
DateObject[{2019, 8, 20}, "Day", "Gregorian", -5.], 734}, {
DateObject[{2019, 8, 22}, "Day", "Gregorian", -5.], 735}, {
DateObject[{2019, 8, 22}, "Day", "Gregorian", -5.], 736}, {
DateObject[{2019, 8, 22}, "Day", "Gregorian", -5.], 737}, {
DateObject[{2019, 8, 22}, "Day", "Gregorian", -5.], 738}, {
DateObject[{2019, 8, 22}, "Day", "Gregorian", -5.], 739}, {
DateObject[{2019, 8, 23}, "Day", "Gregorian", -5.], 740}, {
DateObject[{2019, 8, 23}, "Day", "Gregorian", -5.], 741}, {
DateObject[{2019, 8, 23}, "Day", "Gregorian", -5.], 742}, {
DateObject[{2019, 8, 23}, "Day", "Gregorian", -5.], 743}, {
DateObject[{2019, 8, 26}, "Day", "Gregorian", -5.], 744}, {
DateObject[{2019, 8, 26}, "Day", "Gregorian", -5.], 745}, {
DateObject[{2019, 8, 26}, "Day", "Gregorian", -5.], 746}, {
DateObject[{2019, 8, 26}, "Day", "Gregorian", -5.], 747}, {
DateObject[{2019, 8, 26}, "Day", "Gregorian", -5.], 748}, {
DateObject[{2019, 8, 28}, "Day", "Gregorian", -5.], 749}, {
DateObject[{2019, 8, 28}, "Day", "Gregorian", -5.], 750}, {
DateObject[{2019, 8, 28}, "Day", "Gregorian", -5.], 751}, {
DateObject[{2019, 8, 28}, "Day", "Gregorian", -5.], 752}, {
DateObject[{2019, 8, 28}, "Day", "Gregorian", -5.], 753}, {
DateObject[{2019, 8, 28}, "Day", "Gregorian", -5.], 754}, {
DateObject[{2019, 8, 28}, "Day", "Gregorian", -5.], 755}, {
DateObject[{2019, 8, 28}, "Day", "Gregorian", -5.], 756}, {
DateObject[{2019, 8, 29}, "Day", "Gregorian", -5.], 757}, {
DateObject[{2019, 8, 29}, "Day", "Gregorian", -5.], 758}, {
DateObject[{2019, 9, 3}, "Day", "Gregorian", -5.], 759}, {
DateObject[{2019, 9, 3}, "Day", "Gregorian", -5.], 760}, {
DateObject[{2019, 9, 5}, "Day", "Gregorian", -5.], 761}, {
DateObject[{2019, 9, 10}, "Day", "Gregorian", -5.], 762}, {
DateObject[{2019, 9, 10}, "Day", "Gregorian", -5.], 763}, {
DateObject[{2019, 9, 12}, "Day", "Gregorian", -5.], 764}, {
DateObject[{2019, 9, 12}, "Day", "Gregorian", -5.], 765}, {
DateObject[{2019, 9, 12}, "Day", "Gregorian", -5.], 766}, {
DateObject[{2019, 9, 12}, "Day", "Gregorian", -5.], 767}, {
DateObject[{2019, 9, 12}, "Day", "Gregorian", -5.], 768}, {
DateObject[{2019, 9, 13}, "Day", "Gregorian", -5.], 769}, {
DateObject[{2019, 9, 13}, "Day", "Gregorian", -5.], 770}, {
DateObject[{2019, 9, 13}, "Day", "Gregorian", -5.], 771}, {
DateObject[{2019, 9, 13}, "Day", "Gregorian", -5.], 772}, {
DateObject[{2019, 9, 15}, "Day", "Gregorian", -5.], 773}, {
DateObject[{2019, 9, 17}, "Day", "Gregorian", -5.], 774}, {
DateObject[{2019, 9, 17}, "Day", "Gregorian", -5.], 775}, {
DateObject[{2019, 9, 19}, "Day", "Gregorian", -5.], 776}, {
DateObject[{2019, 9, 19}, "Day", "Gregorian", -5.], 777}, {
DateObject[{2019, 9, 19}, "Day", "Gregorian", -5.], 778}, {
DateObject[{2019, 9, 19}, "Day", "Gregorian", -5.], 779}, {
DateObject[{2019, 9, 20}, "Day", "Gregorian", -5.], 780}, {
DateObject[{2019, 9, 20}, "Day", "Gregorian", -5.], 781}, {
DateObject[{2019, 9, 20}, "Day", "Gregorian", -5.], 782}, {
DateObject[{2019, 9, 20}, "Day", "Gregorian", -5.], 783}, {
DateObject[{2019, 9, 20}, "Day", "Gregorian", -5.], 784}, {
DateObject[{2019, 9, 23}, "Day", "Gregorian", -5.], 785}, {
DateObject[{2019, 9, 23}, "Day", "Gregorian", -5.], 786}, {
DateObject[{2019, 9, 23}, "Day", "Gregorian", -5.], 787}, {
DateObject[{2019, 9, 24}, "Day", "Gregorian", -5.], 788}, {
DateObject[{2019, 9, 24}, "Day", "Gregorian", -5.], 789}, {
DateObject[{2019, 9, 24}, "Day", "Gregorian", -5.], 790}, {
DateObject[{2019, 9, 24}, "Day", "Gregorian", -5.], 791}, {
DateObject[{2019, 9, 25}, "Day", "Gregorian", -5.], 792}, {
DateObject[{2019, 9, 25}, "Day", "Gregorian", -5.], 793}, {
DateObject[{2019, 9, 25}, "Day", "Gregorian", -5.], 794}, {
DateObject[{2019, 9, 25}, "Day", "Gregorian", -5.], 795}, {
DateObject[{2019, 9, 25}, "Day", "Gregorian", -5.], 796}, {
DateObject[{2019, 9, 25}, "Day", "Gregorian", -5.], 797}, {
DateObject[{2019, 9, 25}, "Day", "Gregorian", -5.], 798}, {
DateObject[{2019, 9, 25}, "Day", "Gregorian", -5.], 799}, {
DateObject[{2019, 9, 26}, "Day", "Gregorian", -5.], 800}, {
DateObject[{2019, 9, 26}, "Day", "Gregorian", -5.], 801}, {
DateObject[{2019, 9, 27}, "Day", "Gregorian", -5.], 802}, {
DateObject[{2019, 9, 27}, "Day", "Gregorian", -5.], 803}, {
DateObject[{2019, 9, 27}, "Day", "Gregorian", -5.], 804}, {
DateObject[{2019, 9, 27}, "Day", "Gregorian", -5.], 805}, {
DateObject[{2019, 9, 27}, "Day", "Gregorian", -5.], 806}, {
DateObject[{2019, 9, 27}, "Day", "Gregorian", -5.], 807}, {
DateObject[{2019, 10, 2}, "Day", "Gregorian", -5.], 808}, {
DateObject[{2019, 10, 2}, "Day", "Gregorian", -5.], 809}, {
DateObject[{2019, 10, 2}, "Day", "Gregorian", -5.], 810}, {
DateObject[{2019, 10, 2}, "Day", "Gregorian", -5.], 811}, {
DateObject[{2019, 10, 2}, "Day", "Gregorian", -5.], 812}, {
DateObject[{2019, 10, 3}, "Day", "Gregorian", -5.], 813}, {
DateObject[{2019, 10, 3}, "Day", "Gregorian", -5.], 814}, {
DateObject[{2019, 10, 3}, "Day", "Gregorian", -5.], 815}, {
DateObject[{2019, 10, 3}, "Day", "Gregorian", -5.], 816}, {
DateObject[{2019, 10, 3}, "Day", "Gregorian", -5.], 817}, {
DateObject[{2019, 10, 3}, "Day", "Gregorian", -5.], 818}, {
DateObject[{2019, 10, 3}, "Day", "Gregorian", -5.], 819}, {
DateObject[{2019, 10, 4}, "Day", "Gregorian", -5.], 820}, {
DateObject[{2019, 10, 4}, "Day", "Gregorian", -5.], 821}, {
DateObject[{2019, 10, 4}, "Day", "Gregorian", -5.], 822}, {
DateObject[{2019, 10, 7}, "Day", "Gregorian", -5.], 823}, {
DateObject[{2019, 10, 7}, "Day", "Gregorian", -5.], 824}, {
DateObject[{2019, 10, 7}, "Day", "Gregorian", -5.], 825}, {
DateObject[{2019, 10, 7}, "Day", "Gregorian", -5.], 826}, {
DateObject[{2019, 10, 7}, "Day", "Gregorian", -5.], 827}, {
DateObject[{2019, 10, 8}, "Day", "Gregorian", -5.], 828}, {
DateObject[{2019, 10, 8}, "Day", "Gregorian", -5.], 829}, {
DateObject[{2019, 10, 8}, "Day", "Gregorian", -5.], 830}, {
DateObject[{2019, 10, 8}, "Day", "Gregorian", -5.], 831}, {
DateObject[{2019, 10, 10}, "Day", "Gregorian", -5.], 832}, {
DateObject[{2019, 10, 10}, "Day", "Gregorian", -5.], 833}, {
DateObject[{2019, 10, 10}, "Day", "Gregorian", -5.], 834}, {
DateObject[{2019, 10, 10}, "Day", "Gregorian", -5.], 835}, {
DateObject[{2019, 10, 10}, "Day", "Gregorian", -5.], 836}, {
DateObject[{2019, 10, 11}, "Day", "Gregorian", -5.], 837}, {
DateObject[{2019, 10, 11}, "Day", "Gregorian", -5.], 838}, {
DateObject[{2019, 10, 11}, "Day", "Gregorian", -5.], 839}, {
DateObject[{2019, 10, 11}, "Day", "Gregorian", -5.], 840}, {
DateObject[{2019, 10, 14}, "Day", "Gregorian", -5.], 841}, {
DateObject[{2019, 10, 14}, "Day", "Gregorian", -5.], 842}, {
DateObject[{2019, 10, 14}, "Day", "Gregorian", -5.], 843}, {
DateObject[{2019, 10, 14}, "Day", "Gregorian", -5.], 844}, {
DateObject[{2019, 10, 14}, "Day", "Gregorian", -5.], 845}, {
DateObject[{2019, 10, 14}, "Day", "Gregorian", -5.], 846}, {
DateObject[{2019, 10, 14}, "Day", "Gregorian", -5.], 847}, {
DateObject[{2019, 10, 14}, "Day", "Gregorian", -5.], 848}, {
DateObject[{2019, 10, 15}, "Day", "Gregorian", -5.], 849}, {
DateObject[{2019, 10, 15}, "Day", "Gregorian", -5.], 850}, {
DateObject[{2019, 10, 15}, "Day", "Gregorian", -5.], 851}, {
DateObject[{2019, 10, 15}, "Day", "Gregorian", -5.], 852}, {
DateObject[{2019, 10, 15}, "Day", "Gregorian", -5.], 853}, {
DateObject[{2019, 10, 15}, "Day", "Gregorian", -5.], 854}, {
DateObject[{2019, 10, 16}, "Day", "Gregorian", -5.], 855}, {
DateObject[{2019, 10, 16}, "Day", "Gregorian", -5.], 856}, {
DateObject[{2019, 10, 16}, "Day", "Gregorian", -5.], 857}, {
DateObject[{2019, 10, 16}, "Day", "Gregorian", -5.], 858}, {
DateObject[{2019, 10, 16}, "Day", "Gregorian", -5.], 859}, {
DateObject[{2019, 10, 16}, "Day", "Gregorian", -5.], 860}, {
DateObject[{2019, 10, 16}, "Day", "Gregorian", -5.], 861}, {
DateObject[{2019, 10, 16}, "Day", "Gregorian", -5.], 862}, {
DateObject[{2019, 10, 16}, "Day", "Gregorian", -5.], 863}, {
DateObject[{2019, 10, 16}, "Day", "Gregorian", -5.], 864}, {
DateObject[{2019, 10, 16}, "Day", "Gregorian", -5.], 865}, {
DateObject[{2019, 10, 16}, "Day", "Gregorian", -5.], 866}, {
DateObject[{2019, 10, 16}, "Day", "Gregorian", -5.], 867}, {
DateObject[{2019, 10, 17}, "Day", "Gregorian", -5.], 868}, {
DateObject[{2019, 10, 17}, "Day", "Gregorian", -5.], 869}, {
DateObject[{2019, 10, 17}, "Day", "Gregorian", -5.], 870}, {
DateObject[{2019, 10, 17}, "Day", "Gregorian", -5.], 871}, {
DateObject[{2019, 10, 18}, "Day", "Gregorian", -5.], 872}, {
DateObject[{2019, 10, 18}, "Day", "Gregorian", -5.], 873}, {
DateObject[{2019, 10, 18}, "Day", "Gregorian", -5.], 874}, {
DateObject[{2019, 10, 18}, "Day", "Gregorian", -5.], 875}, {
DateObject[{2019, 10, 18}, "Day", "Gregorian", -5.], 876}, {
DateObject[{2019, 10, 18}, "Day", "Gregorian", -5.], 877}, {
DateObject[{2019, 10, 18}, "Day", "Gregorian", -5.], 878}, {
DateObject[{2019, 10, 18}, "Day", "Gregorian", -5.], 879}, {
DateObject[{2019, 10, 18}, "Day", "Gregorian", -5.], 880}, {
DateObject[{2019, 10, 18}, "Day", "Gregorian", -5.], 881}, {
DateObject[{2019, 10, 21}, "Day", "Gregorian", -5.], 882}, {
DateObject[{2019, 10, 21}, "Day", "Gregorian", -5.], 883}, {
DateObject[{2019, 10, 21}, "Day", "Gregorian", -5.], 884}, {
DateObject[{2019, 10, 21}, "Day", "Gregorian", -5.], 885}, {
DateObject[{2019, 10, 22}, "Day", "Gregorian", -5.], 886}, {
DateObject[{2019, 10, 22}, "Day", "Gregorian", -5.], 887}, {
DateObject[{2019, 10, 22}, "Day", "Gregorian", -5.], 888}, {
DateObject[{2019, 10, 22}, "Day", "Gregorian", -5.], 889}, {
DateObject[{2019, 10, 22}, "Day", "Gregorian", -5.], 890}, {
DateObject[{2019, 10, 22}, "Day", "Gregorian", -5.], 891}, {
DateObject[{2019, 10, 22}, "Day", "Gregorian", -5.], 892}, {
DateObject[{2019, 10, 22}, "Day", "Gregorian", -5.], 893}, {
DateObject[{2019, 10, 22}, "Day", "Gregorian", -5.], 894}, {
DateObject[{2019, 10, 22}, "Day", "Gregorian", -5.], 895}, {
DateObject[{2019, 10, 23}, "Day", "Gregorian", -5.], 896}, {
DateObject[{2019, 10, 23}, "Day", "Gregorian", -5.], 897}, {
DateObject[{2019, 10, 23}, "Day", "Gregorian", -5.], 898}, {
DateObject[{2019, 10, 23}, "Day", "Gregorian", -5.], 899}, {
DateObject[{2019, 10, 24}, "Day", "Gregorian", -5.], 900}, {
DateObject[{2019, 10, 24}, "Day", "Gregorian", -5.], 901}, {
DateObject[{2019, 10, 24}, "Day", "Gregorian", -5.], 902}, {
DateObject[{2019, 10, 24}, "Day", "Gregorian", -5.], 903}, {
DateObject[{2019, 10, 25}, "Day", "Gregorian", -5.], 904}, {
DateObject[{2019, 10, 28}, "Day", "Gregorian", -5.], 905}, {
DateObject[{2019, 10, 28}, "Day", "Gregorian", -5.], 906}, {
DateObject[{2019, 11, 1}, "Day", "Gregorian", -5.], 907}, {
DateObject[{2019, 11, 1}, "Day", "Gregorian", -5.], 908}, {
DateObject[{2019, 11, 1}, "Day", "Gregorian", -5.], 909}, {
DateObject[{2019, 11, 1}, "Day", "Gregorian", -5.], 910}, {
DateObject[{2019, 11, 4}, "Day", "Gregorian", -6.], 911}, {
DateObject[{2019, 11, 4}, "Day", "Gregorian", -6.], 912}, {
DateObject[{2019, 11, 4}, "Day", "Gregorian", -6.], 913}, {
DateObject[{2019, 11, 4}, "Day", "Gregorian", -6.], 914}, {
DateObject[{2019, 11, 4}, "Day", "Gregorian", -6.], 915}, {
DateObject[{2019, 11, 4}, "Day", "Gregorian", -6.], 916}, {
DateObject[{2019, 11, 4}, "Day", "Gregorian", -6.], 917}, {
DateObject[{2019, 11, 4}, "Day", "Gregorian", -6.], 918}, {
DateObject[{2019, 11, 4}, "Day", "Gregorian", -6.], 919}, {
DateObject[{2019, 11, 4}, "Day", "Gregorian", -6.], 920}, {
DateObject[{2019, 11, 4}, "Day", "Gregorian", -6.], 921}, {
DateObject[{2019, 11, 5}, "Day", "Gregorian", -6.], 922}, {
DateObject[{2019, 11, 5}, "Day", "Gregorian", -6.], 923}, {
DateObject[{2019, 11, 5}, "Day", "Gregorian", -6.], 924}, {
DateObject[{2019, 11, 5}, "Day", "Gregorian", -6.], 925}, {
DateObject[{2019, 11, 6}, "Day", "Gregorian", -6.], 926}, {
DateObject[{2019, 11, 6}, "Day", "Gregorian", -6.], 927}, {
DateObject[{2019, 11, 6}, "Day", "Gregorian", -6.], 928}, {
DateObject[{2019, 11, 6}, "Day", "Gregorian", -6.], 929}, {
DateObject[{2019, 11, 6}, "Day", "Gregorian", -6.], 930}, {
DateObject[{2019, 11, 6}, "Day", "Gregorian", -6.], 931}, {
DateObject[{2019, 11, 6}, "Day", "Gregorian", -6.], 932}, {
DateObject[{2019, 11, 6}, "Day", "Gregorian", -6.], 933}, {
DateObject[{2019, 11, 7}, "Day", "Gregorian", -6.], 934}, {
DateObject[{2019, 11, 8}, "Day", "Gregorian", -6.], 935}, {
DateObject[{2019, 11, 8}, "Day", "Gregorian", -6.], 936}, {
DateObject[{2019, 11, 8}, "Day", "Gregorian", -6.], 937}, {
DateObject[{2019, 11, 8}, "Day", "Gregorian", -6.], 938}, {
DateObject[{2019, 11, 8}, "Day", "Gregorian", -6.], 939}, {
DateObject[{2019, 11, 11}, "Day", "Gregorian", -6.], 940}, {
DateObject[{2019, 11, 11}, "Day", "Gregorian", -6.], 941}, {
DateObject[{2019, 11, 11}, "Day", "Gregorian", -6.], 942}, {
DateObject[{2019, 11, 11}, "Day", "Gregorian", -6.], 943}, {
DateObject[{2019, 11, 11}, "Day", "Gregorian", -6.], 944}, {
DateObject[{2019, 11, 11}, "Day", "Gregorian", -6.], 945}, {
DateObject[{2019, 11, 11}, "Day", "Gregorian", -6.], 946}, {
DateObject[{2019, 11, 12}, "Day", "Gregorian", -6.], 947}, {
DateObject[{2019, 11, 13}, "Day", "Gregorian", -6.], 948}, {
DateObject[{2019, 11, 13}, "Day", "Gregorian", -6.], 949}, {
DateObject[{2019, 11, 13}, "Day", "Gregorian", -6.], 950}, {
DateObject[{2019, 11, 13}, "Day", "Gregorian", -6.], 951}, {
DateObject[{2019, 11, 13}, "Day", "Gregorian", -6.], 952}, {
DateObject[{2019, 11, 14}, "Day", "Gregorian", -6.], 953}, {
DateObject[{2019, 11, 14}, "Day", "Gregorian", -6.], 954}, {
DateObject[{2019, 11, 14}, "Day", "Gregorian", -6.], 955}, {
DateObject[{2019, 11, 15}, "Day", "Gregorian", -6.], 956}, {
DateObject[{2019, 11, 15}, "Day", "Gregorian", -6.], 957}, {
DateObject[{2019, 11, 15}, "Day", "Gregorian", -6.], 958}, {
DateObject[{2019, 11, 15}, "Day", "Gregorian", -6.], 959}, {
DateObject[{2019, 11, 18}, "Day", "Gregorian", -6.], 960}, {
DateObject[{2019, 11, 18}, "Day", "Gregorian", -6.], 961}, {
DateObject[{2019, 11, 18}, "Day", "Gregorian", -6.], 962}, {
DateObject[{2019, 11, 18}, "Day", "Gregorian", -6.], 963}, {
DateObject[{2019, 11, 18}, "Day", "Gregorian", -6.], 964}, {
DateObject[{2019, 11, 18}, "Day", "Gregorian", -6.], 965}, {
DateObject[{2019, 11, 19}, "Day", "Gregorian", -6.], 966}, {
DateObject[{2019, 11, 19}, "Day", "Gregorian", -6.], 967}, {
DateObject[{2019, 11, 19}, "Day", "Gregorian", -6.], 968}, {
DateObject[{2019, 11, 20}, "Day", "Gregorian", -6.], 969}, {
DateObject[{2019, 11, 20}, "Day", "Gregorian", -6.], 970}, {
DateObject[{2019, 11, 20}, "Day", "Gregorian", -6.], 971}, {
DateObject[{2019, 11, 20}, "Day", "Gregorian", -6.], 972}, {
DateObject[{2019, 11, 20}, "Day", "Gregorian", -6.], 973}, {
DateObject[{2019, 11, 20}, "Day", "Gregorian", -6.], 974}, {
DateObject[{2019, 11, 20}, "Day", "Gregorian", -6.], 975}, {
DateObject[{2019, 11, 20}, "Day", "Gregorian", -6.], 976}, {
DateObject[{2019, 11, 20}, "Day", "Gregorian", -6.], 977}, {
DateObject[{2019, 11, 20}, "Day", "Gregorian", -6.], 978}, {
DateObject[{2019, 11, 21}, "Day", "Gregorian", -6.], 979}, {
DateObject[{2019, 11, 21}, "Day", "Gregorian", -6.], 980}, {
DateObject[{2019, 11, 21}, "Day", "Gregorian", -6.], 981}, {
DateObject[{2019, 11, 22}, "Day", "Gregorian", -6.], 982}, {
DateObject[{2019, 11, 25}, "Day", "Gregorian", -6.], 983}, {
DateObject[{2019, 11, 25}, "Day", "Gregorian", -6.], 984}, {
DateObject[{2019, 12, 2}, "Day", "Gregorian", -6.], 985}, {
DateObject[{2019, 12, 2}, "Day", "Gregorian", -6.], 986}, {
DateObject[{2019, 12, 3}, "Day", "Gregorian", -6.], 987}, {
DateObject[{2019, 12, 3}, "Day", "Gregorian", -6.], 988}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 989}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 990}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 991}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 992}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 993}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 994}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 995}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 996}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 997}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 998}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 999}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 1000}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 1001}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 1002}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 1003}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 1004}, {
DateObject[{2019, 12, 4}, "Day", "Gregorian", -6.], 1005}, {
DateObject[{2019, 12, 5}, "Day", "Gregorian", -6.], 1006}, {
DateObject[{2019, 12, 5}, "Day", "Gregorian", -6.], 1007}, {
DateObject[{2019, 12, 5}, "Day", "Gregorian", -6.], 1008}, {
DateObject[{2019, 12, 6}, "Day", "Gregorian", -6.], 1009}, {
DateObject[{2019, 12, 6}, "Day", "Gregorian", -6.], 1010}, {
DateObject[{2019, 12, 6}, "Day", "Gregorian", -6.], 1011}, {
DateObject[{2019, 12, 6}, "Day", "Gregorian", -6.], 1012}, {
DateObject[{2019, 12, 6}, "Day", "Gregorian", -6.], 1013}, {
DateObject[{2019, 12, 12}, "Day", "Gregorian", -6.], 1014}, {
DateObject[{2019, 12, 13}, "Day", "Gregorian", -6.], 1015}, {
DateObject[{2019, 12, 13}, "Day", "Gregorian", -6.], 1016}, {
DateObject[{2019, 12, 13}, "Day", "Gregorian", -6.], 1017}, {
DateObject[{2019, 12, 13}, "Day", "Gregorian", -6.], 1018}, {
DateObject[{2019, 12, 13}, "Day", "Gregorian", -6.], 1019}, {
DateObject[{2019, 12, 13}, "Day", "Gregorian", -6.], 1020}, {
DateObject[{2019, 12, 16}, "Day", "Gregorian", -6.], 1021}, {
DateObject[{2019, 12, 16}, "Day", "Gregorian", -6.], 1022}, {
DateObject[{2019, 12, 16}, "Day", "Gregorian", -6.], 1023}, {
DateObject[{2019, 12, 16}, "Day", "Gregorian", -6.], 1024}, {
DateObject[{2019, 12, 16}, "Day", "Gregorian", -6.], 1025}, {
DateObject[{2019, 12, 16}, "Day", "Gregorian", -6.], 1026}, {
DateObject[{2019, 12, 16}, "Day", "Gregorian", -6.], 1027}, {
DateObject[{2019, 12, 16}, "Day", "Gregorian", -6.], 1028}, {
DateObject[{2019, 12, 17}, "Day", "Gregorian", -6.], 1029}, {
DateObject[{2019, 12, 17}, "Day", "Gregorian", -6.], 1030}, {
DateObject[{2019, 12, 17}, "Day", "Gregorian", -6.], 1031}, {
DateObject[{2019, 12, 17}, "Day", "Gregorian", -6.], 1032}, {
DateObject[{2019, 12, 17}, "Day", "Gregorian", -6.], 1033}, {
DateObject[{2019, 12, 18}, "Day", "Gregorian", -6.], 1034}, {
DateObject[{2019, 12, 18}, "Day", "Gregorian", -6.], 1035}, {
DateObject[{2019, 12, 18}, "Day", "Gregorian", -6.], 1036}, {
DateObject[{2019, 12, 19}, "Day", "Gregorian", -6.], 1037}, {
DateObject[{2019, 12, 19}, "Day", "Gregorian", -6.], 1038}, {
DateObject[{2019, 12, 19}, "Day", "Gregorian", -6.], 1039}, {
DateObject[{2019, 12, 19}, "Day", "Gregorian", -6.], 1040}, {
DateObject[{2019, 12, 19}, "Day", "Gregorian", -6.], 1041}, {
DateObject[{2019, 12, 20}, "Day", "Gregorian", -6.], 1042}, {
DateObject[{2019, 12, 20}, "Day", "Gregorian", -6.], 1043}, {
DateObject[{2019, 12, 20}, "Day", "Gregorian", -6.], 1044}, {
DateObject[{2019, 12, 20}, "Day", "Gregorian", -6.], 1045}, {
DateObject[{2019, 12, 24}, "Day", "Gregorian", -6.], 1046}, {
DateObject[{2019, 12, 26}, "Day", "Gregorian", -6.], 1047}, {
DateObject[{2019, 12, 26}, "Day", "Gregorian", -6.], 1048}, {
DateObject[{2019, 12, 26}, "Day", "Gregorian", -6.], 1049}, {
DateObject[{2019, 12, 26}, "Day", "Gregorian", -6.], 1050}, {
DateObject[{2019, 12, 27}, "Day", "Gregorian", -6.], 1051}, {
DateObject[{2019, 12, 27}, "Day", "Gregorian", -6.], 1052}, {
DateObject[{2019, 12, 27}, "Day", "Gregorian", -6.], 1053}, {
DateObject[{2019, 12, 27}, "Day", "Gregorian", -6.], 1054}, {
DateObject[{2019, 12, 30}, "Day", "Gregorian", 1.], 1055}, {
DateObject[{2019, 12, 30}, "Day", "Gregorian", 1.], 1056}, {
DateObject[{2019, 12, 31}, "Day", "Gregorian", -6.], 1057}, {
DateObject[{2019, 12, 31}, "Day", "Gregorian", -6.], 1058}, {
DateObject[{2020, 1, 2}, "Day", "Gregorian", -6.], 1059}, {
DateObject[{2020, 1, 2}, "Day", "Gregorian", -6.], 1060}, {
DateObject[{2020, 1, 2}, "Day", "Gregorian", -6.], 1061}, {
DateObject[{2020, 1, 3}, "Day", "Gregorian", -6.], 1062}, {
DateObject[{2020, 1, 3}, "Day", "Gregorian", -6.], 1063}, {
DateObject[{2020, 1, 6}, "Day", "Gregorian", -6.], 1064}, {
DateObject[{2020, 1, 9}, "Day", "Gregorian", -6.], 1065}, {
DateObject[{2020, 1, 9}, "Day", "Gregorian", -6.], 1066}, {
DateObject[{2020, 1, 10}, "Day", "Gregorian", -6.], 1067}, {
DateObject[{2020, 1, 10}, "Day", "Gregorian", -6.], 1068}, {
DateObject[{2020, 1, 13}, "Day", "Gregorian", -6.], 1069}, {
DateObject[{2020, 1, 13}, "Day", "Gregorian", -6.], 1070}, {
DateObject[{2020, 1, 13}, "Day", "Gregorian", -6.], 1071}, {
DateObject[{2020, 1, 16}, "Day", "Gregorian", -6.], 1072}, {
DateObject[{2020, 1, 17}, "Day", "Gregorian", -6.], 1073}, {
DateObject[{2020, 1, 17}, "Day", "Gregorian", -6.], 1074}, {
DateObject[{2020, 1, 17}, "Day", "Gregorian", -6.], 1075}, {
DateObject[{2020, 1, 17}, "Day", "Gregorian", -6.], 1076}, {
DateObject[{2020, 1, 17}, "Day", "Gregorian", -6.], 1077}, {
DateObject[{2020, 1, 17}, "Day", "Gregorian", -6.], 1078}, {
DateObject[{2020, 1, 20}, "Day", "Gregorian", -6.], 1079}, {
DateObject[{2020, 1, 20}, "Day", "Gregorian", -6.], 1080}, {
DateObject[{2020, 1, 20}, "Day", "Gregorian", -6.], 1081}, {
DateObject[{2020, 1, 23}, "Day", "Gregorian", -6.], 1082}, {
DateObject[{2020, 1, 23}, "Day", "Gregorian", -6.], 1083}, {
DateObject[{2020, 1, 27}, "Day", "Gregorian", -6.], 1084}, {
DateObject[{2020, 1, 27}, "Day", "Gregorian", -6.], 1085}, {
DateObject[{2020, 1, 27}, "Day", "Gregorian", -6.], 1086}, {
DateObject[{2020, 1, 27}, "Day", "Gregorian", -6.], 1087}, {
DateObject[{2020, 1, 30}, "Day", "Gregorian", -6.], 1088}, {
DateObject[{2020, 1, 30}, "Day", "Gregorian", -6.], 1089}, {
DateObject[{2020, 2, 3}, "Day", "Gregorian", -8.], 1090}, {
DateObject[{2020, 2, 3}, "Day", "Gregorian", -6.], 1091}, {
DateObject[{2020, 2, 4}, "Day", "Gregorian", -6.], 1092}, {
DateObject[{2020, 2, 5}, "Day", "Gregorian", -6.], 1093}, {
DateObject[{2020, 2, 5}, "Day", "Gregorian", -6.], 1094}, {
DateObject[{2020, 2, 5}, "Day", "Gregorian", -6.], 1095}, {
DateObject[{2020, 2, 5}, "Day", "Gregorian", -6.], 1096}, {
DateObject[{2020, 2, 5}, "Day", "Gregorian", -6.], 1097}, {
DateObject[{2020, 2, 6}, "Day", "Gregorian", -6.], 1098}, {
DateObject[{2020, 2, 7}, "Day", "Gregorian", -6.], 1099}, {
DateObject[{2020, 2, 7}, "Day", "Gregorian", -6.], 1100}, {
DateObject[{2020, 2, 13}, "Day", "Gregorian", -6.], 1101}, {
DateObject[{2020, 2, 13}, "Day", "Gregorian", -6.], 1102}, {
DateObject[{2020, 2, 13}, "Day", "Gregorian", -6.], 1103}, {
DateObject[{2020, 2, 13}, "Day", "Gregorian", -6.], 1104}, {
DateObject[{2020, 2, 13}, "Day", "Gregorian", -6.], 1105}, {
DateObject[{2020, 2, 14}, "Day", "Gregorian", -6.], 1106}, {
DateObject[{2020, 2, 14}, "Day", "Gregorian", -6.], 1107}, {
DateObject[{2020, 2, 17}, "Day", "Gregorian", -6.], 1108}, {
DateObject[{2020, 2, 17}, "Day", "Gregorian", -6.], 1109}, {
DateObject[{2020, 2, 18}, "Day", "Gregorian", -6.], 1110}, {
DateObject[{2020, 2, 18}, "Day", "Gregorian", -6.], 1111}, {
DateObject[{2020, 2, 18}, "Day", "Gregorian", -6.], 1112}, {
DateObject[{2020, 2, 18}, "Day", "Gregorian", -6.], 1113}, {
DateObject[{2020, 2, 18}, "Day", "Gregorian", -6.], 1114}, {
DateObject[{2020, 2, 18}, "Day", "Gregorian", -6.], 1115}, {
DateObject[{2020, 2, 20}, "Day", "Gregorian", -6.], 1116}, {
DateObject[{2020, 2, 20}, "Day", "Gregorian", -6.], 1117}, {
DateObject[{2020, 2, 21}, "Day", "Gregorian", -6.], 1118}, {
DateObject[{2020, 2, 24}, "Day", "Gregorian", -6.], 1119}, {
DateObject[{2020, 2, 24}, "Day", "Gregorian", -6.], 1120}, {
DateObject[{2020, 2, 24}, "Day", "Gregorian", -6.], 1121}, {
DateObject[{2020, 2, 24}, "Day", "Gregorian", -6.], 1122}, {
DateObject[{2020, 2, 24}, "Day", "Gregorian", -6.], 1123}, {
DateObject[{2020, 2, 24}, "Day", "Gregorian", -6.], 1124}, {
DateObject[{2020, 2, 24}, "Day", "Gregorian", -6.], 1125}, {
DateObject[{2020, 2, 24}, "Day", "Gregorian", -6.], 1126}, {
DateObject[{2020, 2, 24}, "Day", "Gregorian", -6.], 1127}, {
DateObject[{2020, 2, 24}, "Day", "Gregorian", -6.], 1128}, {
DateObject[{2020, 2, 24}, "Day", "Gregorian", -6.], 1129}, {
DateObject[{2020, 2, 25}, "Day", "Gregorian", -6.], 1130}, {
DateObject[{2020, 2, 25}, "Day", "Gregorian", -6.], 1131}, {
DateObject[{2020, 2, 25}, "Day", "Gregorian", -6.], 1132}, {
DateObject[{2020, 2, 26}, "Day", "Gregorian", -6.], 1133}, {
DateObject[{2020, 2, 26}, "Day", "Gregorian", -6.], 1134}, {
DateObject[{2020, 2, 26}, "Day", "Gregorian", -6.], 1135}, {
DateObject[{2020, 2, 26}, "Day", "Gregorian", -6.], 1136}, {
DateObject[{2020, 2, 26}, "Day", "Gregorian", -6.], 1137}, {
DateObject[{2020, 2, 26}, "Day", "Gregorian", -6.], 1138}, {
DateObject[{2020, 2, 26}, "Day", "Gregorian", -6.], 1139}, {
DateObject[{2020, 2, 26}, "Day", "Gregorian", -6.], 1140}, {
DateObject[{2020, 2, 26}, "Day", "Gregorian", -6.], 1141}, {
DateObject[{2020, 2, 26}, "Day", "Gregorian", -6.], 1142}, {
DateObject[{2020, 2, 26}, "Day", "Gregorian", -6.], 1143}, {
DateObject[{2020, 2, 26}, "Day", "Gregorian", -6.], 1144}, {
DateObject[{2020, 2, 27}, "Day", "Gregorian", -6.], 1145}, {
DateObject[{2020, 2, 27}, "Day", "Gregorian", -6.], 1146}, {
DateObject[{2020, 2, 27}, "Day", "Gregorian", -6.], 1147}, {
DateObject[{2020, 2, 27}, "Day", "Gregorian", -6.], 1148}, {
DateObject[{2020, 2, 27}, "Day", "Gregorian", -6.], 1149}, {
DateObject[{2020, 2, 28}, "Day", "Gregorian", -6.], 1150}, {
DateObject[{2020, 2, 28}, "Day", "Gregorian", -6.], 1151}, {
DateObject[{2020, 2, 28}, "Day", "Gregorian", -6.], 1152}, {
DateObject[{2020, 2, 28}, "Day", "Gregorian", -6.], 1153}, {
DateObject[{2020, 2, 28}, "Day", "Gregorian", -6.], 1154}, {
DateObject[{2020, 2, 28}, "Day", "Gregorian", -6.], 1155}, {
DateObject[{2020, 3, 2}, "Day", "Gregorian", -6.], 1156}, {
DateObject[{2020, 3, 2}, "Day", "Gregorian", -6.], 1157}, {
DateObject[{2020, 3, 2}, "Day", "Gregorian", -6.], 1158}, {
DateObject[{2020, 3, 2}, "Day", "Gregorian", -6.], 1159}, {
DateObject[{2020, 3, 3}, "Day", "Gregorian", -6.], 1160}, {
DateObject[{2020, 3, 3}, "Day", "Gregorian", -6.], 1161}, {
DateObject[{2020, 3, 3}, "Day", "Gregorian", -6.], 1162}, {
DateObject[{2020, 3, 4}, "Day", "Gregorian", -6.], 1163}, {
DateObject[{2020, 3, 4}, "Day", "Gregorian", -6.], 1164}, {
DateObject[{2020, 3, 4}, "Day", "Gregorian", -6.], 1165}, {
DateObject[{2020, 3, 4}, "Day", "Gregorian", -6.], 1166}, {
DateObject[{2020, 3, 4}, "Day", "Gregorian", -6.], 1167}, {
DateObject[{2020, 3, 4}, "Day", "Gregorian", -6.], 1168}, {
DateObject[{2020, 3, 4}, "Day", "Gregorian", -6.], 1169}, {
DateObject[{2020, 3, 4}, "Day", "Gregorian", -6.], 1170}, {
DateObject[{2020, 3, 5}, "Day", "Gregorian", -6.], 1171}, {
DateObject[{2020, 3, 6}, "Day", "Gregorian", -6.], 1172}, {
DateObject[{2020, 3, 6}, "Day", "Gregorian", -6.], 1173}, {
DateObject[{2020, 3, 6}, "Day", "Gregorian", -6.], 1174}, {
DateObject[{2020, 3, 6}, "Day", "Gregorian", -6.], 1175}, {
DateObject[{2020, 3, 6}, "Day", "Gregorian", -6.], 1176}, {
DateObject[{2020, 3, 6}, "Day", "Gregorian", -6.], 1177}, {
DateObject[{2020, 3, 9}, "Day", "Gregorian", -5.], 1178}, {
DateObject[{2020, 3, 9}, "Day", "Gregorian", -5.], 1179}, {
DateObject[{2020, 3, 9}, "Day", "Gregorian", -5.], 1180}, {
DateObject[{2020, 3, 9}, "Day", "Gregorian", -5.], 1181}, {
DateObject[{2020, 3, 9}, "Day", "Gregorian", -5.], 1182}, {
DateObject[{2020, 3, 9}, "Day", "Gregorian", -5.], 1183}, {
DateObject[{2020, 3, 9}, "Day", "Gregorian", -5.], 1184}, {
DateObject[{2020, 3, 9}, "Day", "Gregorian", -5.], 1185}, {
DateObject[{2020, 3, 9}, "Day", "Gregorian", -5.], 1186}, {
DateObject[{2020, 3, 9}, "Day", "Gregorian", -5.], 1187}, {
DateObject[{2020, 3, 10}, "Day", "Gregorian", -5.], 1188}, {
DateObject[{2020, 3, 10}, "Day", "Gregorian", -5.], 1189}, {
DateObject[{2020, 3, 10}, "Day", "Gregorian", -5.], 1190}, {
DateObject[{2020, 3, 10}, "Day", "Gregorian", -5.], 1191}, {
DateObject[{2020, 3, 10}, "Day", "Gregorian", -5.], 1192}, {
DateObject[{2020, 3, 10}, "Day", "Gregorian", -5.], 1193}, {
DateObject[{2020, 3, 10}, "Day", "Gregorian", -5.], 1194}, {
DateObject[{2020, 3, 10}, "Day", "Gregorian", -5.], 1195}, {
DateObject[{2020, 3, 11}, "Day", "Gregorian", -5.], 1196}, {
DateObject[{2020, 3, 11}, "Day", "Gregorian", -5.], 1197}, {
DateObject[{2020, 3, 11}, "Day", "Gregorian", -5.], 1198}, {
DateObject[{2020, 3, 11}, "Day", "Gregorian", -5.], 1199}, {
DateObject[{2020, 3, 11}, "Day", "Gregorian", -5.], 1200}, {
DateObject[{2020, 3, 13}, "Day", "Gregorian", -5.], 1201}, {
DateObject[{2020, 3, 13}, "Day", "Gregorian", -5.], 1202}, {
DateObject[{2020, 3, 13}, "Day", "Gregorian", -5.], 1203}, {
DateObject[{2020, 3, 16}, "Day", "Gregorian", -5.], 1204}, {
DateObject[{2020, 3, 16}, "Day", "Gregorian", -5.], 1205}, {
DateObject[{2020, 3, 16}, "Day", "Gregorian", -5.], 1206}, {
DateObject[{2020, 3, 16}, "Day", "Gregorian", -5.], 1207}, {
DateObject[{2020, 3, 16}, "Day", "Gregorian", -5.], 1208}, {
DateObject[{2020, 3, 17}, "Day", "Gregorian", -5.], 1209}, {
DateObject[{2020, 3, 17}, "Day", "Gregorian", -5.], 1210}, {
DateObject[{2020, 3, 18}, "Day", "Gregorian", -5.], 1211}, {
DateObject[{2020, 3, 18}, "Day", "Gregorian", -5.], 1212}, {
DateObject[{2020, 3, 18}, "Day", "Gregorian", -5.], 1213}, {
DateObject[{2020, 3, 18}, "Day", "Gregorian", -5.], 1214}, {
DateObject[{2020, 3, 18}, "Day", "Gregorian", -5.], 1215}, {
DateObject[{2020, 3, 18}, "Day", "Gregorian", -5.], 1216}, {
DateObject[{2020, 3, 18}, "Day", "Gregorian", -5.], 1217}, {
DateObject[{2020, 3, 18}, "Day", "Gregorian", -5.], 1218}, {
DateObject[{2020, 3, 19}, "Day", "Gregorian", -5.], 1219}, {
DateObject[{2020, 3, 19}, "Day", "Gregorian", -5.], 1220}, {
DateObject[{2020, 3, 20}, "Day", "Gregorian", -5.], 1221}, {
DateObject[{2020, 3, 20}, "Day", "Gregorian", -5.], 1222}, {
DateObject[{2020, 3, 20}, "Day", "Gregorian", -5.], 1223}, {
DateObject[{2020, 3, 20}, "Day", "Gregorian", -5.], 1224}, {
DateObject[{2020, 3, 23}, "Day", "Gregorian", -5.], 1225}, {
DateObject[{2020, 3, 23}, "Day", "Gregorian", -5.], 1226}, {
DateObject[{2020, 3, 23}, "Day", "Gregorian", -5.], 1227}, {
DateObject[{2020, 3, 23}, "Day", "Gregorian", -5.], 1228}, {
DateObject[{2020, 3, 23}, "Day", "Gregorian", -5.], 1229}, {
DateObject[{2020, 3, 23}, "Day", "Gregorian", -5.], 1230}, {
DateObject[{2020, 3, 23}, "Day", "Gregorian", -5.], 1231}, {
DateObject[{2020, 3, 24}, "Day", "Gregorian", -5.], 1232}, {
DateObject[{2020, 3, 24}, "Day", "Gregorian", -5.], 1233}, {
DateObject[{2020, 3, 25}, "Day", "Gregorian", -5.], 1234}, {
DateObject[{2020, 3, 25}, "Day", "Gregorian", -5.], 1235}, {
DateObject[{2020, 3, 25}, "Day", "Gregorian", -5.], 1236}, {
DateObject[{2020, 3, 25}, "Day", "Gregorian", -5.], 1237}, {
DateObject[{2020, 3, 25}, "Day", "Gregorian", -5.], 1238}, {
DateObject[{2020, 3, 25}, "Day", "Gregorian", -5.], 1239}, {
DateObject[{2020, 3, 26}, "Day", "Gregorian", -5.], 1240}, {
DateObject[{2020, 3, 26}, "Day", "Gregorian", -5.], 1241}, {
DateObject[{2020, 3, 26}, "Day", "Gregorian", -5.], 1242}, {
DateObject[{2020, 3, 26}, "Day", "Gregorian", -5.], 1243}, {
DateObject[{2020, 3, 27}, "Day", "Gregorian", -5.], 1244}, {
DateObject[{2020, 3, 27}, "Day", "Gregorian", -5.], 1245}, {
DateObject[{2020, 3, 27}, "Day", "Gregorian", -5.], 1246}, {
DateObject[{2020, 3, 27}, "Day", "Gregorian", -5.], 1247}, {
DateObject[{2020, 3, 27}, "Day", "Gregorian", -5.], 1248}, {
DateObject[{2020, 3, 30}, "Day", "Gregorian", -5.], 1249}, {
DateObject[{2020, 3, 30}, "Day", "Gregorian", -5.], 1250}, {
DateObject[{2020, 3, 31}, "Day", "Gregorian", -5.], 1251}, {
DateObject[{2020, 3, 31}, "Day", "Gregorian", -5.], 1252}, {
DateObject[{2020, 3, 31}, "Day", "Gregorian", -5.], 1253}, {
DateObject[{2020, 3, 31}, "Day", "Gregorian", -5.], 1254}, {
DateObject[{2020, 3, 31}, "Day", "Gregorian", -5.], 1255}, {
DateObject[{2020, 3, 31}, "Day", "Gregorian", -5.], 1256}, {
DateObject[{2020, 3, 31}, "Day", "Gregorian", -5.], 1257}, {
DateObject[{2020, 3, 31}, "Day", "Gregorian", -5.], 1258}, {
DateObject[{2020, 4, 1}, "Day", "Gregorian", -5.], 1259}, {
DateObject[{2020, 4, 1}, "Day", "Gregorian", -5.], 1260}, {
DateObject[{2020, 4, 1}, "Day", "Gregorian", -5.], 1261}, {
DateObject[{2020, 4, 1}, "Day", "Gregorian", -5.], 1262}, {
DateObject[{2020, 4, 1}, "Day", "Gregorian", -5.], 1263}, {
DateObject[{2020, 4, 1}, "Day", "Gregorian", -5.], 1264}, {
DateObject[{2020, 4, 1}, "Day", "Gregorian", -5.], 1265}, {
DateObject[{2020, 4, 1}, "Day", "Gregorian", -5.], 1266}, {
DateObject[{2020, 4, 1}, "Day", "Gregorian", -5.], 1267}, {
DateObject[{2020, 4, 1}, "Day", "Gregorian", -5.], 1268}, {
DateObject[{2020, 4, 1}, "Day", "Gregorian", -5.], 1269}, {
DateObject[{2020, 4, 1}, "Day", "Gregorian", -5.], 1270}, {
DateObject[{2020, 4, 2}, "Day", "Gregorian", -5.], 1271}, {
DateObject[{2020, 4, 2}, "Day", "Gregorian", -5.], 1272}, {
DateObject[{2020, 4, 2}, "Day", "Gregorian", -5.], 1273}, {
DateObject[{2020, 4, 2}, "Day", "Gregorian", -5.], 1274}, {
DateObject[{2020, 4, 2}, "Day", "Gregorian", -5.], 1275}, {
DateObject[{2020, 4, 2}, "Day", "Gregorian", -5.], 1276}, {
DateObject[{2020, 4, 2}, "Day", "Gregorian", -5.], 1277}, {
DateObject[{2020, 4, 3}, "Day", "Gregorian", -5.], 1278}, {
DateObject[{2020, 4, 3}, "Day", "Gregorian", -5.], 1279}, {
DateObject[{2020, 4, 3}, "Day", "Gregorian", -5.], 1280}, {
DateObject[{2020, 4, 3}, "Day", "Gregorian", -4.], 1281}, {
DateObject[{2020, 4, 6}, "Day", "Gregorian", -5.], 1282}, {
DateObject[{2020, 4, 6}, "Day", "Gregorian", -5.], 1283}, {
DateObject[{2020, 4, 6}, "Day", "Gregorian", -5.], 1284}, {
DateObject[{2020, 4, 6}, "Day", "Gregorian", -5.], 1285}, {
DateObject[{2020, 4, 6}, "Day", "Gregorian", -5.], 1286}, {
DateObject[{2020, 4, 6}, "Day", "Gregorian", -5.], 1287}, {
DateObject[{2020, 4, 6}, "Day", "Gregorian", -5.], 1288}, {
DateObject[{2020, 4, 6}, "Day", "Gregorian", -5.], 1289}, {
DateObject[{2020, 4, 6}, "Day", "Gregorian", -5.], 1290}, {
DateObject[{2020, 4, 6}, "Day", "Gregorian", -5.], 1291}, {
DateObject[{2020, 4, 7}, "Day", "Gregorian", -5.], 1292}, {
DateObject[{2020, 4, 7}, "Day", "Gregorian", -5.], 1293}, {
DateObject[{2020, 4, 7}, "Day", "Gregorian", -5.], 1294}, {
DateObject[{2020, 4, 8}, "Day", "Gregorian", -5.], 1295}, {
DateObject[{2020, 4, 8}, "Day", "Gregorian", -5.], 1296}, {
DateObject[{2020, 4, 8}, "Day", "Gregorian", -5.], 1297}, {
DateObject[{2020, 4, 8}, "Day", "Gregorian", -5.], 1298}, {
DateObject[{2020, 4, 8}, "Day", "Gregorian", -5.], 1299}, {
DateObject[{2020, 4, 8}, "Day", "Gregorian", -5.], 1300}, {
DateObject[{2020, 4, 8}, "Day", "Gregorian", -5.], 1301}, {
DateObject[{2020, 4, 9}, "Day", "Gregorian", -5.], 1302}, {
DateObject[{2020, 4, 9}, "Day", "Gregorian", -5.], 1303}, {
DateObject[{2020, 4, 9}, "Day", "Gregorian", -5.], 1304}, {
DateObject[{2020, 4, 9}, "Day", "Gregorian", -5.], 1305}, {
DateObject[{2020, 4, 10}, "Day", "Gregorian", -5.], 1306}, {
DateObject[{2020, 4, 10}, "Day", "Gregorian", -5.], 1307}, {
DateObject[{2020, 4, 10}, "Day", "Gregorian", -5.], 1308}, {
DateObject[{2020, 4, 10}, "Day", "Gregorian", -5.], 1309}, {
DateObject[{2020, 4, 10}, "Day", "Gregorian", -5.], 1310}, {
DateObject[{2020, 4, 10}, "Day", "Gregorian", -5.], 1311}, {
DateObject[{2020, 4, 10}, "Day", "Gregorian", -5.], 1312}, {
DateObject[{2020, 4, 10}, "Day", "Gregorian", -5.], 1313}, {
DateObject[{2020, 4, 10}, "Day", "Gregorian", -5.], 1314}, {
DateObject[{2020, 4, 10}, "Day", "Gregorian", -5.], 1315}, {
DateObject[{2020, 4, 10}, "Day", "Gregorian", -5.], 1316}, {
DateObject[{2020, 4, 10}, "Day", "Gregorian", -5.], 1317}, {
DateObject[{2020, 4, 13}, "Day", "Gregorian", -5.], 1318}, {
DateObject[{2020, 4, 13}, "Day", "Gregorian", -5.], 1319}, {
DateObject[{2020, 4, 13}, "Day", "Gregorian", -5.], 1320}, {
DateObject[{2020, 4, 14}, "Day", "Gregorian", -5.], 1321}, {
DateObject[{2020, 4, 14}, "Day", "Gregorian", -5.], 1322}, {
DateObject[{2020, 4, 14}, "Day", "Gregorian", -5.], 1323}, {
DateObject[{2020, 4, 14}, "Day", "Gregorian", -5.], 1324}, {
DateObject[{2020, 4, 15}, "Day", "Gregorian", -5.], 1325}, {
DateObject[{2020, 4, 15}, "Day", "Gregorian", -5.], 1326}, {
DateObject[{2020, 4, 15}, "Day", "Gregorian", -5.], 1327}, {
DateObject[{2020, 4, 15}, "Day", "Gregorian", -5.], 1328}, {
DateObject[{2020, 4, 15}, "Day", "Gregorian", -5.], 1329}, {
DateObject[{2020, 4, 16}, "Day", "Gregorian", -5.], 1330}, {
DateObject[{2020, 4, 17}, "Day", "Gregorian", -5.], 1331}, {
DateObject[{2020, 4, 17}, "Day", "Gregorian", -5.], 1332}, {
DateObject[{2020, 4, 17}, "Day", "Gregorian", -5.], 1333}, {
DateObject[{2020, 4, 17}, "Day", "Gregorian", -5.], 1334}, {
DateObject[{2020, 4, 17}, "Day", "Gregorian", -5.], 1335}, {
DateObject[{2020, 4, 20}, "Day", "Gregorian", -5.], 1336}, {
DateObject[{2020, 4, 20}, "Day", "Gregorian", -5.], 1337}, {
DateObject[{2020, 4, 20}, "Day", "Gregorian", -5.], 1338}, {
DateObject[{2020, 4, 20}, "Day", "Gregorian", -5.], 1339}, {
DateObject[{2020, 4, 21}, "Day", "Gregorian", -5.], 1340}, {
DateObject[{2020, 4, 21}, "Day", "Gregorian", -5.], 1341}, {
DateObject[{2020, 4, 21}, "Day", "Gregorian", -5.], 1342}, {
DateObject[{2020, 4, 22}, "Day", "Gregorian", -5.], 1343}, {
DateObject[{2020, 4, 22}, "Day", "Gregorian", -5.], 1344}, {
DateObject[{2020, 4, 22}, "Day", "Gregorian", -5.], 1345}, {
DateObject[{2020, 4, 22}, "Day", "Gregorian", -5.], 1346}, {
DateObject[{2020, 4, 22}, "Day", "Gregorian", -5.], 1347}, {
DateObject[{2020, 4, 23}, "Day", "Gregorian", -5.], 1348}, {
DateObject[{2020, 4, 23}, "Day", "Gregorian", -5.], 1349}, {
DateObject[{2020, 4, 23}, "Day", "Gregorian", -5.], 1350}, {
DateObject[{2020, 4, 24}, "Day", "Gregorian", -5.], 1351}, {
DateObject[{2020, 4, 24}, "Day", "Gregorian", -5.], 1352}, {
DateObject[{2020, 4, 24}, "Day", "Gregorian", -5.], 1353}, {
DateObject[{2020, 4, 24}, "Day", "Gregorian", -5.], 1354}, {
DateObject[{2020, 4, 24}, "Day", "Gregorian", -5.], 1355}, {
DateObject[{2020, 4, 24}, "Day", "Gregorian", -5.], 1356}, {
DateObject[{2020, 4, 27}, "Day", "Gregorian", -5.], 1357}, {
DateObject[{2020, 4, 27}, "Day", "Gregorian", -5.], 1358}, {
DateObject[{2020, 4, 27}, "Day", "Gregorian", -5.], 1359}, {
DateObject[{2020, 4, 27}, "Day", "Gregorian", -5.], 1360}, {
DateObject[{2020, 4, 28}, "Day", "Gregorian", -5.], 1361}, {
DateObject[{2020, 4, 28}, "Day", "Gregorian", -5.], 1362}, {
DateObject[{2020, 4, 28}, "Day", "Gregorian", -5.], 1363}, {
DateObject[{2020, 4, 28}, "Day", "Gregorian", -5.], 1364}, {
DateObject[{2020, 4, 28}, "Day", "Gregorian", -5.], 1365}, {
DateObject[{2020, 4, 28}, "Day", "Gregorian", -5.], 1366}, {
DateObject[{2020, 4, 29}, "Day", "Gregorian", -5.], 1367}, {
DateObject[{2020, 4, 29}, "Day", "Gregorian", -5.], 1368}, {
DateObject[{2020, 4, 29}, "Day", "Gregorian", -5.], 1369}, {
DateObject[{2020, 4, 29}, "Day", "Gregorian", -5.], 1370}, {
DateObject[{2020, 4, 30}, "Day", "Gregorian", -5.], 1371}, {
DateObject[{2020, 5, 1}, "Day", "Gregorian", -5.], 1372}, {
DateObject[{2020, 5, 1}, "Day", "Gregorian", -5.], 1373}, {
DateObject[{2020, 5, 1}, "Day", "Gregorian", -5.], 1374}, {
DateObject[{2020, 5, 1}, "Day", "Gregorian", -5.], 1375}, {
DateObject[{2020, 5, 1}, "Day", "Gregorian", -5.], 1376}, {
DateObject[{2020, 5, 1}, "Day", "Gregorian", -5.], 1377}, {
DateObject[{2020, 5, 4}, "Day", "Gregorian", -5.], 1378}, {
DateObject[{2020, 5, 4}, "Day", "Gregorian", -5.], 1379}, {
DateObject[{2020, 5, 4}, "Day", "Gregorian", -5.], 1380}, {
DateObject[{2020, 5, 4}, "Day", "Gregorian", -5.], 1381}, {
DateObject[{2020, 5, 5}, "Day", "Gregorian", -5.], 1382}, {
DateObject[{2020, 5, 6}, "Day", "Gregorian", -5.], 1383}, {
DateObject[{2020, 5, 6}, "Day", "Gregorian", -5.], 1384}, {
DateObject[{2020, 5, 6}, "Day", "Gregorian", -5.], 1385}, {
DateObject[{2020, 5, 7}, "Day", "Gregorian", 3.], 1386}, {
DateObject[{2020, 5, 8}, "Day", "Gregorian", -5.], 1387}, {
DateObject[{2020, 5, 8}, "Day", "Gregorian", -5.], 1388}, {
DateObject[{2020, 5, 8}, "Day", "Gregorian", -5.], 1389}, {
DateObject[{2020, 5, 11}, "Day", "Gregorian", -5.], 1390}, {
DateObject[{2020, 5, 11}, "Day", "Gregorian", -5.], 1391}, {
DateObject[{2020, 5, 11}, "Day", "Gregorian", -5.], 1392}, {
DateObject[{2020, 5, 11}, "Day", "Gregorian", -5.], 1393}, {
DateObject[{2020, 5, 11}, "Day", "Gregorian", -5.], 1394}, {
DateObject[{2020, 5, 12}, "Day", "Gregorian", -5.], 1395}, {
DateObject[{2020, 5, 12}, "Day", "Gregorian", -5.], 1396}, {
DateObject[{2020, 5, 13}, "Day", "Gregorian", -5.], 1397}, {
DateObject[{2020, 5, 13}, "Day", "Gregorian", -5.], 1398}, {
DateObject[{2020, 5, 13}, "Day", "Gregorian", -5.], 1399}, {
DateObject[{2020, 5, 13}, "Day", "Gregorian", -5.], 1400}, {
DateObject[{2020, 5, 14}, "Day", "Gregorian", -5.], 1401}, {
DateObject[{2020, 5, 15}, "Day", "Gregorian", -5.], 1402}, {
DateObject[{2020, 5, 15}, "Day", "Gregorian", -5.], 1403}, {
DateObject[{2020, 5, 18}, "Day", "Gregorian", -5.], 1404}, {
DateObject[{2020, 5, 19}, "Day", "Gregorian", -5.], 1405}, {
DateObject[{2020, 5, 19}, "Day", "Gregorian", -5.], 1406}, {
DateObject[{2020, 5, 19}, "Day", "Gregorian", -5.], 1407}, {
DateObject[{2020, 5, 20}, "Day", "Gregorian", -5.], 1408}, {
DateObject[{2020, 5, 20}, "Day", "Gregorian", -5.], 1409}, {
DateObject[{2020, 5, 20}, "Day", "Gregorian", -5.], 1410}, {
DateObject[{2020, 5, 20}, "Day", "Gregorian", -5.], 1411}, {
DateObject[{2020, 5, 21}, "Day", "Gregorian", -5.], 1412}, {
DateObject[{2020, 5, 21}, "Day", "Gregorian", -5.], 1413}, {
DateObject[{2020, 5, 21}, "Day", "Gregorian", -5.], 1414}, {
DateObject[{2020, 5, 21}, "Day", "Gregorian", -5.], 1415}, {
DateObject[{2020, 5, 26}, "Day", "Gregorian", -5.], 1416}, {
DateObject[{2020, 5, 27}, "Day", "Gregorian", -5.], 1417}, {
DateObject[{2020, 5, 27}, "Day", "Gregorian", -5.], 1418}, {
DateObject[{2020, 5, 27}, "Day", "Gregorian", -5.], 1419}, {
DateObject[{2020, 5, 27}, "Day", "Gregorian", -5.], 1420}, {
DateObject[{2020, 5, 28}, "Day", "Gregorian", -5.], 1421}, {
DateObject[{2020, 5, 29}, "Day", "Gregorian", -5.], 1422}, {
DateObject[{2020, 5, 29}, "Day", "Gregorian", -5.], 1423}, {
DateObject[{2020, 6, 1}, "Day", "Gregorian", -5.], 1424}, {
DateObject[{2020, 6, 1}, "Day", "Gregorian", -5.], 1425}, {
DateObject[{2020, 6, 1}, "Day", "Gregorian", -5.], 1426}, {
DateObject[{2020, 6, 1}, "Day", "Gregorian", -5.], 1427}, {
DateObject[{2020, 6, 1}, "Day", "Gregorian", -5.], 1428}, {
DateObject[{2020, 6, 2}, "Day", "Gregorian", -5.], 1429}, {
DateObject[{2020, 6, 2}, "Day", "Gregorian", -5.], 1430}, {
DateObject[{2020, 6, 2}, "Day", "Gregorian", -5.], 1431}, {
DateObject[{2020, 6, 5}, "Day", "Gregorian", -5.], 1432}, {
DateObject[{2020, 6, 5}, "Day", "Gregorian", -5.], 1433}, {
DateObject[{2020, 6, 9}, "Day", "Gregorian", -5.], 1434}, {
DateObject[{2020, 6, 9}, "Day", "Gregorian", -5.], 1435}, {
DateObject[{2020, 6, 10}, "Day", "Gregorian", -5.], 1436}, {
DateObject[{2020, 6, 10}, "Day", "Gregorian", -5.], 1437}, {
DateObject[{2020, 6, 11}, "Day", "Gregorian", -5.], 1438}, {
DateObject[{2020, 6, 11}, "Day", "Gregorian", -5.], 1439}, {
DateObject[{2020, 6, 12}, "Day", "Gregorian", -5.], 1440}, {
DateObject[{2020, 6, 15}, "Day", "Gregorian", -5.], 1441}, {
DateObject[{2020, 6, 15}, "Day", "Gregorian", -5.], 1442}, {
DateObject[{2020, 6, 15}, "Day", "Gregorian", -5.], 1443}, {
DateObject[{2020, 6, 17}, "Day", "Gregorian", -5.], 1444}, {
DateObject[{2020, 6, 18}, "Day", "Gregorian", -5.], 1445}, {
DateObject[{2020, 6, 18}, "Day", "Gregorian", -5.], 1446}, {
DateObject[{2020, 6, 19}, "Day", "Gregorian", -5.], 1447}, {
DateObject[{2020, 6, 19}, "Day", "Gregorian", -5.], 1448}, {
DateObject[{2020, 6, 19}, "Day", "Gregorian", -5.], 1449}, {
DateObject[{2020, 6, 22}, "Day", "Gregorian", -5.], 1450}, {
DateObject[{2020, 6, 22}, "Day", "Gregorian", -5.], 1451}},
  PlotLabel -> "Functions in the WFR"]]

Random

As you might imagine, we get a lot of random stuff submitted. Literally random. Here are some random entries that put the “fun” in “Function Repository”:

ResourceFunction
&#10005

ResourceFunction["RandomMandala"][]
ResourceFunction
&#10005

ResourceFunction["RandomMaze"][25]
ResourceFunction
&#10005

ResourceFunction["RandomMondrian"][]

Games

When we first opened the Function Repository for submissions, several of the first submissions were games. Some people had made Wolfram Language versions of games in Mathematica years ago and were waiting for a good opportunity to share them. The quality assurance testing of these was not a chore (send more, please).

ResourceFunction
&#10005

ResourceFunction["DisplaySudokuPuzzle"][
 Last@ResourceFunction["GenerateSudokuPuzzle"][]]
ResourceFunction
&#10005

ResourceFunction["LightsOutGame"][8]
ResourceFunction
&#10005

ResourceFunction["Minesweeper"][]
ResourceFunction
&#10005

ResourceFunction["Play2048"][];
ResourceFunction
&#10005

ResourceFunction["PolyominoesGame"][]

The Greatest, Most Fun Function of All

The greatest, most fun function of all is the one you are going to send us. Sorry, I know that was lame and disappointing. I needed to use this section header so that you would stop playing Minesweeper and finish reading. The functions here are fun, but I know there are other hidden gems out there, waiting on lonely hard drives, yearning for the chance to be discovered.

So it’s time to get serious about fun. We want your silly, absurd, stupid functions. I can’t remain the only person with a Function Repository entry that shares both their name and sense of humor. Chase, Harmony, Sue, do your worst. Submit them. I promise we will laugh with you, not at you.

Get full access to the latest Wolfram Language functionality with a Mathematica 12.1 or Wolfram|One trial, and submit your own functions to the Wolfram Function Repository.
Engage with the code in this post by downloading the Wolfram Notebook
]]> https://blog.wolfram.com:443/2020/08/25/you-cant-have-a-function-repository-without-having-somefun/feed/ 0 Generative Adversarial Networks (GANs) in the Wolfram Language https://blog.wolfram.com:443/2020/08/18/generative-adversarial-networks-gans-in-the-wolfram-language/ https://blog.wolfram.com:443/2020/08/18/generative-adversarial-networks-gans-in-the-wolfram-language/#comments Tue, 18 Aug 2020 16:35:02 +0000 Jérôme Louradour https://blog.internal.wolfram.com/?p=68015 Generative Adversarial Networks (GANs) in the Wolfram Language

A noteworthy achievement of artificial intelligence, since it is driven by artificial neural networks under the label deep learning, is the ability to create artistic works to generate images, text and sounds. At the core of this breakthrough is a basic method to train neural networks that was introduced by Ian Goodfellow in 2014 and was called by Yann LeCun “the most interesting idea in the last 10 years in machine learning”: generative adversarial networks (GANs). A GAN is a way to train a generative network that produces realistic-looking fake samples out of a latent seed, which can be some arbitrary data or random numbers sampled from a simple distribution. Let’s look at how to do so with some of the new capabilities developed for Mathematica Version 12.1.

Adversarial training found many applications, particularly in image processing: photo editing, style transfer, colorization, inpainting, super resolution, generation of images from a text, etc. It can also improve the accuracy of image recognition models by augmenting the data to train them. GANs can also be used just for fun. Look how these networks available in the Wolfram Neural Net Repository are able to change apples into oranges:

NetModel
&#10005

NetModel["CycleGAN Apple-to-Orange Translation Trained on ImageNet \
Competition Data"][CloudGet["https://wolfr.am/OJr6cvJh"]]

Just for fun, we tested the networks by giving them a silly-looking partial horse picture, and they passed! The image was still recognized as a horse, and we were able to change it into a zebra:

NetModel
&#10005

NetModel["CycleGAN Horse-to-Zebra Translation Trained on ImageNet \
Competition Data"][CloudGet["https://wolfr.am/OJr6ClZ8"]]

Artificial Neural Networks

Before diving into the details of GANs, let’s say some words about neural networks, which are at the core of deep learning. A neural network is simply a function with a lot of parameters that can be trained by gradient descent to minimize a loss. The function is usually expressed as a composition of basic functions, called layers. Neural networks are modular and able to model an infinity of functions by combining different layers, just as you can build an infinity of LEGO constructions by stacking building blocks. Their flexibility explains a part of their success.

The optimization of neural networks is now well mastered since machine learning has been democratized with user-friendly optimization toolboxes, such as NetTrain in the Wolfram Language. The main technical challenges that remain when implementing a deep learning approach for a given application, besides collecting the relevant data, consist of:

  1. Designing the neural architecture (number of parameters, connectivity, …)
  2. Choosing a sensible loss function

GANs address the latter. They provide a good strategy to build a loss suitable for generating realistic-looking data, without having to model the underlying distribution of real data.

GANs in a Nutshell

The principle of GANs is that the loss for the generative network is given by another network: the discriminative network. These two networks play a zero-sum game, like in tug-of-war.

The “discriminator” learns to distinguish fake samples from real ones, and the “generator” learns to fool the discriminator with fake samples that look real. The generator yields a fake sample by simply applying a forward pass to a latent seed that can be an array of random numbers or some arbitrary data.

The crux in a GAN is finding an equilibrium. If the discriminator starts to perform too poorly in comparison to the generator, it will be fooled forever and the generator will stop learning anything, and vice versa. It is like when one opponent in a tug-of-war game lets the rope go: he loses the game, and nothing prevents the other from falling.

Besides, because GAN losses are artificial and constantly changing over the training as the discriminator changes, none of the losses that are optimized are good indicators of whether the generator is doing a good job or not. Only extreme loss values can tell that GAN training is doomed. Finding good metrics to monitor GAN training and evaluate generated samples is an open question whose answer highly depends on the application.

The following chart depicts how the discriminator and the generator are applied:

Chart 1

The adversarial training procedure of this pair of networks and losses consists of iteratively looping over the following steps after a random (or pretrained) initialization of the two networks:

Discriminator update:

  1. Sample a batch of m real data
  2. Sample m latent seeds, and generate m fakes
  3. Update the discriminator to minimize "LossReal" and "LossFake"

Generator update:

  1. Sample m latent seeds, and generate m fakes
  2. Update the generator to maximize "LossFake"

The generator and the discriminator are never updated at the same time, which is actually crucial for good convergence behavior. Several forms of loss are possible, and the most popular ones are:

Jensen–Shannon

Wasserstein

GANs in the Wolfram Language

The design of GANs in the Wolfram Language took a lot of brainstorming sessions. For a long time, there was hesitation between using a simple-to-use and high-level interface based on NetTrain, or a more flexible but lower-level solution where machine learning experts could write custom training loops and run them efficiently. Developers finally opted for the former (a user-friendly design in Version 12.1), while continuing to work on more flexible and complicated syntaxes as well. I am now happy to demonstrate how easy it can be to write GAN experiments in the Wolfram Language’s high-level symbolic neural network framework.

In the end, we can unlock GAN training by introducing only two new symbols:

  • NetGANOperator, an operator that wraps a generator and a discriminator into a training network that computes the losses and that can be given directly as a first argument to NetTrain
  • TrainingUpdateSchedule, an option to NetTrain to apply a custom update schedule, as in the training loop of the aforementioned pseudo-code

The options TrainingProgressFunction and TrainingProgressReporting are also very useful to implement custom monitoring of the generator performance, like showing a compilation of generated samples at regular steps of the training.

LearningRateMultipliers can also be useful to invert or negate gradients, which can unlock more customized versions than vanilla GANs. This option was revisited in Version 12.1 so that learning rate multipliers can be directly attached to any learnable array, layer or network. It is the first option for the training that is introduced in layers and networks. For many applications, it is actually quite handy to attach learning rate multipliers while building a network, rather than to have to attach them to network subparts at each call of NetTrain.

How NetGANOperator Works

Let’s build a NetGANOperator and understand what is going inside this operator.

First, a generator needs to be defined. Like this deep neural network, which takes a vector of one hundred random values and produces an RGB image of size 224×224, reusing pretrained layers from an existing CycleGAN model:

pretrained = NetTake
&#10005

pretrained =
  NetTake[NetModel[
    "CycleGAN Horse-to-Zebra Translation Trained on ImageNet \
Competition Data"], {10, All}];

generator =
 NetChain[{LinearLayer["Input" -> 100], pretrained,
   ResizeLayer[{224, 224}]}, "Output" -> NetDecoder["Image"]]

Only the first layer of this generator has to be initialized, and it is ready to produce images out of random numbers sampled from a simple distribution:

generator = NetInitialize
&#10005

generator = NetInitialize[generator]
generator
&#10005

generator[RandomVariate[NormalDistribution[], 100]]

Next, a discriminator is needed, like this deep neural network adapted from a popular image classifier:

discriminator = NetChain
&#10005

discriminator =
 NetChain[{NetModel[
    "ResNet-101 Trained on ImageNet Competition Data"],
   AggregationLayer[Max, 1]}]

This discriminator is a binary classifier that produces the probability of an input RGB image of size 224×224 to be real, i.e. not faked by the generator:

AssociationMap
&#10005

AssociationMap[discriminator, [CloudGet[https://wolfr.am/OJzBFkms"], {{0, 224.}, {224., 0}}, {0., 1.},
ColorFunction->RGBColor],
BoxForm`ImageTag["Real32", ColorSpace -> "RGB", Interleaving -> False],
Selectable->False],
DefaultBaseStyle->"ImageGraphics",
ImageSize->{61.999999999998934`, Automatic},
ImageSizeRaw->{224., 224.},
PlotRange->{{0, 224.}, {0, 224.}}]\),
  CloudGet["https://wolfr.am/OJr7RbQp"]}]

With a generator and a discriminator on hand, we are now ready to combine the two nets using NetGANOperator:

gan = NetGANOperator
&#10005

gan = NetGANOperator[{generator, discriminator}, "JensenShannon"]

This operator takes two inputs: latent random numbers and real images. It computes generated images by applying the generator to the latent seeds as well as to the loss values on the discriminator’s outputs, respectively, for the generated images and the real ones:

gan
&#10005

gan[<|"Sample" -> CloudGet["https://wolfr.am/OJADw9OW], {{
         0, 162.48}, {162.48, 0}}, {0, 255},
ColorFunction->RGBColor,
ImageResolution->{300, 300}],
BoxForm`ImageTag[
       "Byte", ColorSpace -> "RGB", Interleaving -> True,
        MetaInformation -> Association[
         "Exif" -> Association[
           "Orientation" -> Association[
             "CameraTopOrientation" -> Top, "Mirrored" -> False],
            "XResolution" -> 300, "YResolution" -> 300,
            "ResolutionUnit" -> "Inch",
            "YCbCrPositioning" -> "Centered", "ExifTag" -> 102,
            "ExifVersion" -> "2.10",
            "ComponentsConfiguration" -> "YCbCr",
            "FlashpixVersion" -> "1.00",
            "ColorSpace" -> "Uncalibrated", "PixelXDimension" -> 677,
            "PixelYDimension" -> 677],
          "XMP" -> Association[
           "DublinCoreSchema" -> Association[
             "Creator" -> "DANIEL POCKETT/EPA-EFE/REX",
              "Description" -> "x-default", "Rights" -> "x-default",
              "Subject" -> "INTERNATIONAL, TIGER, DAY, AT, MELBOURNE, \
ZOO, AUSTRALIA, 29, JUL, 2019, INDRAH, A, NINEYEAROLD, SUMATRAN, \
DURING, JULY, 82258863", "Title" -> "x-default"],
            "IPTCCoreSchema" -> Association[
             "CountryCode" -> "AUS", "Scene" -> "general view"], 

            "PhotoshopSchema" -> Association[
             "Category" -> "HUM", "City" -> "MELBOURNE",
              "Country" -> "Australia",
              "Credit" -> "DANIEL POCKETT/EPA-EFE/REX",
              "DateCreated" -> DateObject[{2019, 7, 29, 15, 8, 38.},
                "Instant", "Gregorian", 2.],
              "Headline" -> "International Tiger Day at Melbourne \
Zoo, Australia - 29 Jul 2019", "Source" -> "REX",
              "SupplementalCategories" -> "ANIMALS"]]]],
Selectable->False],
DefaultBaseStyle->"ImageGraphics",
ImageSize->{61.95333333333272, Automatic},
ImageSizeRaw->{162.48, 162.48},
PlotRange->{{0, 162.48}, {0, 162.48}}]\),
  "Latent" -> NumericArray[CompressedData["
1:eJwBugFF/iFib1JmAgAAAHMIAAAAUmF3QXJyYXlTBgAAAFJlYWwzMmwBAAAA
ZAAAAPj3Kz8OjyG/e4t5P+K7SL7pqn8/Yzxyv4rno7+wNsO+O4mjP3OxH7/K
Mrc+RmIhv5hjpb46EVU/oUODvGmEvb43HRg/lPTSvhjzBL/tVcw/A2GBPtqF
Ir+Ok6U/6Cj1Pty5KD7brT0/YTBdv01Ndb/2kvY+qtySvZaI6D8QvGm/u8JP
P8ef+z7X8Hi86e7KPzGPTL+FDxA+BnG8v980sr9jjQY+xlCdvfy+CT7tuR4+
08sMv1dcsL84/Y0/D9YPwI8ITz/7gXq/4Q//vylRxz+jRNi/98KSP6PwAj4X
+ew/CsY4voKAvr+Gj+8/B6ahv5HqhD8z+ku/5bynv0zPCz93hXm+i3+kv3/n
BcDV7j6/TRGrvtvonD9IHZi+86DCvvDIBb+3GKy+KNApP9CeDb9JAZ2+1tHD
PzVZgL4RLHy/eFyMvhQBhL+Q4Jk+GbLfPpiLV785Psw/dx6Lv6filD7OU4I/
3SnGP5iszj9j2HS+8++lvTfoZj4/CJW9NJ1Qvvqboj/frTO/2ORmP1pZDr3o
jdoF
"],"Real32"]|>]

NetGANOperator is not just a generative network, but a training network; it is ready to be passed directly as a first argument to NetTrain, and the generator can be easily extracted from it. NetGANOperator can also be combined into a NetGraph to build a more complex training network for approaches like CycleGAN, for instance. CycleGAN involves two pairs of generators and discriminators learned conjointly, one generator yielding fakes in domain A from latent domain B, and the other generator yielding fakes in domain B from latent domain A:

Chart 2

(See the Applications section of the NetGANOperator documentation for details on how to train CycleGAN in the Wolfram Language.)

An important detail is that the gradient coming from the discriminator back into the generator is negated, so the generator tries to maximize "LossFake" while the discriminator tries to minimize it. NetGANOperator is pretty equivalent to the following NetGraph, which uses the gradient-negated generator and shares the discriminator at two places (one applied to the real images and one fooled with fake generated images):

ganAsGraph = NetGraph
&#10005

ganAsGraph =
 NetGraph[<|
   "Generator" ->
    NetReplacePart[generator, LearningRateMultipliers -> -1],
   "Discriminator" -> NetInsertSharedArrays[discriminator],
   "FooledDiscriminator" -> NetInsertSharedArrays[discriminator],
   "LossReal" -> ElementwiseLayer[Function[-Log[#]]],
   "LossFake" -> ElementwiseLayer[Function[-Log[1 - #]]]|>,
  {NetPort["Sample"] -> (
    "Discriminator" -> ("LossReal" -> NetPort["LossReal"])),
   NetPort["Latent"] -> (
    "Generator" -> (
     "FooledDiscriminator" -> ("LossFake" -> NetPort["LossFake"]))),
   "Generator" -> NetPort["GeneratedFake"]}]

Intermediate values of this workflow can be computed like this:

ganAsGraph
&#10005

ganAsGraph[<|"Sample" -> CloudGet["https://wolfr.am/OJADw9OW"], {{
         0, 162.48}, {162.48, 0}}, {0, 255},
ColorFunction->RGBColor,
ImageResolution->{300, 300}],
BoxForm`ImageTag[
       "Byte", ColorSpace -> "RGB", Interleaving -> True,
        MetaInformation -> Association[
         "Exif" -> Association[
           "Orientation" -> Association[
             "CameraTopOrientation" -> Top, "Mirrored" -> False],
            "XResolution" -> 300, "YResolution" -> 300,
            "ResolutionUnit" -> "Inch",
            "YCbCrPositioning" -> "Centered", "ExifTag" -> 102,
            "ExifVersion" -> "2.10",
            "ComponentsConfiguration" -> "YCbCr",
            "FlashpixVersion" -> "1.00",
            "ColorSpace" -> "Uncalibrated", "PixelXDimension" -> 677,
            "PixelYDimension" -> 677],
          "XMP" -> Association[
           "DublinCoreSchema" -> Association[
             "Creator" -> "DANIEL POCKETT/EPA-EFE/REX",
              "Description" -> "x-default", "Rights" -> "x-default",
              "Subject" -> "INTERNATIONAL, TIGER, DAY, AT, MELBOURNE, \
ZOO, AUSTRALIA, 29, JUL, 2019, INDRAH, A, NINEYEAROLD, SUMATRAN, \
DURING, JULY, 82258863", "Title" -> "x-default"],
            "IPTCCoreSchema" -> Association[
             "CountryCode" -> "AUS", "Scene" -> "general view"], 

            "PhotoshopSchema" -> Association[
             "Category" -> "HUM", "City" -> "MELBOURNE",
              "Country" -> "Australia",
              "Credit" -> "DANIEL POCKETT/EPA-EFE/REX",
              "DateCreated" -> DateObject[{2019, 7, 29, 15, 8, 38.},
                "Instant", "Gregorian", 2.],
              "Headline" -> "International Tiger Day at Melbourne \
Zoo, Australia - 29 Jul 2019", "Source" -> "REX",
              "SupplementalCategories" -> "ANIMALS"]]]],
Selectable->False],
DefaultBaseStyle->"ImageGraphics",
ImageSize->{61.95333333333497, Automatic},
ImageSizeRaw->{162.48, 162.48},
PlotRange->{{0, 162.48}, {0, 162.48}}]\),
  "Latent" -> NumericArray[CompressedData["
1:eJwBugFF/iFib1JmAgAAAHMIAAAAUmF3QXJyYXlTBgAAAFJlYWwzMmwBAAAA
ZAAAAPj3Kz8OjyG/e4t5P+K7SL7pqn8/Yzxyv4rno7+wNsO+O4mjP3OxH7/K
Mrc+RmIhv5hjpb46EVU/oUODvGmEvb43HRg/lPTSvhjzBL/tVcw/A2GBPtqF
Ir+Ok6U/6Cj1Pty5KD7brT0/YTBdv01Ndb/2kvY+qtySvZaI6D8QvGm/u8JP
P8ef+z7X8Hi86e7KPzGPTL+FDxA+BnG8v980sr9jjQY+xlCdvfy+CT7tuR4+
08sMv1dcsL84/Y0/D9YPwI8ITz/7gXq/4Q//vylRxz+jRNi/98KSP6PwAj4X
+ew/CsY4voKAvr+Gj+8/B6ahv5HqhD8z+ku/5bynv0zPCz93hXm+i3+kv3/n
BcDV7j6/TRGrvtvonD9IHZi+86DCvvDIBb+3GKy+KNApP9CeDb9JAZ2+1tHD
PzVZgL4RLHy/eFyMvhQBhL+Q4Jk+GbLfPpiLV785Psw/dx6Lv6filD7OU4I/
3SnGP5iszj9j2HS+8++lvTfoZj4/CJW9NJ1Qvvqboj/frTO/2ORmP1pZDr3o
jdoF
"],"Real32"]|>, NetPort[All]]

What TrainingUpdateSchedule Does

Training this in accordance with the typical GAN training loop in the aforementioned pseudo-code can be done by specifying a custom schedule of updates with the new option TrainingUpdateSchedule. Simply using TrainingUpdateSchedule→{"Discriminator","Generator"} means that the updates will be done alternatively to the "Discriminator" subnetwork part and to the "Generator" subnetwork part, which is enough for vanilla GAN.

To check this, let’s launch a dummy training with the option TrainingProgressFunction to collect weight values from the discriminator and the generator along the optimization process:

weights = {};NetTrain
&#10005

weights = {};

NetTrain[NetGANOperator[{
LinearLayer[{}],
LinearLayer[{}]}, "Latent" -> "Real"], BlockRandom[
 SeedRandom[13]; AssociationMap[RandomVariate[
NormalDistribution[], 100]& , {"Sample", "Latent"}]], All,
 TrainingUpdateSchedule -> {"Discriminator", "Generator"},
 TrainingProgressFunction -> {AppendTo[weights, Flatten[
Map[Normal,
NetExtract[
Slot["Net"], {{"Discriminator", "Weights"}, {
         "Generator", "Weights"}}]]]] &,
   "Interval" -> Quantity[1, "Batches"]},
 Sequence[
 MaxTrainingRounds -> 10, LearningRate -> 0.01, RandomSeeding -> 2008]
 ]

The progress of the weights shows how they are updated alternatively in the discriminator and the generator. The steps show when weight updates occur:

ListStepPlot
&#10005

ListStepPlot[Transpose[weights],
 PlotLabels -> {"Discriminator", "Generator"}, Filling -> Axis]

It’s also easy to specify that the discriminator should be updated three times, then the generator two times and so on:

weights = {};NetTrain
&#10005

weights = {};

NetTrain[Sequence[
NetGANOperator[{
LinearLayer[{}],
LinearLayer[{}]}, "Latent" -> "Real"],
BlockRandom[SeedRandom[13]; AssociationMap[RandomVariate[
NormalDistribution[], 100]& , {"Sample", "Latent"}]]],
  TrainingUpdateSchedule -> {"Discriminator" -> 3, "Generator" -> 2},
  Sequence[TrainingProgressFunction -> {AppendTo[weights,
Flatten[
Map[Normal,
NetExtract[
Slot["Net"], {{"Discriminator", "Weights"}, {
          "Generator", "Weights"}}]]]]& ,
     "Interval" -> Quantity[1, "Batches"]}, MaxTrainingRounds -> 10,
   LearningRate -> 0.01, RandomSeeding -> 2008]];

ListStepPlot[Transpose[weights], Sequence[
 PlotLabels -> {"Discriminator", "Generator"}, Filling -> Axis]]

Training GANs to Generate New Pokémon Characters

To see how to articulate all these pieces together and learn a generative model with adversarial training, let’s have a bit of fun and try to generate new Pokémon characters. There are 911 images of individual Pokémon characters available in the Wolfram Knowledgebase, which can be obtained efficiently using:

EntityPrefetch
&#10005

EntityPrefetch[EntityProperty["Pokemon", "Image"]]; pokemons = DeleteMissing@ EntityValue[EntityList["Pokemon"], EntityProperty["Pokemon", "Image"]];

We can make these images square by padding as needed, and then resize as 64×64 thumbnails:

pokemons = Map
&#10005

pokemons = Map[ImageResize[ImagePad[#, Block[{width, height}, {width, height} = ImageDimensions[Slot[RowBox[{"CloudGet", "[", "\"https://wolfr.am/OJr981NW\"", "]"}]]]; {Table[Round[Ramp[height - width]/2], 2], Table[Round[Ramp[width - height]/2], 2]}]], {64, 64}] &, pokemons]
{\!\(\*GraphicsBox
&#10005











Inspired by the advances in deep convolutional GANs (DCGANs, as mentioned in Radford et. al, “Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks,” 2015), our generator will be a chain of DeconvolutionLayer interleaved with BatchNormalizationLayer and rectified linear units (ReLU):









					deconvolutionBlock = Function
				



					&#10005


deconvolutionBlock =
  Function[{numhiddens, size},
   NetChain[{DeconvolutionLayer[numhiddens, {5, 5},
      "Stride" -> {2, 2}, PaddingSize -> 1],
     PartLayer[{All, 1 ;; size, 1 ;; size}],
     BatchNormalizationLayer[], Ramp}]];

generator = NetChain[{
   NetChain[{{512, 4, 4}, BatchNormalizationLayer[], Ramp}],
   deconvolutionBlock[256, 8],
   deconvolutionBlock[128, 16],
   deconvolutionBlock[64, 32],
   DeconvolutionLayer[3, {5, 5}, "Stride" -> {2, 2}, PaddingSize -> 1,
     "Weights" -> 0], PartLayer[{All, 1 ;; 64, 1 ;; 64}],
   ElementwiseLayer[Tanh[#]*0.5 + .5 &]},
  "Input" -> 32,
  "Output" -> NetDecoder["Image"]]










Our discriminator will be a chain of ConvolutionLayer interleaved with BatchNormalizationLayer and leaky ReLU:









					convolutionBlock = Function
				



					&#10005


convolutionBlock =
  Function[{numhiddens, size},
   NetChain[{ConvolutionLayer[numhiddens, {5, 5}, "Stride" -> {2, 2},
      PaddingSize -> 2], BatchNormalizationLayer[],
     ElementwiseLayer[Max[#1, 0.2` #1] &]}]];

discriminator = NetChain[{
   ElementwiseLayer[-1 + 2*# &],
   convolutionBlock[64, 32],
   convolutionBlock[128, 16],
   convolutionBlock[256, 8],
   convolutionBlock[512, 4],
   LinearLayer[{}, "Weights" -> 0, "Biases" -> None],
   LogisticSigmoid},
  "Input" -> NetEncoder[{"Image", {64, 64}, "RGB"}]]










We can apprehend that training a generator of cartoonish images with less than a thousand images will be challenging. Therefore, we have to start on the right foot and follow all possible good practices. One of them is to first pretrain the generator and the discriminator so that the optimization of GAN will start with good conditions. Let’s try for this to train generative and discriminative subparts in an autoencoder scheme. The goal of an autoencoder is simply to reproduce the input image after compressing it to a vector of 32 values, which will be the latent space of our GAN:









					autoencoder = NetChain
				



					&#10005


autoencoder =
 NetChain[<|
   "compressor" -> NetTake[discriminator, {All, 5}],
   "latent" ->
    NetChain[{LinearLayer[32], BatchNormalizationLayer[]}],
   "generator" -> generator|>]










Autoencoder optimization can consist of minimizing the mean squared error between input and output arrays of pixel RGB values:









					autoencoderTrainer = NetGraph
				



					&#10005


autoencoderTrainer =
 NetGraph[<|"autoencoder" -> autoencoder,
   "MSE" ->
    MeanSquaredLossLayer[]|>, {{"autoencoder", NetPort["Input"]} ->
    "MSE"}]










An autoencoder to compress images of Pokémon can be trained in a few minutes on a GPU NVIDIA graphics card:









					autoEncoderTrainResults = NetTrain
				



					&#10005


autoEncoderTrainResults =
 NetTrain[autoencoderTrainer, pokemons, All, TargetDevice -> "GPU",
  MaxTrainingRounds -> 300]
trained = autoEncoderTrainResults["TrainedNet"];










The trained autoencoder is able to reproduce the input with a bit of blur:









					autoencoder = NetReplacePart
				



					&#10005


autoencoder =
 NetReplacePart[
  trained[["autoencoder"]], {"Input" ->
    NetEncoder[{"Image", {64, 64}}], "Output" -> NetDecoder["Image"]}]

















					AssociationMap
				



					&#10005


AssociationMap[autoencoder, RandomSample[pokemons, 5]]










At least, we are now sure that the generator architecture is able to generate real Pokémon images out of 32 random values. Pretrained layers can be extracted from this autoencoder to build a generator and a discriminator that are more than ready to be adversarially trained:









					generator = NetReplacePart
				



					&#10005


generator =
 NetReplacePart[autoencoder[["generator"]],
  "Output" -> NetDecoder["Image"]]

















					discriminator = NetAppend
				



					&#10005


discriminator =
 NetAppend[autoencoder[["compressor"]],
  LinearLayer[{}, "Weights" -> 0, "Biases" -> None],
  "Input" -> NetEncoder[{"Image", {64, 64}}]]

















					NetGANOperator
				



					&#10005


NetGANOperator[{generator, discriminator}]










The training of GANs involves being able to infinitely sample random latent values. This can be done by using the generator syntax, as explained in the out-of-core training tutorial, where the third argument of NetTrain is a custom generator function yielding batches of inputs for the training network. For our Pokémon training, the generator function can be written as:









					datagen = Function
				



					&#10005


datagen = Function[
   <|"Sample" -> RandomSample[pokemons, #BatchSize],
    "Latent" -> getRandomLatent[#BatchSize]|>];










… where getRandomLatent is a custom function that samples random numbers from a simple latent distribution—for instance:









					getRandomLatent = Function
				



					&#10005


getRandomLatent = Function[batchSize, RandomReal[1, {batchSize, 32}]];










After some preliminary experiments, we found out that better results can be achieved by normalizing the value in the latent space so that it is contained in the unit sphere. We achieve this using the nonlinear squashing function introduced in Hinton’s capsule networks:









					squash = NetGraph
				



					&#10005


squash = NetGraph[Sequence[{
ElementwiseLayer[#^2& ],
AggregationLayer[Total, 1],
ElementwiseLayer[Sqrt[#]/(1 + #)& ],
ReplicateLayer[Automatic],
ThreadingLayer[Times]}, {
   NetPort["Input"] -> (1 -> (2 -> (3 -> (4 -> 5)))),
    NetPort["Input"] -> 5}], "Input" -> {Automatic}]










This squashing function normalizes (latent random) vectors so that their norm never exceeds 1, and preserves the bell shape of the normal distribution, as shown here in two dimensions:









					Histogram3D@squash@RandomVariate
				



					&#10005


Histogram3D@squash@RandomVariate[NormalDistribution[], {5000, 2}]










We will use this custom latent random distribution:









					getRandomLatent = Function
				



					&#10005


getRandomLatent =
  Function[batchSize,
   squash@ RandomVariate[NormalDistribution[], {batchSize, 32}]];










For a batch size of 16, the inputs to NetGANOperator for each training update looks like this:









					MapAt
				



					&#10005


MapAt[ArrayPlot,
  datagen[<|"BatchSize" -> 16|>],
 "Latent"]










With two pretrained networks that have sensible architectures and a decent random-number generator, everything is now ready to train the GAN—except maybe the monitoring part. That must be done with a function that shows or records generated examples in order to judge how well the generator performs while training progresses:









					monitor = With
				



					&#10005


monitor = With[{latents = getRandomLatent[25]},
   Function[generator,
    ImageCollage[generator[latents], ImagePadding -> 1]]];










At the beginning of the training, generated images look like this:









					trainedGan = NetTrain

					
				



					&#10005


trainedGan =
  NetTrain[NetGANOperator[{generator, discriminator}], datagen,
   TrainingUpdateSchedule -> {"Discriminator" -> 3, "Generator" -> 3},
    BatchSize -> 64, MaxTrainingRounds -> 20000,
   TargetDevice -> "GPU",
   TrainingProgressReporting -> {monitor[
       NetExtract[#Net, "Generator"]] &,
     "Interval" -> Quantity[500, "Rounds"]}];










After a few hours of training on a GPU, the GAN has converged and we can extract the trained generator:









					generator = trainedGan
				



					&#10005


generator = trainedGan[["Generator"]]










In the end, here are the new kinds of Pokémon characters that are produced:









					newPokemons = generator
				



					&#10005


newPokemons = generator[getRandomLatent[112]];ImageAssemble[Partition[SortBy[newPokemons, DominantColors[#, Sequence[1, Masking -> Binarize[ColorDistance[Slot[RowBox[{"CloudGet", "[", "\"https://wolfr.am/OJrbVrv3\"", "]"}]], White], 0.1]]] &], 8], Sequence[Spacings -> 10, ImageSize -> Full]]










I hope you can see Pokémon here the same way you can see animals in the clouds sometimes. One thousand Pokémon thumbnails were manifestly not enough for a computer to learn all the features that make a Pokémon credible in terms of physiological constitution. But it was enough to learn the texture, the associations of colors and the kinds of curves to make fishy, birdy and doggy shapes in the cartoon world.


This Pokémon trial was not so bad, and there are several possible ways to improve on this first approach and get a higher level of detail. For example, progressive growing of GANs is promising; it would consist of a loop of NetTrain, growing the resolution iteratively by adding layers to the generator and the discriminator. But let’s stop here with Pokémon. The message is that a GAN is not a completely out-of-the-box tool where you put in your data, click a button and just wait. We tried to make it as easy as possible in the Wolfram Language, for example with sensible default option values:


    

  • If not specified, the loss function (second argument of NetGANOperator) is automatically set to either "JensenShannon" or "Wasserstein", depending on the output layers of the generator
    • 

  • The default optimization parameters of NetTrain (learning rate and momentum) are automatically tuned to values that are commonly used for GANs, when some NetGANOperator is detected inside the net to train
    • 



But still… Many details about the network architecture, the distribution of the latent space and the optimization schedule have to be taken care of depending on the targeted application.


On the Impact of GANs on Society


The use of GANs to create deep fakes, where a person is superimposed over an image or a video—possibly in an embarrassing situation—raises techno-ethics questions. The same sort of controversy emerged when transformers (a new kind of neural net architecture) achieved incredible performance in artificial text generation, in turn awaking fears of escalation of fake news on the web.


What about GANs in this situation? It seems that they constitute new, powerful tools to assist and augment human artistic creativity. Their accomplishments arouse the curiosity of everybody. But the “fakeness” of generated results also raises, justifiably, questions about possible misuses. The black box aspect of deep learning also calls for further research on model interpretability of GANs. Obviously, an innovation in machine learning like GANs makes us feel closer to the point at which computer AIs pass the Turing test, bringing with that all the fears of catastrophic scenarios that could happen in case humans lose control.


It’s not new that a powerful technology can be misused by malicious people. And it’s important that people in the research community are aware of the possible deviations of the new, powerful technology they publish. But in the end, all the actors related to the use of these technologies (not only researchers, who are just the early actors) must be well intentioned and make efforts to ensure that automatic algorithms don’t get out of control. What’s particularly sensitive with artificial generative models is that being benevolent is not enough to avoid a negative impact. The creators of the models must benchmark correctly the performances of the published models and models in production to avoid problems like unintended social biases (a model that discriminates by characteristics such as race, age, gender, etc.). But they cannot be responsible for the bad intentions of others. So the role of the researchers is to educate users of their publications toward the mastery of standard techniques to control social biases and ease model interpretability in general.


Try It Yourself


Future developments on NetGANOperator will include extensions to multiclass classification and to generative models with multiple inputs. Post your best GAN experiments in the comments or share them on Wolfram Community. Questions or suggestions for additional functionality are also welcome.


Wolfram Neural Net Repsitory


Want to Go Further?







Engage with the code in this post by downloading the Wolfram Notebook




]]>
			https://blog.wolfram.com:443/2020/08/18/generative-adversarial-networks-gans-in-the-wolfram-language/feed/
		2
		
		
		Learn Linear Algebra in Five Hours Today with the Wolfram Language!
		https://blog.wolfram.com:443/2020/08/14/learn-linear-algebra-in-five-hours-today-with-the-wolfram-language/
		https://blog.wolfram.com:443/2020/08/14/learn-linear-algebra-in-five-hours-today-with-the-wolfram-language/#comments
		Fri, 14 Aug 2020 13:44:27 +0000
		Devendra Kapadia
				
		
		

		https://blog.internal.wolfram.com/?p=67892
		
			Learn Linear Algebra in Five Hours Today with the Wolfram Language!


Linear algebra is probably the easiest and the most useful branch of modern mathematics. Indeed, topics such as  matrices and linear equations are often taught in middle or high school. On the other hand, concepts and techniques from linear algebra underlie cutting-edge disciplines such as data science and quantum computation. And in the field of numerical analysis, everything is linear algebra!


Today, I am proud to announce a free interactive course, Introduction to Linear Algebra, that will help students all over the world to master this wonderful subject. The course uses the powerful functions for matrix operations in the Wolfram Language and addresses questions such as “How long would it take to solve a system of 500 linear equations?” or “How does data compression work?”


I invite you to start exploring the interactive course by clicking anywhere in the following image before reading the rest of this blog post.


Interactive course


Motivation from History


The ancient Babylonians and Chinese knew how to solve simple systems of linear equations with two or three equations. However, the first systematic method for solving linear systems was given in 1750 by Gabriel Cramer, who formulated a rule for solving such systems using determinants. This was followed by the 1810 work of Carl Friedrich Gauss, who developed the technique known as Gaussian elimination for solving linear systems. Next, in 1850, James Joseph Sylvester introduced the notion of a matrix to represent arrays of numbers such as those formed by the coefficients of a linear system. A few years later, around 1855, Arthur Cayley published his work on the theory of matrices and operations on them. Finally, in 1888, Giuseppe Peano  defined the notion of an abstract vector space, which plays a unifying role in modern linear algebra.


In keeping with the historical development, Introduction to Linear Algebra focuses on matrices and determinants, while vector spaces are discussed only when necessary during the course. 


Overview


Students taking this course will receive a thorough introduction to linear algebra including standard topics, such as linear systems, geometric transformations, matrix operations, determinants and eigenvalues. The course also includes a few advanced topics, such as the  singular value decomposition, one of the most valuable concepts in applied linear algebra. Here is a sneak peek at some of the topics in the course (shown in the left-hand column):


Course topics


I have worked hard to keep the course down to a reasonable length, and I expect that you will finish watching the 29 videos and also complete the five short quizzes in about five hours. (Hence the title of the blog post!)


Finally, I assume that the students are familiar with high-school algebra and basic trigonometry, but no calculus is required for this course. 


The next few sections of the blog post will describe the different components of the course in detail.


Lessons


The heart of the course is a set of 25 lessons, beginning with “What Is Linear Algebra?”. This introductory lesson includes a discussion of the different approaches to linear algebra, followed by a brief history of the subject and an outline of the course. Here is a short excerpt from the video for this lesson:


A short excerpt from “What Is Linear Algebra?”


Further lessons begin with an overview of the topic (for example, eigenvalues and eigenvectors), followed by a discussion of the key concepts interspersed with examples that illustrate the ideas using Wolfram Language functions for matrix computations.


The videos range from 7 to 12 minutes in length, and each video is accompanied by a transcript notebook displayed on the right-hand side of the screen. You can copy and paste Wolfram Language input directly from the transcript notebook to the embedded scratch notebook to try the examples for yourself.


Exercises


Each lesson is accompanied by a set of five exercises to review the concepts covered during the lesson. Since this course is designed for independent study, a detailed solution is given for all exercises. The following shows an exercise from lesson 14 on applications of determinants:


Exercise 5


The notebooks with the exercises are interactive, so students can try variations of each problem in the Wolfram Cloud. In particular, they are encouraged to change the entries of  the matrices, vary the dimensions, etc. and experience the awesome power of the Wolfram Language for matrix computations.


Application Sessions


Each section of the course includes an application session, which discusses a real-world application of the ideas developed in that section. There are four application sessions on polynomial interpolation, economic models, quantum entanglement and data compression, respectively. The following is a short excerpt from the video for data compression:


A short excerpt from “Data Compression”


These application sessions celebrate the great success of linear algebra techniques in engineering, computer science and other fields. I would like to thank Roger Germundsson, director of R&D at Wolfram, who suggested their inclusion in the course.


Quizzes


 Each section of the course ends with a short, multiple-choice quiz with five problems. The quiz problems are roughly at the same level as those discussed in the lessons, and a student who reviews the section carefully should have no difficulty in doing well on the quiz. 


Quiz


Students will receive instant feedback about their responses to the quiz questions, and they are encouraged to try any method (including hand or computer calculations) to solve them.


Course Certificate


I strongly encourage students to watch all the lessons and attempt the quizzes in the recommended sequence, since each topic in the course relies on earlier concepts and techniques. You can request a certificate of completion, pictured here, at the end of the course. A course certificate is achieved after watching all the lesson and application videos and passing all the quizzes. It represents proficiency in the fundamentals of linear algebra and will add value to your resume or social media profile.


Certificate


There is also an optional final exam at the end of the course. You can receive an advanced level of certification by passing this exam.


A Building Block for Success


A mastery of the fundamental concepts of linear algebra is crucial for students of data science, engineering and other fields. I hope that Introduction to Linear Algebra will help you to achieve such a mastery and will drive you toward success in your chosen field. I have enjoyed teaching the course and welcome any comments regarding the current course as well as suggestions for future courses.


Acknowledgements


I would like to thank Vishaal Ganesan, Knarik Hovhannisyan, Veronica Mullen, Joyce Tracewell, Aram Manaselyan, Tim Shedelbower, Harry Calkins,  Amruta Behera, Andy Hunt and Cassidy Hinkle for their dedicated work on various aspects (lessons, exercises, videos, etc.) of the course.








Need help with calculus? Register for Wolfram U’s daily calculus study group.







]]>
			https://blog.wolfram.com:443/2020/08/14/learn-linear-algebra-in-five-hours-today-with-the-wolfram-language/feed/
		6
		
		
		Playing Cards with Alice and Bob: Using Secure Multi‑Party Computation and the Wolfram Language to Determine a Winner
		https://blog.wolfram.com:443/2020/08/06/alice-and-bob-play-a-game-of-cards/
		https://blog.wolfram.com:443/2020/08/06/alice-and-bob-play-a-game-of-cards/#comments
		Thu, 06 Aug 2020 16:58:57 +0000
		Arnoud Buzing
				
		
		

		https://blog.internal.wolfram.com/?p=67404
		
			Alice and Bob Play a Game of Cards


While catching up with my old friends Alice and Bob on Zoom a few days ago, I became intrigued by their recent card game hobby—and how they used the Wolfram Language to settle an argument. To figure out who gets to go first at the start of the game, they take one suit (spades) from a full deck, and each draws a card. Then, the person with the highest card value wins. Because they are using only one suit, there can be no ties. Simple, right?


Now, there is one thing you need to know about Alice and Bob. They are both super-secretive people. They share very few private details about their lives. One reason for this is that they both have jobs in cryptography. Bob works as a security specialist for a major bank, and Alice is a programmer who develops cryptographic libraries.


With that in mind, it came as no surprise that after they each pulled a card from the deck, they did not want to divulge to each other what card they were holding. Alice was quite certain she had the highest card, but Bob was equally certain he did. They argued back and forth about this, but quickly realized neither one wanted to show the other their card, and as a result, they could not start their card game. 


They began to wonder if perhaps there was a way for one of them to prove to the other that they indeed were holding the higher card. It was not immediately clear how to do this, or if this was even possible, but they both began to discuss this problem and put the actual card game aside for a moment.


Card Selection


They started out by examining their deck of cards and decided that they might as well use a virtual deck of cards, for example this deck from the Wolfram Function Repository. Because a full deck of cards has four copies of each face value, they limited themselves to drawing from a single suit (spades):









					ResourceFunction
				



					&#10005


ResourceFunction["PlayingCardGraphic"][Range[13],
 "CardSpreadAngle" -> 0]










Alice and Bob proceeded to both virtually draw one card from this set:









					{alicesChoice, bobsChoice} = RandomSample
				



					&#10005


{alicesChoice, bobsChoice} = RandomSample[Range[13], 2]










This was Alice’s card, which Bob did not see:









					alicesCard = ResourceFunction
				



					&#10005


alicesCard = ResourceFunction["PlayingCardGraphic"][alicesChoice]










And this was Bob’s card, which Alice did not see:









					bobsCard = ResourceFunction
				



					&#10005


bobsCard = ResourceFunction["PlayingCardGraphic"][bobsChoice]










Because they used the RandomSample function, they each got a unique random card. Alice and Bob did not know each other’s card.


Decrypting a Winner


Next they implemented a way to figure out who had the higher card. We, as the observers, know the answer, but at this point Alice and Bob only knew their own cards. For the first step they needed a list of all 13 individual cards with the value of each card attached to it:









					allCards = Table
				



					&#10005


allCards = Table[{ResourceFunction["PlayingCardGraphic"][i], i}, {i,
    13}];










Next they generated 13 passwords, one to encrypt each card with. Bob was given only one of these 13 passwords. Alice had all the passwords, but she did not know the password that belonged to Bob. They needed 13 passwords to make sure one password could encrypt and decrypt one card. If they had only two passwords, then either Bob would be able to decrypt more than one card or Alice would be able to figure out which card had a unique password to decrypt with:









					allPasswords = Table
				



					&#10005


allPasswords = Table[GenerateSymmetricKey[], 13];










From the generated passwords, Bob picked one that he could use to encrypt and decrypt his own card. He did not know the other passwords, and Alice did not know which password Bob picked. Bob’s choice is shown here, but the actual password is not too relevant. Even Bob did not need to see the actual password—he just needed to have it to decrypt his card:









					bobsPassword = RandomChoice
				



					&#10005


bobsPassword = RandomChoice[allPasswords]










This holds all passwords, except Bob’s:









					otherPasswords = DeleteCases
				



					&#10005


otherPasswords = DeleteCases[allPasswords, bobsPassword];










Then Bob and Alice agreed to run the following code, which encrypted each card in turn. Bob’s card was encrypted with Bob’s password, but all the other cards were encrypted with the passwords that Bob did not know in random order:









					encryptedObjects = Module
				



					&#10005


encryptedObjects = Module[
   {mixedPasswords, i = 0},
   mixedPasswords = RandomSample[otherPasswords];
   Map[
    If[
      First[#] === bobsCard,
      Encrypt[bobsPassword, {bobsCard, bobsChoice}],
      i++; Encrypt[mixedPasswords[[i]], #]
      ] &,
    allCards
    ]];










There were now 13 encrypted objects, one of which could be decrypted by Bob. In other words, Bob could use his key to decrypt the encrypted object that held his own card, but he could not decrypt any of the other encrypted objects. A way to check this is to attempt to decrypt all objects with Bob’s password, as 12 will fail and one will succeed:









					Quiet@Tally
				



					&#10005


Quiet@Tally[
  Map[
   Decrypt[bobsPassword, #] &,
   encryptedObjects
   ]]










Then Alice added information to each encrypted object. She unlocked each encrypted object by trying each password until she had a successful decryption. Next, she added "Higher", "Lower" or "Equal" before encrypting every object again:









					Off
				



					&#10005


Off[Decrypt::failed]

















					newObjects = Map
				



					&#10005


newObjects = Map[
   Function[{object},
    Module[{card, value, password},
     {{card, value}, password} =
      First[Select[Map[{Decrypt[#, object], #} &, allPasswords],
        First[#] =!= $Failed &]];
     Which[
      alicesChoice > value, Encrypt[password, {card, value, "Higher"}],
      alicesChoice === value,
      Encrypt[password, {card, value, "Equal"}],
      alicesChoice < value, Encrypt[password, {card, value, "Lower"}]
      ]]],
   encryptedObjects
   ];

















					On
				



					&#10005


On[Decrypt::failed]










Bob could still only decrypt his own object, but he was able to observe what Alice added. After Bob decrypted his object, he noticed that Alice indicated that her card was higher:









					Clear
				



					&#10005


Clear[result];
Quiet@Map[
   Function[
    decrypt = Decrypt[bobsPassword, #];
    If[decrypt =!= $Failed, result = decrypt]],
   newObjects];
result










So finally Bob knew that Alice’s card was higher, even though he was never told what Alice’s card was. They ran the entire scenario with reversed roles, at which point Alice knew that Bob’s card was lower. In this case, Alice and Bob were looking at the same notebook and code, which made cheating by either one very difficult. If they had each executed their code on their own machines, it would be possible to cheat. For example, Alice could have modified the code and pretended to have a higher card than Bob. But this works only up to a point. If Bob had the king of spades (the highest card), and Alice pretended to have that card too, then Bob would know that Alice had cheated. But the chance of detecting that would be low. One way they could have addressed that is by automating the procedure and running it many times. If Alice had cheated, this would have eventually come out. Another way to address this is to use a shared, trusted computation source. For example, API functions in the Wolfram Cloud could be used as a shared mechanism to run the individual computation steps.


The concept behind all this somewhat mysterious trickery is called “secure multi-party computation.” These types of computations let people compute a function over their data, without revealing the data itself to each other. Another related type of computation is a “zero-knowledge proof,” where one party proves to another party that they know a certain value without revealing it.


Using the Wolfram Language, you can easily model and reason about these types of protocols and computations and even implement them for production-level code.








Get full access to the latest Wolfram Language functionality with a Mathematica 12.1 or Wolfram|One trial.







Engage with the code in this post by downloading the Wolfram Notebook






]]>
			https://blog.wolfram.com:443/2020/08/06/alice-and-bob-play-a-game-of-cards/feed/
		7
		
		
		The Wolfram High School Summer Camp Went Virtual, and It Was an Experience!
		https://blog.wolfram.com:443/2020/07/30/the-wolfram-high-school-summer-camp-went-virtual-and-it-was-an-experience/
		https://blog.wolfram.com:443/2020/07/30/the-wolfram-high-school-summer-camp-went-virtual-and-it-was-an-experience/#comments
		Thu, 30 Jul 2020 19:39:58 +0000
		Rory Foulger
				
		

		https://blog.internal.wolfram.com/?p=67721
		
			For more on Wolfram’s summer education programs, read our post about the Wolfram Summer School.


The Wolfram High School Summer Camp Went Virtual, and It Was an Experience!


This year marked the ninth annual Wolfram High School Summer Camp, and it was a truly amazing experience. Forty-four students joined us remotely from around the world—from almost on the doorstep of Wolfram’s headquarters in Illinois to as far-flung as Kazakhstan, Germany, Russia, South Korea and India. They dedicated two weeks to learning the Wolfram Language, creating remarkably high-level independent projects and developing strong computational thinking skills. Our students had the opportunity to learn from subject experts from Wolfram Research, their mentors and teaching assistants (TAs) and, of course, our CEO Stephen Wolfram, who met with each student to discuss their projects.





Location distribution of the 2020 Wolfram Summer Camp students.


The overarching goal of the Wolfram High School Summer Camp is for talented young people to develop their knowledge, experience and skills by working on an independent project, supported by a mentor and other staff members. Each year at camp, we emphasize the concept of computational X—the idea that for any given subject, there is or can be a computational extension. In this manner, our students managed to apply computational analysis skills to subjects ranging from vexillology (the study of flags), to ornithology (the study of birds), to acoustics and linguistics. Other students worked on more traditional projects, such as data science, machine learning and computational math and physics.


For each student, the final output was a computational essay: an interactive notebook combining narrative, code and output to explain and explore their project. This year’s computational essays were of an exceptionally high standard, especially considering that the students had fewer hours of contact time with their mentors than in previous years spent on campus. Students reported that project time was their favorite part of camp, indicating that we successfully created an atmosphere of hard, productive work, but also one where students could enjoy themselves and make new friends.


This year, we built a curriculum around an active approach to learning. Over the course of the first two days, classes focused on helping students learn the functional programming paradigms and structures of the Wolfram Language, deep diving into the details to give students a full picture of what can be achieved. Each class was structured to provide plenty of time for active learning via small group activities, mini-projects and discussion. Students were able to build a dozen or so mini-projects of increasing complexity before moving on to their own individual projects. These mini-projects helped students to develop skills such as structuring readable code, user experience design, debugging and optimization.


Throughout the camp, mentors and TAs delivered short lectures focused on applications of the Wolfram Language. From computational farming to how step-by-step functionality is built in Wolfram|Alpha, students had the opportunity to see a wealth of real-life, and in some cases production-level, code. This helped them to visualize how their own code should be structured so that it can be useful to others in the future.


Challenges and Solutions for Running an Online Camp


 As with many educational programs this year, we had to make the decision to move online for the first time. When planning the Wolfram Summer Camp, we had three main concerns: that students would lose out on the dynamic social environment, that students wouldn’t get the level of support they needed from our mentors and that students wouldn’t have the technology, time and space available in their homes to complete their projects effectively. 


Unlike at a regular summer camp where campers are rarely, if ever, alone, we would have no transitional times, no opportunities for whispering in class and no chance to play Truth or Dare into the early hours of the morning. A central piece of the Summer Camp that we successfully recreated was the role of junior staff. The TAs brought energy and acted as a bridge between the adult staff and the campers. They organized a range of activities, from a 30-minute warmup session first thing each morning, to a different lunchtime social activity each day, to evening slots for relaxation. Some of the highlights included a virtual escape room, a Bob Ross–inspired painting hour and a talent show. Students became particularly fond of quick games such as Skribbl (a kind of online Pictionary), the Wiki Game and GeoGuessr. With all of these activities and the enthusiasm brought by the TAs, we were able to keep students happy and engaged.


Student paintings


Some of our students’ creations from a Bob Ross–inspired painting hour.


During an in-person camp, students spend project time sitting with their mentor group, keeping each other on task, taking dance breaks and helping each other with bugs. To recreate this dynamic environment, staff and students actively engaged over Zoom (video/audio) and Slack (messaging). Using Zoom allowed us to share video for face-to-face communication as well as create breakout rooms where students (and sometimes a mentor or TA) could play a game or work on their projects or other coding challenges together. Mentors and TAs worked hard to ensure that project time was productive and engaging by sharing music through Zoom, taking time at the start and end of sessions to play a quick game, employing the Pomodoro Technique and, in one case, regular dance breaks! 


Camp communication


Slack allowed us to build on what Zoom offered by providing flexible messaging with channels set up for academic and social use. Over the course of two weeks, the 44 students and 18 staff members sent over 17,000 messages (more than 1,100 every day!) and shared over 1,300 files. In concert, Zoom and Slack made it possible to manage the various needs of students by flexibly allowing mentors and TAs to move between groups as well as answer questions in Slack directly. 


Our final concern was less easily solved. At physical camp, it is relatively easy to ensure that each student is healthy, happy, fed, hydrated, taking enough breaks and is physically safe. It’s also relatively easy for us to solve their technical problems. In some ways, virtual camp is a more equitable experience—camp itself was cheaper, and no one had to pay to fly to Boston. Virtually, however, we ran into some problems with some students using shared or old computers; struggling to find quiet environments where they could sit comfortably for long periods of time; and having issues with Wi-Fi, electricity and time zones when camp ran across their nighttime. While hardware- and utilities-related problems were unsolvable on the side of camp staff, we were able to run computationally costly code through Amazon Web Services (AWS) and rely on Slack for continued communication with students when Wi-Fi was down.


Participants and staff


Participants and staff members from the 2020 Wolfram Summer Camp.


What’s Next after Camp?


Selected students from camp are asked to join various educational programs offered by Wolfram Research. Students who did a project closely related to Stephen Wolfram’s Physics Project will be joining a new initiative there to get young people participating in active scientific research. Other students will be joining the Wolfram Emerging Leaders Program (WELP), a semester-long experience designed to build on what students learned at camp. 


Where students at camp work to produce a project independently in a short period of time, students in WELP work in a team over the course of 15 weeks to follow the entire design-thinking process from ideation to implementation. WELP students present their projects in the form of a computational essay and a poster session. The students benefit from longer-term mentoring, a structured program and the opportunity to form close bonds with their teammates.


Other students will go on to adapt the work they did at camp to make it into functions for the Wolfram Function Repository, a dataset for the Wolfram Data Repository or an interactive Demonstration for the Wolfram Demonstrations Project. Older students may move up to the Wolfram Summer School next year, intern at Wolfram Research or join the Wolfram Student Ambassador Program to represent Wolfram at their schools or universities. Younger students may join Stephen Wolfram’s Computational Explorations club or return to camp next summer to join us (hopefully) in Boston.


With 92% of students rating the camp “Excellent” overall and 90% of students feeling very happy with their final projects, it is safe to say that Wolfram High School Summer Camp in 2020 was a success. On our end, we loved helping the students to grow and develop their skills and their projects, and it’s been a joy to read through their computational essays and see what amazing work they all accomplished in such a short space of time. 








For more hands-on Wolfram Language courses and workshops, check out the latest Wolfram U events.







]]>
			https://blog.wolfram.com:443/2020/07/30/the-wolfram-high-school-summer-camp-went-virtual-and-it-was-an-experience/feed/
		0
		
		
		Pandemic-Inspired Innovations Make for the Best Wolfram Summer School Yet
		https://blog.wolfram.com:443/2020/07/30/pandemic-inspired-innovations-make-for-the-best-wolfram-summer-school-yet/
		https://blog.wolfram.com:443/2020/07/30/pandemic-inspired-innovations-make-for-the-best-wolfram-summer-school-yet/#comments
		Thu, 30 Jul 2020 19:39:37 +0000
		Vitaliy Kaurov
				
		

		https://blog.internal.wolfram.com/?p=67766
		
			For more on Wolfram’s summer education programs, read our post about the Wolfram Summer Camp.


The 18th annual Wolfram Summer School has just thrown its graduation party in High Fidelity, a virtual world augmented with spatial audio. Students and faculty sang together during karaoke with a DJ and jukebox, chatted away mixing techspeak and humor, said farewells and had a ball celebrating the completion of the program. Due to the COVID-19 pandemic, we chose to make our summer programs more accessible to the students and faculty from all corners of the world—this year from 25 countries and all populated continents.


Switching to a purely online format allowed us to lower the cost, provide stronger financial aid and use innovative learning technologies and methods, thus turning the tables on pandemic times, getting more from less. What comes to mind is going far beyond lemonade, after life gave us lemons. As a result, this year was the largest Summer School by student volume, and we expanded educational directions with a new Fundamental Physics track to engage students in the research of the recently unveiled Wolfram Physics Project.


Student locations


Wolfram Summer School participants joined this year’s virtual event from all over the world.


The value of education is seen in the impact it has on students’ lives. The Wolfram Summer School takes students from basic familiarity to finishing significant projects in just three weeks. From the program’s centerpiece—the completion of an innovative project—to a wide range of benefits like career boosts and opportunities leading to internships and employment, the Wolfram Summer School has been helping students for 18 years. The Summer School also gives students the chance to network with a diverse crowd of professionals from both within and without Wolfram companies. Students gain practical scientific and computational knowledge that can be applied in the real world, grow their communication skills and experience joyful and exciting education.


Practical Achievements


Practical achievement is the key focus of the Summer School, and this year, students had plenty. The crown jewel of the program is the completion, presentation and publication of an advanced project, which is uniquely selected for each student though a sophisticated procedure that spans the time from the student application interview to a personal meeting with CEO Stephen Wolfram and faculty at the school. All 77 students who completed the three-week curriculum have published technical articles on our corporate social network Wolfram Community. You can take a look at the spectacular gallery of project highlights from the Summer School’s Tumblr—what a wide variety and complexity of subjects!


Student projects


And this is just the first glance at how thoroughly thought-out our strategic approach to professional development is. After networking with a select student body, the publication of students’ work on the company’s social network connects them further with a growing community of professionals currently exceeding 26,000 members. This opens many opportunities for students, from networking with a global crowd of likeminded technologists and scientists to discovering career opportunities with Wolfram and third-party companies. Helping the students make an actual publication at the end of the program is not only planting the flag of the final accomplishment, but the publication also lives forever at a unique public hyperlink that can be pointed to from a resume, personal website or other media important to the student for promotion of the project and career impact. Moreover, Wolfram provides students with various other publication media to communicate their achievements to a wider audience.


One such medium is the the Wolfram Function Repository. If you have ever thought of publishing a computational idea, you should consider this public resource that hosts an expanding collection of standalone algorithms contributed by the user community. It makes publications simple and referable with an easy submission process and reviews by Wolfram staff. There were more than 10 submissions by the students this year. A few are already through the review process and finalized as official publications that, along with Wolfram Community articles, feature the students’ names and publication dates—a crucial part of any reference. Among the already published ones are:



Excerpts from the first two are shown here to highlight the nature of the publications that is streamlined with innovative templating technology, one of many features of Wolfram Notebooks that students get accustomed to and can use as a universal computational exploration and communication medium.


Wolfram Function Repository


In addition to Wolfram Community articles, which are narratives about key highlights in a project’s development, the students also archive their Wolfram Language code, data and auxiliary files in the Notebook Archive as a permanent record of their work. These are just some examples of immediate output at the end of the three-week program. Some of the projects will continue after the school and might result in additional publication, including with arXiv, peer-reviewed journals and various Wolfram media sites.


Stephen Wolfram’s Leadership


Stephen Wolfram’s leadership and complete dedication to the school makes it a unique experience for the attendees. Since he founded the school in 2003, Stephen has devoted much of his time to the school during its progress every year. Being a renowned scientist, businessman and the creator of the technologies and sciences we teach at the school, he gives students an exclusive perspective and firsthand knowledge about the professional world and beyond. He helps to define a project for every student via a carefully crafted procedure, which involves the understanding of students’ backgrounds and interests to match them with innovative, modern computational projects—often open questions. Many projects actually come directly from Stephen’s ever-expanding project lists, designed specifically for our summer programs. He also checks on the projects’ progress, communicates with the students casually and gives talks and Q&As on numerous subjects. 


This year, in addition to a series of talks on the Wolfram Physics Project, Stephen led a series of fun, illuminating events. For instance, he ran a trivia night where he prepared and asked the students questions addressing a diverse range of human knowledge. By competing and answering, the students naturally revealed their background interests, and this of course was an efficient and entertaining way to get to know each other better. Among other events by Stephen were an opening keynote; various Q&As about entrepreneurship, insights into the future, people, ideas and more; and even a tour around his house showing various objects of curiosity that he has collected over the years. Take a look at just a few random questions students asked Stephen this year:


Student questions


The Program Design


The program design has been refined through the 18 generations of its annual installment. We restructured this year in order to  accommodate online learning. To make distance learning work, we utilized innovative tools and strategies such as a custom-designed portal based on Wolfram Cloud systems for the distribution and collection of all pertinent school content. Additionally, we used High Fidelity for social gatherings, Slack for managing teams and fast information flow, Zoom for conferencing, Pathable for scheduling and various Wolfram technologies for project development. Careful fusion of all of this vanguard tech allowed the program to blossom and efficiently support our faculty and student body in their logistic and learning endeavors. 


The Wolfram Summer School is a computational project–based environment that promotes a hands-on approach to open-ended, challenging problems similar to those that students might face in the real world. It allows the students to quickly learn practical knowledge that they will apply at their places of work and study. Each student is assigned a unique project matched with their background as well as a mentor for continuous guidance. The mentor and student have touchpoints every day to check the progress, define next steps and work together through difficult parts.


To support the rapid growth of programming and scientific skills necessary for project completion, a carefully designed curriculum provides an intense, subject-rich course of lectures that start with essential Wolfram Language training. Training continues into applied areas of data science, machine learning, image processing, high-performance computing, graphs and networks, blockchains, neural networks, A New Kind of Science, the Wolfram Physics Project and more.


Lectures were broadcast live via Zoom. To make the learning active, we had dedicated Slack channels where questions from students were taken in real time and addressed by a speedy team of six helpful teaching assistants. Whatever they could not answer, they would highlight for the lecturer to address in the final Q&A session. There was plenty of sci-fi humor going around, and calls to the teaching assistants often got accompanied with Batsignal emoji responses akin to the Batman comics.


Managing Time Zones


One of the challenges for the online program was the wide range of time zones, as students attended from many different locations. While we initially asked all students to commit to a 10am–10pm EDT daily schedule, we were determined to accommodate their normal life routines as much as possible to make them comfortable and able to focus on education in a healthy way. We recorded all lectures, which usually ran during the morning session, and made the majority of the recordings available that same day for people who could not attend. 


We carefully analyzed the students’ data as well. This is one of the visualizations we built that assumes a standard working window of 8am–5pm in a student’s local time zone and converts it to EDT. Then we counted students in one-hour bins if their normal working window in local time overlapped with a particular bin in EDT. We can obviously see the peaks corresponding to the Americas vs. Europe and Asia. Besides recording lectures, to accommodate non-American time zones we introduced virtual office hours from our faculty members who also reside in diverse time zones. There was also a lot of support from the teaching assistant team and both faculty-to-student and student-to-student help in well-structured Slack channels.


Visualization


Increasing Engagement


We used the online nature of the school this year to our advantage and invited many experts who could not attend otherwise to serve as faculty and guest lecturers. Brian Silverman, one of the external guests, was so kind as to hang out with the students and faculty throughout the whole program and was the inspiration in many mind-boggling conversations. Others include prolific Wolfram technology adepts from around the world and lead architects from Wolfram Research and Wolfram|Alpha R&D who actually develop the cutting-edge Wolfram technologies. In this way, students were exposed to both the gritty real-world practitioner and the insider-designer views of the tech. 


One of the other interesting things we did to support our students was to open doors to the school’s Slack workspace much earlier than the school started to engage the students and faculty in social and learning activities whenever they could drop by. In a wonderful, relaxed way, this built the school community and got it ready for an intense start.


Final Presentations


At the end of the program, the students presented their work in the oral and poster sessions. The oral session is designed in an elevator-pitch style in which students have just a few minutes to tell the audience what their project was about. They train their public speaking skills and rehearse with mentors and teaching assistants. The oral presentations ran exceptionally smoothly and familiarized everyone with what to check out in detail during the poster session, which took place in the High Fidelity environment. 


Along with the mingling crowd of students and faculty, the poster session also featured various guests from Wolfram Research departments, including R&D, partnerships, HR and others, who discussed with the students their projects and future career paths. The program closed with a graduation ceremony and party where everyone realized that time had flown too quickly and we already missed each other.


No Fun—No Work!


Entertainment and socializing are essential parts of a healthy student mindset and the ability to finish a challenging educational program. We all need to relax sometimes to recuperate and come back to learning with a refreshed mind. On a university campus, it is easier to socialize, play games, go for dinner or simply take a walk with a friend or two. I personally organized quite a few basketball games throughout my school years, which was always a lot of fun and brought students and faculty much closer by erasing formal boundaries. I always recommend going regularly to the gym or pool. 


So what could we do in pandemic times? We could leave the leisure part to the students’ own devices, but that would not have been a good strategy for fostering the community and living a unique memorable experience as a collective whole. No worries—we had a few tricks up our sleeve to combat physical isolation, of course led by advanced tech!


First of all, if you manage students via a good team chat software, you must have a #random or #social channel for what Slack playfully labels as a place for “water cooler conversations.” You can add more dedicated channels for games, a movie club and so on to focus and spark conversations by interest. But this was only the beginning for us. We were fortunate that Stephen had exclusive access to and a vision for the school’s usage of the High Fidelity virtual world, augmented with spatial audio. In High Fidelity, you can spatially navigate and understand the direction and proximity of audio coming to you from numerous other people sharing the space. We were connected with High Fidelity developers and had the freedom to tune our environment in terms of of sound attenuation, room maps, interactive links and background music. Here is a sample of a few maps we used:


Sample maps


In the next image, you can actually see some parts of the maps densely populated with students and faculty. On the left, Stephen casually stopped by to chat with the students. The right one is the graduation party, where we even managed to set up karaoke. The little colored bells around people’s avatars indicate the direction in which the person is speaking and listening. We had the High Fidelity space open continuously for casual interactions. Our teaching assistants and mentors often hung out there in case students preferred to start an audio conversation; it was easy to then use Slack in parallel or jump to Zoom.


Populated maps


Another excellent form of entertainment was provided by a great educator, Mark Greenberg, who hosted via Zoom his own invention, a very popular trivia game called Chicken Scratch. All in all, using Slack, Zoom and High Fidelity, we had the time and means to take the occasional break and get to know each other better.  


Students and Projects


Students and their projects are truly the unique centerpiece of the school. Taking a closer look at the students’ stories and project ideas is important to comprehend the scope of the program. I’ve summarized a couple exemplary cases, including direct quotes from the students, to give an idea of what their intellectual journeys at the school are really like. For more, please visit the school’s group on  Wolfram Community or the school’s Tumblr.


Radhika Prasad

Cellular Automata on 3D Lattices by Radhika Prasad, India


Cellular Automata on 3D Lattices


Radhika Prasad is pursuing her master’s degree at the Indian Institute of Technology in Kanpur. In her own words, she “has been interested in physics since [her high]-school days. Within physics, [her] interests lie in optics and quantum mechanics. Besides enjoying physics and programming, [her] hobbies occupy a wide range of the spectrum, including sports (football, tennis, table tennis), Indian classical music (Indian bamboo flute), photography and solving Rubik’s cube and various related puzzles.” The aim of Radhika’s project was to work with 3D lattices and perform computational tasks on the lattice elements. A nice way to visualize the computation is to run cellular automata on the lattices. This research provides powerful means for formulating numerous 3D physical phenomena in the framework of computational models.


Douw Marx

Towards Universal Robotics by Douw Marx, South Africa


Towards Universal Robotics


Douw Marx is a mechanical engineer who is conducting research in the field of condition-based maintenance at the University of Pretoria, South Africa. In his own words, he is “an advocate for a computational approach to problem solving and considers [his] programming ability to be a key tool for finding innovative solutions to engineering problems. [Douw] like[s] to consider alternative solutions to the problems that are considered to be optimally solved. In [his] free time, [he] enjoys hiking, making music and woodworking.” In the words of his mentor, Philip Maymin, “Douw made what to my mind is effectively groundbreaking research in universal modular robotics.” Douw’s project considered ways in which arbitrary motion and force as well as universal computation could be implemented in order to achieve general robotics. He researched approaches that simulate the function of any currently existing robot with a set of identical programmable robotic modules.


Life-Changing Merits


The merits of the school have manifested themselves clearly since the school’s foundation in 2003. We know we’re doing this right when we get positive feedback and appreciation. The career opportunities and boosts are not just marketing cliché here, but a reality. The school has a remarkable impact on many students’ lives. To give you an example, many original Wolfram R&D members, who later helped to form a machine learning and neural networks team, first had been students at the Wolfram Summer School and worked at the school on advanced data science projects.


My own professional path is a perfect example of how the Summer School changes lives. When I came to the Summer School as a student in 2010, I was a professor at the City University of New York. Those three weeks were life-changing enough for me to completely change my career path, leave academia and join Wolfram Research. Now I serve as the director of community engagement and take part in many exhilarating projects, including the development and management of the corporate social network, Wolfram Community. I returned to the Summer School as a faculty member every year until 2017, when I filled the shoes of the former academic director. 


Takeaways for the Future


Relationships, both of the students with each other and with Wolfram, last long after the Summer School is over. Some will return to the school, some will get internships or employment, some will continue projects and make publications, and some will just keep in touch for potential opportunities. 


We also introduce our students to other companies who are interested in their expertise in Wolfram technologies, which are widely used in industry and academia around the world. One of the most indispensable benefits of the school is its diversity of student ages, cultures, countries, backgrounds and career approaches, from early undergrads to established professionals. For instance, John Cromwell, a professor of surgery at the University of Iowa whose work was featured in The Wall Street Journal, developed this year a machine learning application for predicting surgical site infections and is considering turning it into a real medical application that helps people. 


We’re honored to have hosted another talented and diverse group of students. We’re also thankful that both staff and students were able to adapt to the unforeseen changes the Summer School underwent this year. Participants certainly have bright futures ahead, and we look forward to seeing more of their contributions and ways they can incorporate Wolfram technology in their fields. 








For more hands-on Wolfram Language courses and workshops, check out the latest Wolfram U events.







]]>
			https://blog.wolfram.com:443/2020/07/30/pandemic-inspired-innovations-make-for-the-best-wolfram-summer-school-yet/feed/
		0
		
		
		Digital Vintage Sound: Modeling Analog Synthesizers with the Wolfram Language and System Modeler
		https://blog.wolfram.com:443/2020/07/23/digital-vintage-sound-modeling-analog-synthesizers-with-the-wolfram-language-and-system-modeler/
		https://blog.wolfram.com:443/2020/07/23/digital-vintage-sound-modeling-analog-synthesizers-with-the-wolfram-language-and-system-modeler/#comments
		Thu, 23 Jul 2020 14:12:51 +0000
		Leonardo Laguna Ruiz
				
		
		

		https://blog.internal.wolfram.com/?p=67410
		
			Digital Vintage Sound: Modeling Analog Synthesizers with the Wolfram Language and System Modeler


Have you ever thought about making your own musical instruments? What about making mathematical models of your instruments? Whether you’re someone looking for a cost-effective alternative, a minimalist with dreams of maximalist sounds or a Wolfram Language enthusiast curious about sound design, you can build a virtual version of a modular synthesizer using Wolfram System Modeler.


To give you a quick example of what’s possible with this technology, here’s a sample clip of techno-style music created entirely with simulation models:



    
Play Audio

    

        Example clip

    





I use a modular synthesizer for designing sound and occasionally making songs, and I’ve found that System Modeler is ideal for creating a virtual synthesizer because it allows you to easily model and analyze the electric circuits used in vintage equipment.


How Modular Synthesizers Work 


My modular synthesizer is a mashup of different blocks: some of them were designed entirely by myself and others are commercial. How does a synthesizer like this work? Each module has a basic function. For example, it can be an oscillator, filter, envelope generator, amplifier, mixer, etc. By connecting these core components using wires, you can either imitate existing sounds or create new ones. You can see the similarities with System Modeler, where we can create complex systems by connecting components with virtual wires.


Why Virtual?


 Modular synthesizers are built in large and bulky cases. This makes them difficult to transport in a safe way. I have one small case that I carry when traveling, but it still uses a significant volume of my hand luggage. 


Commercial modules can cost from as low as $60 to over $1,000 each, and a small synthesizer can have a dozen modules. That cost can add up quickly and become prohibitive for a hobbyist. If a person is handy with a soldering iron, it is possible to hand build many of the modules. In fact, there is a large community of enthusiasts like me who enjoy using and building these kinds of systems.


Modular synthesizer


My modular synthesizer, an instrument that I have been building component by component over the past few years.


There is, however, another alternative to experiencing a modular synthesizer at a low cost: virtual modular synthesizers. VCV Rack is one of the most popular open-source applications that aim to replicate the experience of using a modular synthesizer. It provides more than a thousand different modules.


Over the past two years, I have been releasing virtual modules for VCV Rack. One of the strong characteristics of my modules is that I try very hard to replicate in software the “analog vibes” of the sound. The analog modules are “imperfect,” in a good way. For example, a digital sine wave oscillator can produce a near-perfect signal. This perfect signal can be perceived as boring, lifeless or cold. On the other hand, an analog oscillator struggles to achieve that level of perfection but produces a sound that can be perceived as rich and warm.


I will explain some of the techniques I use to model and simulate analog circuits in order to create the digital counterparts that imitate the sound.


The Basic Synthesizer Blocks


The sounds produced by a synthesizer can be completely new sounds or try to imitate existing ones. The most common technique used to create sounds in analog synthesizers is called subtractive synthesis, which involves starting with a rich sound and shaping (subtracting harmonics from) the sound in order to get the desired characteristics. You can think of it like having a piece of stone and then removing material in order to get the sculpture you want to create. In subtractive synthesis, the main modules are:


    

  • Sound sources, for example any kind of oscillator that produces waves in the audible range
    • 

  • Sound processors, for example filters and other effects
    • 

  • Control sources; these can be low-frequency oscillators, envelope generators, etc.
    • 

  • Utilities, such as amplifiers, attenuators, etc.
    • 



Let’s start modeling some basic modules: an oscillator and two filters. To help guide me in recreating an analog sound, I’ve selected these self-built modules from my collection to use as a reference: 


A simple oscillator and two filters


A simple oscillator and two filters. The Wolfram MathCore team made these boards as souvenirs for the Wolfram Technology Conference in 2019, where some of the topics of this blog post were showcased.


Modeling Basic Analog Components


In order to model these modules, we need to understand a bit how electric circuits are modeled. Let’s start with the most basic components: resistors and capacitors.


The commonly used electric components can be modeled using simple equations. Taking a look at the System Modeler code (by opening the Text View) for the built-in Resistor, we can see all the equations involved. One of the equations corresponds to Ohm’s law. The remaining equations are used to calculate the dissipated power and the effects of the temperature on the resistance. The equations for the terminals are described in the model OnePort. By modifying this code, we can create our custom electrical components for System Modeler:









					SystemModel
				



					&#10005


SystemModel["Modelica.Electrical.Analog.Basic.Resistor", \
"ModelicaDisplay"]










SystemModel


Taking as a basis the resistor models shown previously, we can create a simplified version that models the effects that we are interested in and removes the ones that we will not use. (You can find all the models in the library AnalogModeling.) In our synthesizer models, we are going to assume that the components are at constant ambient temperature. We will remove as well any calculation of power dissipation since that would not have any effect on the sound. In the following listing, you can see the simplified resistor model that we created:









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Components.R", "ModelicaDisplay"]










SystemModel


The model of the capacitor is very similar. The main change is in the equation that defines the relation between the voltage and current. In the case of the capacitor, this is a differential equation. Next you can see the simplified capacitor model that we are going to use:









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Components.C", "ModelicaDisplay"]










SystemModel


Inductors are not common in the kind of audio circuits I model. For that reason, I’m not creating an inductor model right now, but it is very easy to derive from the capacitor model.


On the other hand, potentiometers are very common since they are the main elements that we use to control the parameters of synthesizers. To simulate potentiometers, I’ll first create a variable resistor. Once there is a variable resistor, I can combine two of them to create a three-pin potentiometer.


In order to control the position of the potentiometer, we will add an input signal u to the model. This signal goes from 0 to 1, which will correspond to the ranges of full counterclockwise and full clockwise motion, respectively:









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Components.PR", "ModelicaDisplay"]










SystemModel


Using two variable resistors, we can create a potentiometer by connecting it as shown in this diagram:









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Components.P", "Diagram"]










The trick is to control both variable resistors using a single input. This is achieved by adding two equations to decrease the value of one resistor while the other increases:









					MatrixForm
				



					&#10005


MatrixForm[{"pR1.u" == u, "pR2.u" == 1.0 - u}]










These equations affect the value of the resistors as shown in the following plot. The  axis has a range from 0 to 1:









					Plot
				



					&#10005


Plot[{u, 1 - u}, {u, 0, 1}]










Now that we have the basic components, let’s start modeling our first circuit.


Modeling an RC Filter 


Using the potentiometer and the capacitor created previously, we can easily wire an RC filter as follows:









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Modules.RCFilter", "Diagram"]










Notice the added inputs u and p to provide the input and control signals, respectively. The output v provides the voltage measured in the capacitor. We packed the RC filter model into a System Modeler component that we can reuse in different models.


In order to test the RC filter model, we used a few components from the System Modeler library that are used to provide stimulus signals:









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Tests.RCFilterTest", "Diagram"]










We used a pulse signal running at 110 Hz as audio input. A saw wave with a frequency of 1 Hz provides a signal that sets the position of the potentiometer. The output of the filter is then passed to a component that records the signal as a WAV file that can be played back to listen to the results.


We simulate our test model for four seconds:









					rc = SystemModelSimulate
				



					&#10005


rc = SystemModelSimulate["AnalogModeling.Tests.RCFilterTest", 4];










The following plot shows the amplitudes of the input signal (in blue) and the filtered output (in orange) as we simulate a change in the position of the potentiometer:









					SystemModelPlot
				



					&#10005


SystemModelPlot[rc, {"filter.u", "filter.v"}, {0, 1}]










We can see in the plot how the filter output is attenuated as the cutoff frequency of the filter is decreased. Initially, the filter is completely open, which means that the cutoff frequency is above the 22 kHz that humans are capable of hearing. As the potentiometer moves, the cutoff frequency is reduced and the filter attenuates more of the high-frequency harmonics of the signal.


An easier way to understand the effect is by listening to the sound produced by our test model. We can import the generated audio file and play it back. If you listen to the sound, you will hear how it changes as the RC filter removes the high harmonics. This sound resembles a string instrument that is plucked:









					rcaudio = Import
				



					&#10005


rcaudio = Import[WSMLink`Library`ResolveModelicaURI["modelica://AnalogModeling/Sounds/RCFilterTest.wav"], "WAV"]











    
Play Audio

    

        RCFilterTest

    





Taking a look at the Spectrogram, the high-frequency harmonics (top of the graphic) are attenuated, while the low-frequency harmonics (bottom) are practically kept the same:









					Spectrogram
				



					&#10005


Spectrogram[rcaudio]










At this point, we have a model of an RC filter that allows us to run many analyses and provides us with very detailed information regarding the voltages and currents of every component. If we convert this model (as it is now) into an audio plugin, it would certainly work, but it would use more CPU than needed. This is because our model has many equations that calculate all the details of the circuit. However, when we are trying to make music, we are not very concerned about the internals of the circuit; the filter is more like a black box. In order to make the model more efficient, we can use the symbolic capabilities of the Wolfram Language to minimize our set of equations. Our target is to obtain the ODE representation of the circuit.


Our simple RC filter consists of 27 equations. We can see them all using the SystemModel command:









					rcm = SystemModel
				



					&#10005


rcm = SystemModel["AnalogModeling.Modules.RCFilter"];

















					rcAllEqns = rcm
				



					&#10005


rcAllEqns = rcm["SystemEquations", t]










The SytemModel command can help us in reducing the number of equations if we specify the level of elimination as follows:









					rcEqns = rcm
				



					&#10005


rcEqns = rcm["SystemEquations", t, Method -> {"Elimination" -> All}]










We can see that the number of equations was reduced to four. This is achieved by eliminating all the trivial equations like  and . In this case, we are intentionally losing information about our model since we are not able to calculate all voltages and currents of the circuit anymore. The resulting set of equations can be reduced further by using the command Eliminate. While eliminating the last variables, we can also replace some of the variable names with short symbols that will improve the readability of the equations. This simplification results in a single differential equation where the name dvc represents the derivative of vc (voltage of the capacitor), and vin is the input voltage:









					rcEqnsSimp =<br />
 Eliminate
				



					&#10005


rcEqnsSimp =
 Eliminate[
   rcEqns, {QuantityVariable["c1.i","ElectricCurrent"][t],
    QuantityVariable["pR1.v","ElectricPotential"][t],
    QuantityVariable["v",""][t]}] /. {QuantityVariable["u",""][t] ->
    vin, QuantityVariable["p",""][t] -> p,
   Derivative[1][QuantityVariable["c1.v","ElectricPotential"]][t] ->
    dvc, QuantityVariable["c1.v","ElectricPotential"][t] -> vc}










We can take the resulting equation and use the command Solve to put it in a traditional ODE form:









					FullSimplify
				



					&#10005


FullSimplify[Solve[rcEqnsSimp, dvc]]










From this differential equation, the transfer function of the filter is easily obtained:









					tfRC = vc /. Solve
				



					&#10005


tfRC = vc /. Solve[rcEqnsSimp /. {dvc -> s vc, vin -> 1}, vc][[1]]










In order to analytically confirm the behavior of the filter, we can create the Bode plot of the transfer function for three different positions of the potentiometer. In this plot, we can see what would be the attenuation of the input audio signal depending on its frequency content:









					BodePlot
				



					&#10005


BodePlot[{tfRC /. p -> 0.01, tfRC /. p -> 0.1, tfRC /. p -> 1.0}]










This equation is a simple differential equation that can be easily implemented with any programming language. Later, I’ll discuss how to implement it and analyze difficulties that can arise.


For now, let’s model a slightly more complex filter.


Modeling a Sallen–Key Filter


The Sallen–Key topology allows building different kinds of filters, for example lowpass, highpass, bandpass, etc. I will focus on the lowpass configuration for now. The previously modeled simple RC filter has one pole, while the Sallen–Key filter has two poles and therefore is “twice” as effective at removing frequencies:


picture


The previous diagram shows that that an operational amplifier (OPAMP) is needed to build this model. In this case, the OPAMP is connected in follower configuration, which makes it very easy to create a basic model. In follower mode, the output voltage of the OPAMP is exactly the input voltage, but the input current is practically zero. This configuration is known as the buffer.


A simple model for the buffer can be made in System Modeler using components from the Modelica library. Notice that this model is very simple and does not consider nonlinear behaviors of a real OPAMP—for example, output voltage saturation. To get a more analog sound, I would have to model saturation and other effects that we will not cover in this blog post.









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Components.Buffer", "Diagram"]










Once we have a model of the buffer, a simulation model of the Sallen–Key filter can be built by connecting the components. In order to change the frequency, we need a dual potentiometer. Dual potentiometers, as the name implies, are two individual potentiometers whose positions are controlled by a single shaft. In the Sallen–Key filter model, we will use two potentiometer components and control them using the same signal.


You can see the schematic of our new filter component in the following figure:









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Modules.Filter", "Diagram"]










Now let’s simulate a filter using a model similar to the one we used to test the RC filter (a pulse wave as audio and a saw wave to control the potentiometer). We simulate the test model for four seconds and plot the results:









					sk = SystemModelSimulate
				



					&#10005


sk = SystemModelSimulate["AnalogModeling.Tests.SallenKeyFilterTest",
   4];

















					SystemModelPlot
				



					&#10005


SystemModelPlot[sk, {"filter.u", "filter.v"}, {0, 1}]










Again, the orange signal is the filtered output and the blue is the audio input. We can listen to the sound of this filter in the following audio clip:









					skaudio = Import
				



					&#10005


skaudio =
 Import[WSMLink`Library`ResolveModelicaURI[
   "modelica://AnalogModeling/Sounds/SallenKeyFilterTest.wav"], "WAV"]











    
Play Audio

    

        RCFilterTest

    





You may notice that the result still sounds like plucking a string instrument, but the sound is a bit more mellow. This is because this filter removes more of the high-frequency harmonics. This effect can be seen in the spectrogram plots. Next, you can see the output of the Sallen–Key and RC filters:









					Spectrogram
				



					&#10005


Spectrogram[skaudio]

















					Spectrogram
				



					&#10005


Spectrogram[rcaudio]










Now that we have a working Sallen–Key filter, let’s follow the same simplification approach in order to get the differential equations and the transfer function. Eliminate all the unneeded variables and replace the names with shorter variables:









					skm = SystemModel
				



					&#10005


skm = SystemModel["AnalogModeling.Modules.Filter"];

















					skEqns = skm
				



					&#10005


skEqns = skm["SystemEquations", t, Method -> {"Elimination" -> All}];

















					skEqnsSimp =<br />
  List @@ Eliminate
				



					&#10005


skEqnsSimp =
  List @@ Eliminate[
     skEqns, {QuantityVariable["C1.i","ElectricCurrent"][t],
      QuantityVariable["R2.i","ElectricCurrent"][t],
      QuantityVariable["R2.p.v","ElectricPotential"][t],
      QuantityVariable["vin.i","ElectricCurrent"][t],
      QuantityVariable["R1.v","ElectricPotential"][t],
      QuantityVariable["R2.v","ElectricPotential"][
       t]}] /. {QuantityVariable["u",""][t] -> vin,
    QuantityVariable["p",""][t] -> p,
    Derivative[1][QuantityVariable["C1.v","ElectricPotential"]][t] ->
     dvc1, QuantityVariable["C1.v","ElectricPotential"][t] -> vc1,
    QuantityVariable["C2.v","ElectricPotential"][t] -> vc2,
    Derivative[1][QuantityVariable["C2.v","ElectricPotential"]][t] ->
     dvc2, QuantityVariable["v",""][t] -> vout};










The system has two differential equations, one for each capacitor. The output voltage corresponds to the voltage of the capacitor C2:









					Solve
				



					&#10005


Solve[skEqnsSimp, {dvc1, dvc2, vout}]










From those differential equations, obtain the transfer function in terms of the potentiometer position:









					tfSK = vc2 /.<br />
  Solve
				



					&#10005


tfSK = vc2 /.
  Solve[Eliminate[
     skEqnsSimp /. {dvc1 -> s vc1, dvc2 -> s vc2, vin -> 1}, {vc1,
      vout}], vc2][[1]]










The following plot shows the frequency response for three different positions of the potentiometer:









					BodePlot
				



					&#10005


BodePlot[{tfSK /. p -> 0.01, tfSK /. p -> 0.1, tfSK /. p -> 1.0}]










Now let’s make a side-by-side comparison of the two filters. Next you can see the frequency response of both filters: the Sallen–Key in orange and the RC in blue. The RC filter is a single pole that provides an attenuation of 20 dB per decade (6 dB per octave), while the Sallen–Key filter provides 40 dB of attenuation (12 dB per octave):









					BodePlot
				



					&#10005


BodePlot[{tfRC, tfSK} /. p -> 0.5]










Modeling a Simple Oscillator


The DIY oscillator that we are using as reference is built using the 555 integrated circuit. Usually, oscillators based on the 555 are pulse generators. In our case, we have extended the circuit to produce a saw wave oscillator. To simulate this oscillator, we need to create a model of the 555 IC first. Luckily, the 555 is very well documented and we can easily find a block diagram describing all the internals of the IC:


picture


The 555 consists of a voltage divider, two comparators, one flip-flip, one transistor and a buffer. I could create this model using Modelica components. However, in this case, I decided to experiment by creating the model directly in Modelica code. This is one big feature that System Modeler provides for advanced users or library developers who want to have full control of the equations involving their models.


Here we can see the code I created. It is not important for the reader to understand it. Just know that this code is an equivalent to the block diagram that was presented earlier.









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Components.IC555", "ModelicaDisplay"]










SystemModel


The oscillator is made by connecting the 555 in the oscillator configuration commonly called “astable.” This will allow us to control the pitch using a single potentiometer. To generate the saw wave, we used a buffer to measure the voltage of the charge/discharge capacitor C1 and then we added C2 as a decoupling capacitor to remove the DC offset. You can see the diagram of the oscillator component in the following figure:









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Modules.Oscillator", "Diagram"]










To test this model, we used a ramp that simulates the turning of the potentiometer, resulting in changing the pitch of the oscillator. Similar to the previous test performed on the filters, we recorded the audio produced by the simulation:









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Tests.OscillatorTest", "Diagram"]

















					osc = SystemModelSimulate
				



					&#10005


osc = SystemModelSimulate["AnalogModeling.Tests.OscillatorTest", 4];










If we plot a small segment of the simulation results, we can see the produced saw wave:









					SystemModelPlot
				



					&#10005


SystemModelPlot[osc, {"oscillator.v"}, {3.94, 4}]










The first thing you may notice is that the wave is not a perfect saw. This is in part because the charging of the capacitor is not perfectly linear. These kinds of small details are what make analog oscillators sound the way they do. However, not all imperfections of analog oscillators are desired. For example, the analog oscillators can detune with the temperature. To compensate for that, more sophisticated circuits can include temperature compensation. 


When importing the produced audio file, we can hear how the oscillator sounds:









					oscaudio =<br />
 Import
				



					&#10005


oscaudio =
 Import[WSMLink`Library`ResolveModelicaURI[
   "modelica://AnalogModeling/Sounds/OscillatorTest.wav"], "WAV"]











    
Play Audio

    

        RCFilterTest

    





We can hear that the sound starts with a high pitch and gradually changes into a lower frequency. We can see this effect in the spectrogram. One more thing to notice is how the saw wave is comprised of many harmonics that make it a rich signal:









					Spectrogram
				



					&#10005


Spectrogram[oscaudio]










As mentioned earlier, subtractive synthesis consists of shaping the harmonics by using modules like filters. Now let’s find out how the combination of our filter and oscillator sounds. 









					oscfilter =<br />
  SystemModelSimulate
				



					&#10005


oscfilter =
  SystemModelSimulate["AnalogModeling.Tests.OscPlusFilterTest", 4];

















					oscfilterwav =<br />
 Import
				



					&#10005


oscfilterwav =
 Import[WSMLink`Library`ResolveModelicaURI[
   "modelica://AnalogModeling/Sounds/OscPlusFilterTest.wav"], "WAV"]











    
Play Audio

    

        RCFilterTest

    





The resulting sound resembles a tuba. By plotting the spectrogram, we can see how the filter opens and closes, removing many of the harmonics.









					Spectrogram
				



					&#10005


Spectrogram[oscfilterwav]










Simulating Other Synthesizer Modules


So far, we’ve discussed two basic modules, an oscillator and a filter. In order to create more complex sounds, models must be created for some of the common utility functions, like envelope generators and amplifiers. The following components are not modeled after existing circuits. They are behavioral models that imitate the actual behavior of the real module.


The first one is the VCA, which stands for voltage-controlled amplifier. Implementing a VCA in System Modeler is straightforward because a VCA is a multiplication of two signals. One of the signals is used as a control and the other as a source.


Next is a diagram and the icon of the VCA:









					Grid
				



					&#10005


Grid[{{SystemModel["AnalogModeling.Modules.VCA", "Diagram"],
   SystemModel["AnalogModeling.Modules.VCA", "ModelicaIcon"]}}]










We can test this model by using two sine wave components from the Modelica library:









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Tests.VCATest", "Diagram"]

















					vcatest = SystemModelSimulate
				



					&#10005


vcatest = SystemModelSimulate["AnalogModeling.Tests.VCATest", 4];










In the simulation result, we can see the change of amplitude of the signal:









					SystemModelPlot
				



					&#10005


SystemModelPlot[vcatest, {"vca.y"}, {0, 4}]










If you listen to the audio, you will notice how the perceived volume changes:









					vcatestwav =<br />
 Import
				



					&#10005


vcatestwav =
 Import[WSMLink`Library`ResolveModelicaURI[
   "modelica://AnalogModeling/Sounds/VCATest.wav"], "WAV"]











    
Play Audio

    

        RCFilterTest

    





The next model that we need is an envelope generator. Envelopes are commonly used to shape the amplitude of the sound. For example, when hitting a drum, the sound has initially a sudden rise of amplitude, then it gradually decays. To model that behavior, we can use a simple RC circuit that is very similar to the filter we presented before:









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Modules.Envelope", "Diagram"]










In the previous diagram, the capacitor C1 is recharged to 1 V every time the input voltage becomes larger than 0.5 V. This is achieved by adding the following equation to the model:


Equation


The decay of the envelope is defined by changing the value of the capacitor C1. The envelope has a second RC stage that is used to smoothen the transitions. The values of the capacitors and resistors were arbitrarily chosen to provide the desired transition.


To test the envelope, we combine it with the VCA model and trigger it with a 1 Hz pulse. The audio signal is a sine wave of 440 Hz:









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Tests.EnvelopeTest", "Diagram"]










In the simulation results, we can see the change of amplitude in the signal:









					env = SystemModelSimulate
				



					&#10005


env = SystemModelSimulate["AnalogModeling.Tests.EnvelopeTest", 4];

















					SystemModelPlot
				



					&#10005


SystemModelPlot[env, {"envelope.v", "vca.y"}, {0, 4}]










Listening to the results, we can hear that this simulation sounds like gently hitting a glass of wine with your finger:









					envtestwav =<br />
 Import
				



					&#10005


envtestwav =
 Import[WSMLink`Library`ResolveModelicaURI[
   "modelica://AnalogModeling/Sounds/EnvelopeTest.wav"], "WAV"]











    
Play Audio

    

        RCFilterTest

    





Using these basic models (plus some utilities from the Modelica library), I have created the short loop of techno music that was presented in the beginning of the post. Without going into the details, this loop consist of three voices: one kick drum, one bass synthesizer and one hi-hat synthesizer. All of them are combined using a mixer (summing voltages) and recorded directly to a WAV file:









					SystemModel
				



					&#10005


SystemModel["AnalogModeling.Tests.Techno", "Diagram"]










Why Aren’t Musicians Using System Modeler to Perform Live?


The previous example takes about 70 seconds to render 30 seconds of audio. This is more than two times slower than real time. The main reason for this is because the solvers used by System Modeler are focused on providing high-accuracy simulations. In addition, System Modeler calculates the internal voltages and currents of every component in the circuit. This is very handy when performing analysis on our models, but as I have mentioned before, when creating music we can consider all our models as black boxes and optimize them in order to consume as little CPU as possible.


When optimizing the simulation models, there are other compromises that we can make in order to obtain an efficient simulation. One of these things is to simulate the models with less accurate methods. This will result in a simulation that is not perfect, but it will be faster and the listener will have a difficult time noticing which simulation is which. It is a matter of finding a good tradeoff between the quality of our model/simulation and the efficiency. If the simulation is oversimplified, we may lose the “analog vibes” of the sound. On the other hand, if the simulation is very accurate, the users will consume their available CPU resources quickly.


Implementing the Filter as an Audio Plugin


Now we are going to implement the Sallen–Key filter equations we obtained and use the filter to process audio inside VCV Rack. In order to do that, we need VCV Rack and a plugin called VCV Prototype. Both are freely available from the VCV Rack website. The VCV Prototype is a special module that allows testing of our own DSP code without the need for any extra tools. It also has support for a programming language I developed called Vult. The Vult language is an easy and constrained language that I use to write all my plugins. 


VCV Rack


VCV Rack Prototype module.


In order to implement our filter, we are going to take the differential equations we derived and then we are going to use a numerical integrator to simulate them in real time. In this example, we will use the forward Euler method. This method is simple and fast; however, it can have drawbacks such as instability or bad accuracy. But for the purposes of this example, the method is good enough.


The following figure shows the Vult language code that simulates the Sallen–Key equations we obtained. You may notice that the code has a resemblance to JavaScript or C++ code. This code declares a function filter, which receives the input voltage vin, the potentiometer position p and the simulation time step h.


Vult Sallen–Key


The derivatives dvc1 and dvc2 are calculated, then the simulation takes one step using the Euler method. Before we can run this code, we need a small piece of code to calculate the time step h and the position of the potentiometer. There are three issues that we need to guard against before we run this code, and all of them have to do with the position of the potentiometer p. The first is that the value cannot be zero because that would produce a division by zero in the equations. Second, the value of p cannot be too small because that would make the Euler simulation method unstable. The third one is that p has a linear relation with the frequency, which is not the best when dealing with audio. In musical filters, it is preferable to control the cutoff in a musical way, which requires changing the cutoff frequency by octaves (exponentially). To deal with all these issues, we use a simple formula to calculate the  parameter:









					Plot
				



					&#10005


Plot[Exp[-5 knob], {knob, 0 , 1}]










This formula takes the knob variable, which represents the linear position of the potentiometer (ranging from 0 to 1) and gives us back p, which varies exponentially and never reaches zero.


If we translate this to Vult language and we run the final code in the VCV Prototype, we can finally use our filter inside VCV Rack to make music:


Vult


In this video, you can hear the filter we implemented running in real time inside VCV Rack.




Try It Using Wolfram Technology


Using System Modeler and Mathematica, I have modeled a large collection of analog circuits for which I have implemented more than 35 virtual modules that can be used in platforms like VCV Rack and Cherry Audio Voltage Modular.


Virtual models


Virtual models created using System Modeler.


Among all those circuits, I have modeled more than 13 analog filters used on vintage synthesizers. All those models can be run in a custom hardware module that I have designed. Now it’s possible to have the richness of sound of an analog filter, but conveniently packed into a fully digital module.


Hardware


An example of a custom hardware module.


I have made a complete version of this library available. You can download it to test for yourself. You can always download an unrestricted 30-day trial of System Modeler 12.1 and modify the included models to your own liking, or create your very own models for exploration, learning or advanced analysis.


For more details on what’s new in Wolfram System Modeler, visit the What’s New page or explore existing libraries at SystemModeler’s library store.








Download the AnalogModeling library featured in this post or sign up for a free System Modeler trial.









Engage with the code in this post by downloading the Wolfram Notebook




]]>
			https://blog.wolfram.com:443/2020/07/23/digital-vintage-sound-modeling-analog-synthesizers-with-the-wolfram-language-and-system-modeler/feed/
		5