Refrigerios, comidas y cantidades de alimentos: Nuevo en Wolfram Language 11

Refrigerios, comidas y cantidades de alimentos

Wolfram Knowledgebase incluye propiedades detalladas e información nutricional de más de 37.000 "Food" y 1000 "FoodType" entidades. Usando la entrada de forma libre, EntityInstance, EntityGroup y Quantity, es fácil representar y calcular propiedades nutricionales de colecciones de alimentos, en particular, los contenidos calóricos, de fibra y azúcar del almuerzo y cena.

In[1]:=

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

Out[1]=

Use Ctrl+= (entrada de forma libre) para obtener fácilmente una cantidad de comida dada, expresada como una EntityInstance de una entidad de comida implícitamente definida de una cantidad determinada.

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]=

Vea la expresión de Quantity subyacente (que se muestra de forma predeterminada con formato en salidas).

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=

Expanda la entidad implícitamente definida anterior haciendo clic en [+].

In[4]:=

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

La entrada de forma libre también puede ser usada directamente en declaraciones programáticas.

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]=

Grupos de alimentos (e.g. comidas, refrigerios, etc.) pueden ser representados con EntityGroup.

In[7]:=

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

Encuentre el contenido nutricional del grupo de alimentos en su conjunto.

In[8]:=

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

Out[8]=

Use EntityGroup y EntityInstance para analizar una cena con espaguetis.

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]=

Ejemplos relacionados

Refrigerios, comidas y cantidades de alimentos

Prepare aspirina

Evalúe una bolsa de monedas

Explore la cinematografía

Autoanálisis de Wolfram Language

Visualice la nutrición en términos de valores diarios recomendados

Potencia de un Pokémon

Yoga para la salud y el conocimiento

Cree un EntityStore de meteoros de bolas de fuego

Enumere estructuras de PCB y comparta por medio de un EntityStore

Riesgo de cáncer con base en actividad física usando un EntityStore

EntityStore de transformadas integrales

Pinturas y artistas del Museo de Arte Moderno

Análisis de los números de la Maratón de Chicago del 2015

Becas de la Fundación Nacional de Ciencia

Datos institucionales de la Corporación Federal de Seguro de Depósitos

Pronóstico del tiempo

Trace el Paso del Noroeste con modelado geomagnético

Visualice Wolfram Language

Función especial de red de derivadas

Segmente y analice ingredientes de recetas

Analice, visualice y compare "superalimentos"

Consultas de propiedades y entidades de forma libre

Generación de cuestionarios en línea