Snacks, Meals, and Food Quantities: New in Wolfram Language 11

Snacks, Meals, and Food Quantities

The Wolfram Knowledgebase includes detailed properties and nutritional information for more than 37,000 "Food" and 1000 "FoodType" entities. Using free-form input, EntityInstance, EntityGroup, and Quantity, it is easy to represent and compute nutritional properties of collections of food, in particular the caloric, fiber, and sugar contents of lunch and dinner.

In[1]:=

✖

Table[EntityValue[foodtype, 
  "EntityCount"], {foodtype, {"Food", "FoodType"}}]

Out[1]=

Use Ctrl+= (free-form input) to easily obtain a given quantity of food, expressed as an EntityInstance of an implicitly defined food entity of specified amount.

In[2]:=

✖

\!\(
NamespaceBox["LinguisticAssistant",
DynamicModuleBox[{Typeset`query$$ = "2 tbsp peanut butter", 
    Typeset`boxes$$ = RowBox[{"EntityInstance", "[", 
RowBox[{
InterpretationBox[
DynamicModuleBox[{EntityFramework`Formatting`Private`open = False}, 
TemplateBox[{
TemplateBox[{"\"foods\""}, "GeneralizedEntityBase"], 
TagBox[
GridBox[{{
TemplateBox[{
TemplateBox[{"\"food type\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"FoodType\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \\\"FoodType\\\"]\
\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", 
TemplateBox[{"\"peanut butter\"", 
RowBox[{"Entity", "[", 
RowBox[{"\"FoodType\"", ",", "\"PeanutButter\""}], "]"}], 
                    "\"Entity[\\\"FoodType\\\", \\\"PeanutButter\\\"]\
\"", "\"food type\""}, "Entity"], "}"}], "]"}]}, 
                 "GeneralizedEntityInfoRow"]}, {
TemplateBox[{
TemplateBox[{"\"added food types\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"AddedFoodTypes\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"]\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", "}"}], "]"}]}, "GeneralizedEntityInfoRow"]}}, 
              GridBoxAlignment -> {"Columns" -> {{Left}}}, 
              DefaultBaseStyle -> "GeneralizedEntityInfoGrid", 
              GridBoxItemSize -> {
               "Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}}], 
             "Column"], 
Dynamic[EntityFramework`Formatting`Private`open], 
            "\"Entity[\\\"Food\\\", {EntityProperty[\\\"Food\\\", \
\\\"FoodType\\\"] -> ContainsExactly[{Entity[\\\"FoodType\\\", \
\\\"PeanutButter\\\"]}], EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"] -> ContainsExactly[{}]}]\""}, 
           "GeneralizedEntityToggle"]], 
Entity["Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "PeanutButter"]}], 
           EntityProperty[
            "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
         SelectWithContents -> True], ",", " ", 
TemplateBox[{"2", "\"tbsp\"", "tablespoons", "\"Tablespoons\""}, 
         "Quantity", SyntaxForm -> Mod]}], "]"}], 
    Typeset`allassumptions$$ = {{
     "type" -> "Unit", "word" -> "tbsp", 
      "template" -> "Assuming ${desc1} for \"${word}\". Use ${desc2} \
instead", "count" -> "4", 
      "Values" -> {{
        "name" -> "Tablespoons", "desc" -> "US tablespoons", 
         "input" -> "UnitClash_*tbsp.*Tablespoons--"}, {
        "name" -> "TablespoonsUK", "desc" -> "UK tablespoons", 
         "input" -> "UnitClash_*tbsp.*TablespoonsUK--"}, {
        "name" -> "MetricTablespoons", "desc" -> "metric tablespoons",
          "input" -> "UnitClash_*tbsp.*MetricTablespoons--"}, {
        "name" -> "TablespoonsAustralian", 
         "desc" -> "Australian tablespoons", 
         "input" -> "UnitClash_*tbsp.*TablespoonsAustralian--"}}}}, 
    Typeset`assumptions$$ = {}, Typeset`open$$ = {1}, 
    Typeset`querystate$$ = {
    "Online" -> True, "Allowed" -> True, 
     "mparse.jsp" -> 0.574756`6.211028507153325, "Messages" -> {}}}, 
DynamicBox[ToBoxes[
AlphaIntegration`LinguisticAssistantBoxes["", 4, Automatic, 
Dynamic[Typeset`query$$], 
Dynamic[Typeset`boxes$$], 
Dynamic[Typeset`allassumptions$$], 
Dynamic[Typeset`assumptions$$], 
Dynamic[Typeset`open$$], 
Dynamic[Typeset`querystate$$]], StandardForm],
ImageSizeCache->{138., {7., 16.}},
TrackedSymbols:>{
      Typeset`query$$, Typeset`boxes$$, Typeset`allassumptions$$, 
       Typeset`assumptions$$, Typeset`open$$, Typeset`querystate$$}],
DynamicModuleValues:>{},
UndoTrackedVariables:>{Typeset`open$$}],
BaseStyle->{"Deploy"},
DeleteWithContents->True,
Editable->False,
SelectWithContents->True]\)

Out[2]=

View the underlying Quantity expression (by default, displayed in formatted form in outputs).

In[3]:=

✖

\!\(
NamespaceBox["LinguisticAssistant",
DynamicModuleBox[{Typeset`query$$ = "2 tbsp peanut butter", 
    Typeset`boxes$$ = RowBox[{"EntityInstance", "[", 
RowBox[{
InterpretationBox[
DynamicModuleBox[{EntityFramework`Formatting`Private`open = False}, 
TemplateBox[{
TemplateBox[{"\"foods\""}, "GeneralizedEntityBase"], 
TagBox[
GridBox[{{
TemplateBox[{
TemplateBox[{"\"food type\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"FoodType\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \\\"FoodType\\\"]\
\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", 
TemplateBox[{"\"peanut butter\"", 
RowBox[{"Entity", "[", 
RowBox[{"\"FoodType\"", ",", "\"PeanutButter\""}], "]"}], 
                    "\"Entity[\\\"FoodType\\\", \\\"PeanutButter\\\"]\
\"", "\"food type\""}, "Entity"], "}"}], "]"}]}, 
                 "GeneralizedEntityInfoRow"]}, {
TemplateBox[{
TemplateBox[{"\"added food types\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"AddedFoodTypes\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"]\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", "}"}], "]"}]}, "GeneralizedEntityInfoRow"]}}, 
              GridBoxAlignment -> {"Columns" -> {{Left}}}, 
              DefaultBaseStyle -> "GeneralizedEntityInfoGrid", 
              GridBoxItemSize -> {
               "Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}}], 
             "Column"], 
Dynamic[EntityFramework`Formatting`Private`open], 
            "\"Entity[\\\"Food\\\", {EntityProperty[\\\"Food\\\", \
\\\"FoodType\\\"] -> ContainsExactly[{Entity[\\\"FoodType\\\", \
\\\"PeanutButter\\\"]}], EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"] -> ContainsExactly[{}]}]\""}, 
           "GeneralizedEntityToggle"]], 
Entity["Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "PeanutButter"]}], 
           EntityProperty[
            "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
         SelectWithContents -> True], ",", " ", 
TemplateBox[{"2", "\"tbsp\"", "tablespoons", "\"Tablespoons\""}, 
         "Quantity", SyntaxForm -> Mod]}], "]"}], 
    Typeset`allassumptions$$ = {{
     "type" -> "Unit", "word" -> "tbsp", 
      "template" -> "Assuming ${desc1} for \"${word}\". Use ${desc2} \
instead", "count" -> "4", 
      "Values" -> {{
        "name" -> "Tablespoons", "desc" -> "US tablespoons", 
         "input" -> "UnitClash_*tbsp.*Tablespoons--"}, {
        "name" -> "TablespoonsUK", "desc" -> "UK tablespoons", 
         "input" -> "UnitClash_*tbsp.*TablespoonsUK--"}, {
        "name" -> "MetricTablespoons", "desc" -> "metric tablespoons",
          "input" -> "UnitClash_*tbsp.*MetricTablespoons--"}, {
        "name" -> "TablespoonsAustralian", 
         "desc" -> "Australian tablespoons", 
         "input" -> "UnitClash_*tbsp.*TablespoonsAustralian--"}}}}, 
    Typeset`assumptions$$ = {}, Typeset`open$$ = {1}, 
    Typeset`querystate$$ = {
    "Online" -> True, "Allowed" -> True, 
     "mparse.jsp" -> 0.574756`6.211028507153325, "Messages" -> {}}}, 
DynamicBox[ToBoxes[
AlphaIntegration`LinguisticAssistantBoxes["", 4, Automatic, 
Dynamic[Typeset`query$$], 
Dynamic[Typeset`boxes$$], 
Dynamic[Typeset`allassumptions$$], 
Dynamic[Typeset`assumptions$$], 
Dynamic[Typeset`open$$], 
Dynamic[Typeset`querystate$$]], StandardForm],
ImageSizeCache->{138., {7., 16.}},
TrackedSymbols:>{
      Typeset`query$$, Typeset`boxes$$, Typeset`allassumptions$$, 
       Typeset`assumptions$$, Typeset`open$$, Typeset`querystate$$}],
DynamicModuleValues:>{},
UndoTrackedVariables:>{Typeset`open$$}],
BaseStyle->{"Deploy"},
DeleteWithContents->True,
Editable->False,
SelectWithContents->True]\);
Cases[%, _Quantity] // InputForm

Out[3]//InputForm=

Expand the preceding implicitly defined entity by clicking the [+].

In[4]:=

✖

EntityInstance[Entity[
 "Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "PeanutButter"]}], 
   EntityProperty["Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
 Quantity[2, "Tablespoons"]]

Free-form input can also be used directly in programmatic statements.

In[5]:=

✖

peanutButter = \!\(\*
NamespaceBox["LinguisticAssistant",
DynamicModuleBox[{Typeset`query$$ = "2 tbsp peanut butter", 
     Typeset`boxes$$ = RowBox[{"EntityInstance", "[", 
RowBox[{
InterpretationBox[
DynamicModuleBox[{EntityFramework`Formatting`Private`open = False}, 
TemplateBox[{
TemplateBox[{"\"foods\""}, "GeneralizedEntityBase"], 
TagBox[
GridBox[{{
TemplateBox[{
TemplateBox[{"\"food type\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"FoodType\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \\\"FoodType\\\"]\
\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", 
TemplateBox[{"\"peanut butter\"", 
RowBox[{"Entity", "[", 
RowBox[{"\"FoodType\"", ",", "\"PeanutButter\""}], "]"}], 
                    "\"Entity[\\\"FoodType\\\", \\\"PeanutButter\\\"]\
\"", "\"food type\""}, "Entity"], "}"}], "]"}]}, 
                  "GeneralizedEntityInfoRow"]}, {
TemplateBox[{
TemplateBox[{"\"added food types\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"AddedFoodTypes\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"]\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", "}"}], "]"}]}, "GeneralizedEntityInfoRow"]}}, 
               GridBoxAlignment -> {"Columns" -> {{Left}}}, 
               DefaultBaseStyle -> "GeneralizedEntityInfoGrid", 
               GridBoxItemSize -> {
                "Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}}],
               "Column"], 
Dynamic[EntityFramework`Formatting`Private`open], 
             "\"Entity[\\\"Food\\\", {EntityProperty[\\\"Food\\\", \\\
\"FoodType\\\"] -> ContainsExactly[{Entity[\\\"FoodType\\\", \
\\\"PeanutButter\\\"]}], EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"] -> ContainsExactly[{}]}]\""}, 
            "GeneralizedEntityToggle"]], 
Entity["Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "PeanutButter"]}], 
            EntityProperty[
             "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
          SelectWithContents -> True], ",", " ", 
TemplateBox[{"2", "\"tbsp\"", "tablespoons", "\"Tablespoons\""}, 
          "Quantity", SyntaxForm -> Mod]}], "]"}], 
     Typeset`allassumptions$$ = {{
      "type" -> "Unit", "word" -> "tbsp", 
       "template" -> "Assuming ${desc1} for \"${word}\". Use ${desc2} \
instead", "count" -> "4", 
       "Values" -> {{
         "name" -> "Tablespoons", "desc" -> "US tablespoons", 
          "input" -> "UnitClash_*tbsp.*Tablespoons--"}, {
         "name" -> "TablespoonsUK", "desc" -> "UK tablespoons", 
          "input" -> "UnitClash_*tbsp.*TablespoonsUK--"}, {
         "name" -> "MetricTablespoons", 
          "desc" -> "metric tablespoons", 
          "input" -> "UnitClash_*tbsp.*MetricTablespoons--"}, {
         "name" -> "TablespoonsAustralian", 
          "desc" -> "Australian tablespoons", 
          "input" -> "UnitClash_*tbsp.*TablespoonsAustralian--"}}}}, 
     Typeset`assumptions$$ = {}, Typeset`open$$ = {1}, 
     Typeset`querystate$$ = {
     "Online" -> True, "Allowed" -> True, 
      "mparse.jsp" -> 0.574756`6.211028507153325, "Messages" -> {}}}, 
     
DynamicBox[ToBoxes[
AlphaIntegration`LinguisticAssistantBoxes["", 4, Automatic, 
Dynamic[Typeset`query$$], 
Dynamic[Typeset`boxes$$], 
Dynamic[Typeset`allassumptions$$], 
Dynamic[Typeset`assumptions$$], 
Dynamic[Typeset`open$$], 
Dynamic[Typeset`querystate$$]], StandardForm],
ImageSizeCache->{138., {7., 16.}},
TrackedSymbols:>{
       Typeset`query$$, Typeset`boxes$$, Typeset`allassumptions$$, 
        Typeset`assumptions$$, Typeset`open$$, Typeset`querystate$$}],
     
DynamicModuleValues:>{},
UndoTrackedVariables:>{Typeset`open$$}],
BaseStyle->{"Deploy"},
DeleteWithContents->True,
Editable->False,
SelectWithContents->True]\)

Out[5]=

In[6]:=

✖

twoSlicesOfBread = \!\(\*
NamespaceBox["LinguisticAssistant",
DynamicModuleBox[{Typeset`query$$ = "2 slices of bread", 
     Typeset`boxes$$ = RowBox[{"EntityInstance", "[", 
RowBox[{
InterpretationBox[
DynamicModuleBox[{EntityFramework`Formatting`Private`open = False}, 
TemplateBox[{
TemplateBox[{"\"foods\""}, "GeneralizedEntityBase"], 
TagBox[
GridBox[{{
TemplateBox[{
TemplateBox[{"\"food type\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"FoodType\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \\\"FoodType\\\"]\
\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", 
TemplateBox[{"\"bread\"", 
RowBox[{"Entity", "[", 
RowBox[{"\"FoodType\"", ",", "\"Bread\""}], "]"}], 
                    "\"Entity[\\\"FoodType\\\", \\\"Bread\\\"]\"", 
                    "\"food type\""}, "Entity"], "}"}], "]"}]}, 
                  "GeneralizedEntityInfoRow"]}, {
TemplateBox[{
TemplateBox[{"\"added food types\"", 
RowBox[{"EntityProperty", "[", 
RowBox[{"\"Food\"", ",", "\"AddedFoodTypes\""}], "]"}], 
                    "\"EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"]\""}, "EntityProperty"], 
StyleBox["\":\"", "GeneralizedEntityInfoItem"], 
RowBox[{"ContainsExactly", "[", 
RowBox[{"{", "}"}], "]"}]}, "GeneralizedEntityInfoRow"]}}, 
               GridBoxAlignment -> {"Columns" -> {{Left}}}, 
               DefaultBaseStyle -> "GeneralizedEntityInfoGrid", 
               GridBoxItemSize -> {
                "Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}}],
               "Column"], 
Dynamic[EntityFramework`Formatting`Private`open], 
             "\"Entity[\\\"Food\\\", {EntityProperty[\\\"Food\\\", \\\
\"FoodType\\\"] -> ContainsExactly[{Entity[\\\"FoodType\\\", \
\\\"Bread\\\"]}], EntityProperty[\\\"Food\\\", \
\\\"AddedFoodTypes\\\"] -> ContainsExactly[{}]}]\""}, 
            "GeneralizedEntityToggle"]], 
Entity["Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "Bread"]}], 
            EntityProperty[
             "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
          SelectWithContents -> True], ",", " ", 
TemplateBox[{"2", "\"slices\"", "slices", "\"Slices\""}, "Quantity", 
          SyntaxForm -> Mod]}], "]"}], 
     Typeset`allassumptions$$ = {{
      "type" -> "Clash", "word" -> "bread", 
       "template" -> "Assuming \"${word}\" is ${desc1}. Use as \
${desc2} instead", "count" -> "2", 
       "Values" -> {{
         "name" -> "FoodType", "desc" -> "a food type", 
          "input" -> "*C.bread-_*FoodType-"}, {
         "name" -> "FoodTypeGroup", 
          "desc" -> " referring to food type group", 
          "input" -> "*C.bread-_*FoodTypeGroup-"}}}}, 
     Typeset`assumptions$$ = {"*C.bread-_*FoodType-"}, 
     Typeset`open$$ = {1}, Typeset`querystate$$ = {
     "Online" -> True, "Allowed" -> True, 
      "mparse.jsp" -> 0.662875`6.2729766336225925, "Messages" -> {}}}, 
DynamicBox[ToBoxes[
AlphaIntegration`LinguisticAssistantBoxes["", 4, Automatic, 
Dynamic[Typeset`query$$], 
Dynamic[Typeset`boxes$$], 
Dynamic[Typeset`allassumptions$$], 
Dynamic[Typeset`assumptions$$], 
Dynamic[Typeset`open$$], 
Dynamic[Typeset`querystate$$]], StandardForm],
ImageSizeCache->{117., {7., 16.}},
TrackedSymbols:>{
       Typeset`query$$, Typeset`boxes$$, Typeset`allassumptions$$, 
        Typeset`assumptions$$, Typeset`open$$, Typeset`querystate$$}],
     
DynamicModuleValues:>{},
UndoTrackedVariables:>{Typeset`open$$}],
BaseStyle->{"Deploy"},
DeleteWithContents->True,
Editable->False,
SelectWithContents->True]\)

Out[6]=

Groups of foods (e.g. meals, snacks, etc.) can be represented with EntityGroup.

In[7]:=

✖

pbjSandwich = EntityGroup[{
    twoSlicesOfBread,
    peanutButter,
    EntityInstance[Entity[
     "Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "Jelly"]}], 
       EntityProperty[
        "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
     Quantity[1, "Servings"]]
    }];

Find the nutrition content of the group of foods as a whole.

In[8]:=

✖

pbjSandwich[{EntityProperty["Food", "AbsoluteTotalCaloriesContent"], 
  EntityProperty["Food", 
   "AbsoluteTotalProteinContent"]}, "PropertyAssociation"]

Out[8]=

Use EntityGroup and EntityInstance to analyze a spaghetti dinner.

In[9]:=

✖

dinner = EntityGroup[{
    EntityInstance[Entity[
     "Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "Spaghetti"]}], 
       EntityProperty[
        "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
     Quantity[1, "Servings"]],
    EntityInstance[Entity[
     "Food", {EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "Meatball"]}], 
       EntityProperty[
        "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
     Quantity[3, "Items"]],
    EntityInstance[Entity[
     "Food", {
      EntityProperty["Food", "BrandName"] -> Entity[
        "FoodBrandName", "Bertolli"], 
       EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "Sauce"]}], 
       EntityProperty[
        "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
     Quantity[1.5, "Servings"]],
    EntityInstance[Entity[
     "Food", {
      EntityProperty["Food", "Flavor"] -> Entity[
        "FoodFlavor", "Cola"], 
       EntityProperty["Food", "FoodType"] -> ContainsExactly[{
Entity["FoodType", "CarbonatedBeverage"]}], 
       EntityProperty[
        "Food", "AddedFoodTypes"] -> ContainsExactly[{}]}], 
     Quantity[1, "USSodaCanVolumes"]]
    }];

In[10]:=

✖

dinner[{EntityProperty["Food", "AbsoluteTotalCaloriesContent"], 
  EntityProperty["Food", 
   "AbsoluteTotalSugarContent"]}, "PropertyAssociation"]

Out[10]=

Related Examples

Snacks, Meals, and Food Quantities

Prepare Aspirin

Valuate a Bag of Coins

Explore Movieology

Wolfram Language Self-Analysis

Visualize Nutrition in Terms of Daily Recommended Values

Pokémon Power

Yoga for Health and Knowledge

Create a Fireball Meteor EntityStore

Enumerate PCB Structures and Share via an EntityStore

Cancer Risk Based on Physical Activity Using an EntityStore

Integral Transform EntityStore

Museum of Modern Art Paintings and Artists

Running the Numbers on the 2015 Chicago Marathon

National Science Foundation Grants

Federal Deposit Insurance Corporation Institutional Data

Forecast the Weather

Chart the Northwest Passage with Geomagnetic Modeling

Visualize the Wolfram Language

Special Function Derivative Network

Parse and Analyze Recipe Ingredients

Analyze, Visualize, and Compare "Superfoods"

Free-Form Entity-Property Queries

Online Quiz Generation