Obracompleta Coleccionmodular 2023Alvaradogerman

Vista previa del material en texto

M
AT
H
EM
AT
IC
A
MATHEMATICA
Germán Alvarado Jiménez
MATHEMATICA
MATHEMATICA
Germán Alvarado Jiménez
Alvarado Jiménez, Germán
Mathematica / Germán Alvarado Jiménez, Bogotá: Universidad Santo Tomás, 2023.
105 páginas; gráficos, ilustraciones y tablas 
Incluye referencias bibliográficas (página 103) 
E-ISBN 978-958-782-586-2
1. Matemáticas 2. Tecnologías 3. Cálculo 4. Base de datos 5. Aplicativos – Dinámicos 6. Sintaxis-Mate-
máticas I. Universidad Santo Tomás (Colombia).
CDD 510 CO-BoUST
© Germán Alvarado Jiménez, autor, 2023
© Universidad Santo Tomás, 2023
Ediciones USTA
Bogotá, D. C., Colombia
Carrera 9 n. ̊ 51-11
Teléfono: (+571) 587 8797, ext. 2991
editorial@usta.edu.co
http://ediciones.usta.edu.co
Corrección de estilo:
María Carolina Suárez Sandoval
Diseño de cubierta:
Patricia Montaña D.
E-ISBN: 978-958-782-586-2
Primera edición, 2023
Universidad Santo Tomás
Vigilada Mineducación
Reconocimiento personería jurídica: 
Resolución 3645 del 6 de agosto de 1965, 
Minjusticia
Acreditación Institucional de Alta Calidad 
Multicampus: Resolución 014525 del 28 de julio 
de 2022, 8 años, MinEducación
Se prohíbe la reproducción total o parcial 
de esta obra, por cualquier medio, sin la 
autorización expresa del titular de los 
derechos.
CONTENIDO
Sesión 1. Reglas básicas 5
Sesión 2. Ayudantes de Mathematica 11
Sesión 3. Representación gráfica 17
Sesión 4. Asignaciones y definiciones del usuario 36
Sesión 5. Manejo de listas 44
Sesión 6. Comandos lógicos 56
Sesión 7. Ideas básicas de programación en Mathematica 61
Sesión 8. Objetos dinámicos: comando Manipulate 73
Referencias 98
Para Laura y Serú,
los Shift + Enter
de mi vida
Presentación
El uso de las tecnologías dentro del desarrollo de las clases de matemáticas es fundamental
para ayudar a la comprensión de los diferentes temas, esto por la facilidad de cálculo, repre-
sentación y determinación de modelos. El software Wolfram Mathematica, tiene las siguientes
características:
Maneja cálculo simbólico.
Permite realizar programación bajo cualquier paradigma.
Basado en el conocimiento: Wolfram Mathematica y su extensión anexa WolframAlpha permite
acceder a una extensa base de datos curados, actuales y computables.
En pocas líneas de código y de forma sencilla e intuitiva permite la creación de aplicativos
dinámicos que posibilitan la visualización del comportamiento de diversos modelos al manipu-
lar sus parámetros constitutivos.
El presente texto es un manual que tiene como principal objetivo facilitar la interacción con el
Programa Wolfram Mathematica que de ahora en delante se denominará como Mathematica.
En esta sesión veremos las reglas básicas para una eficiente interacción con Mathematica.
Sesión 1. Reglas básicas
Notebooks
Mathematica interactúa con el usuario a través de documentos de trabajo llamados notebooks,
donde se redactan las ordenes que el programa ejecutará en el kernel, los resultados se presen-
tan nuevamente en el notebook, estos tienen una extensión (.nb). Es posible utilizarlos como un
documento de procesador de texto, pero esta es una de varias opciones.
Las ordenes o entradas que se escriben en el programa van siendo etiquetadas por el símbolo
In[1]: que indica la entrada 1, y las respuestas o salidas del programa son etiquetadas por
Out[1]: indicando que es la respuesta correspondiente a la entrada 1, esta pareja se almacena
en una celda, que se señalan con grupos de corchetes a la derecha en el notebook. 
Para ser evaluada una entrada se debe ejecutar Shift + Enter, y en los PC la tecla Enter numérica
únicamente. La tecla Enter alfabética crea un espacio vertical, sin evaluar.
In[]:= 1 + 1
Out[]= 2
Cálculos básicos
Tipo calculadora
Las operaciones se pueden introducir directamente desde el teclado y evaluarlas como se indicó
anteriormente :
In[]:= 2 + 4
Out[]= 6
In[]:= 23*45
Out[]= 1035
Mathematica asume los espacios como productos, al introducir un espacio entre dos números
Mathematica automáticamente introduce el símbolo de multiplicación.
In[]:= 34×4
Out[]= 136
El símbolo porcentaje lo utiliza para hacer referencia a salidas anteriores. Por ejemplo, la salida
anterior más la salida anterior a la anterior.
In[]:= % + %%
Out[]= 1171
O también, se pueden nombrar con porcentaje y el número correspondiente a la salida, por
ejemplo la salida 1 más la salida 2.
In[]:= %1 + %2
Out[]= 8
Para introducir potencias, se utiliza el símbolo ^.
In[]:= 2^32
Out[]= 4294 967 296
6 | Curso de Mathematica.nb
Para realizar divisiones.
In[]:= 2/4
Out[]=
1
2
Mathematica trabaja preferentemente de forma simbólica, entonces muestra la respuesta que
representa la mayor exactitud posible, es más exacto dejar la presentación del resultado como
fracción que mostrar la salida en forma decimal, que por más cifras decimales que se calculen es
solo una aproximación.
In[]:= 2/7
Out[]=
2
7
Para que muestre una aproximación decimal se introduce un punto al final de cualquiera de las
cantidades que interviene en la operación.
In[]:= 2./7
Out[]= 0.285714
Reglas básicas de la sintaxis de Mathematica
En el software Mathematica es necesario tener presente las siguientes reglas de la sintaxis del
programa:
 Los comandos y nombres propios de Mathematica comienzan con mayúscula, se utiliza la
palabra en inglés.
 Los argumentos de las funciones se escriben entre paréntesis cuadrados [ ].
 Las listas o rangos se escriben entre corchetes ,{ , , } separados por comas.
 Los paréntesis redondos ( ) se utilizan para agrupar, como en álgebra.
Ejemplos del uso de las reglas de sintaxis
Algunos comando básicos para ilustrar el uso de las anteriores reglas.
In[]:= Factor[x^2 - x - 6]
Out[]= (-3 + x) (2 + x)
Mayúscula en F y los paréntesis [ ] para encerrar la expresión a factorizar, se observa que la x
aparece en azul mientras que el comando Factor aparece de color negro, en Mathematica el
Curso de Mathematica.nb | 7
color negro es para las expresiones que reconoce y azul para las que no reconoce, pero que no
necesariamente están mal, simplemente no las relaciona con algún comando o un valor previa-
mente establecido. Ahora, al momento de realizar la operación no tiene ninguna dificultad pues
lo hace de forma simbólica, no necesita tener una interpretación para la variable, la x se puede
reemplazar por cualquier expresión.
In[]:= Solve[x^2 - x - 6  0, x]
Out[]= {{x  -2}, {x  3}}
Mayúscula en S y los paréntesis [ ] para encerrar la ecuación que se va a resolver, la igualdad en
las ecuaciones es doble igual == y al tener el comando dos argumentos ellos se separan con
coma.
In[]:= N[2/7]
Out[]= 0.285714
Para obtener el valor numérico aproximado de una cantidad, también admite la posibilidad de
dos argumentos, donde el segundo es para establecer la cantidad de cifras decimales que va a
mostrar.
In[]:= N[Pi, 100]
Out[]= 3.1415926535897932384626433832795028841971693993751058209749445923078164062862
08998628034825342117068
Aproximación a cien cifras decimales, observe la P de π en mayúscula.
In[]:= Expand[(x + y)^10]
Out[]= x10 + 10 x9 y + 45 x8 y2 + 120 x7 y3 + 210 x6 y4 +
252 x5 y5 + 210 x4 y6 + 120 x3 y7 + 45 x2 y8 + 10 x y9 + y10
Observese el uso algebraico de los paréntesis ( ) como símbolo de agrupación.
In[]:= Simplify[%]
Out[]= (x + y)10
Para simplificar un expresión, y el símbolo porcentaje hace referencia a la salida inmediata-
mente anterior.
8 | Curso de Mathematica.nb
In[]:= Plot[x^2 - x - 6, {x, -5, 5}]
Out[]=
-4 -2 2 4
-5
5
10
15
20
25
Para el uso del comando Plot es necesario introducirdos argumentos, la fórmula de la función a
graficar y el rango de los valores que va a tomar la variable de la fórmula que se escribe entre
corchetes { } separado por comas.
In[]:= Plot[{x, x^2 - x - 6}, {x, -5, 5}]
Out[]=
-4 -2 2 4
-5
5
10
15
20
25
Para graficar dos funciones en un mismo plano coordenado. Obsérvese el doble uso que se hace
de los corchetes, en su primera aparición se esta agrupando en una lista las dos funciones a
graficar y en su segunda aparición especifica, no una lista, sino el rango de los valores que toma
la variable. Se puede dentro de la lista escribir más funciones que se deseen graficar.
In[]:= Table[{x, x^2 - x - 6}, {x, -5, 5}]
Out[]= {{-5, 24}, {-4, 14}, {-3, 6}, {-2, 0}, {-1, -4},
{0, -6}, {1, -6}, {2, -4}, {3, 0}, {4, 6}, {5, 14}}
Esta es la tabla de valores correspondientes a la primera gráfica avanzando desde -5 hasta 5 de
una unidad cada paso, el primer uso que se hace de los corchetes es para agrupar como una lista
Curso de Mathematica.nb | 9
las parejas ordenadas y el segundo es para determinar el rango de variación de la x. Obsérvese la
similitud que se tiene en la escritura entre el comando Plot y el comando Table en el ejemplo
anterior.
In[]:= ListPlot[%]
Out[]=
-4 -2 2 4
-5
5
10
15
20
25
Graficando los puntos que obtenidos en la salida anterior, como el comando ListPlot es una
orden compuesta por dos palabras cada una comienza con mayúscula pero pegadas (sin
espacio).
In[]:= Solve[{x + y  4, x - y  2}, {x, y}]
Out[]= {{x  3, y  1}}
Resolviendo un sistema de ecuaciones de dos ecuaciones y dos incógnitas, se agrupa con { } las
ecuaciones (es una lista) y las incógnitas (es otra lista) separadas por comas entre ellas como
también sus elementos en el interior de cada una de ellas. No únicamente resuelve sistemas
lineales también se pueden resolver sistemas no lineales:
In[]:= Solve[{x + y^2  4, x - y  2}, {x, y}]
Out[]= {{x  0, y  -2}, {x  3, y  1}}
Obsérvese como la respuesta se muestra como una lista que agrupa dos soluciones. También se
pueden resolver ecuaciones con el comando Reduce que da la posibilidad de resolver además
inecuaciones:
In[]:= Reduce[x^2 - x - 6 > 0, x]
Out[]= x < -2 || x > 3
Las dos barras verticales corresponden al conector lógico o, es decir la respuesta son los x
menores que -2 o mayores que 3.
10 | Curso de Mathematica.nb
Sesión 2. Ayudantes de Mathematica
Hasta aquí una de las principales dificultades de Mathematica es su interacción con el usuario,
sino se conoce el nombre del comando para realizar una acción u operación; y la complejidad y
exigencia en la escritura. Con la evolución del programa Mathematica desde su aparición en
1988, sus principales logros se han orientado al mejoramiento e incremento de algoritmos de
cálculo y facilitar su uso por parte de la población no experta, esto lo ha logrado con la creación
de asistentes como :
Paletas
En la barra de Menú de Mathematica está Paletas donde se encuentran asistentes de apunte y
click, por ejemplo, uno de ellos, Classroom Assintant (Ayudante de Clase).
Aquí encontrará todos los comandos básicos que seguramente utilizará durante su aprendizaje
de Mathematica y en sus cursos en la Universidad, el consejo es que explore su uso.
Las Paletas funcionan haciendo click sobre sus botones y automáticamente el esqueleto del
comando aparece en el notebook listo para rellenar y ejecutar. En la sección de Comandos
Básicos se encuentran varias pestañas donde aparecen los principales comandos para álgebra,
calculo, álgebra lineal, manejo de listas y gráficas en dos y tres dimensiones. El consejo, como
durante todo el curso, es explorar e investigar los diferentes comandos que aparecen.
Curso de Mathematica.nb | 11
Barra predictiva
Desde la versión 9 al ir escribiendo, Mathematica va dándole las opciones que cree que el
usuario va a necesitar, tanto antes como después de realizar el cálculo, intenta adivinar o prede-
cir que desea realizar el usuario.
Aquí, en el ejemplo, sugiere que hacer con la salida obtenida al realizar la factorización: dibu-
jarla, expandirla, derivarla, integrarla, y más opciones.
In[]:=
Out[]=
Wolfram|Alpha®
Uno de los grandes proyectos de Wolfram Research, la casa matriz de Mathematica, es que todo
el conocimiento sea computable, es decir, no solo que aparezca digitalizado sino que se pueda
operar sobre él. En la página de Internet www.wolframalpha.com se encuentran un gran número
de bases de datos a las cuales se puede acceder en forma de entrada de lingüística libre (en
inglés), intenta interpretar su pregunta.
Las características fundamentales de los datos que se encuentran en WolframAlpha son: 
 Los datos son curados, puede estar seguro de la veracidad del resultado;
 los datos son actuales, encuentra el valor más reciente que se conozca;
 y los datos son computables, al descargarlos a Mathematica los datos se comportan como listas las
cuales se pueden manipular y operar.
Wolfram|Alpha® desde Mathematica
Desde Mathematica se puede acceder de forma completa a WolframAlpha, al introducir un igual
al comienzo de una línea de cálculo; puede realizar la pregunta o cálculo que desee, por ejemplo:
12 | Curso de Mathematica.nb
In[]:= population of Colombia »
Colombia COUNTRY  population 

Out[]= 50 882884 people
In[]:= 500 digits of pi
[◼] NthDigit Pi, {1, 500}

Out[]= [◼] NthDigit [π, {1, 500}]
In[]:= plot sin 2x from 0 to 4pi
PlotSin[2 * x], x, 0, 4 * Pi

Out[]=
2 4 6 8 10 12
-1.0
-0.5
0.5
1.0
In[]:= 55 deg 45' N, 37 deg 37' E »
GeoPosition[{223 / 4, 2257 / 60}]

Out[]= GeoPosition
223
4
,
2257
60

In[]:= C6H5COOH
benzoic acid CHEMICAL

Out[]= benzoic acid
Curso de Mathematica.nb | 13
In[]:= apple vs. microsoft »
 Apple FINANCIAL ENTITY , Microsoft FINANCIAL ENTITY 

Out[]=  Apple , Microsoft 
Algunas de las bases de datos sobre las cuales WolframAlpha puede mostrar información apare-
cen en los comandos de Mathematica que terminan en Data, los cuales se pueden encontrar
mediante:
In[]:= ?*Data
System`
AdministrativeDivisionData GenomeData PolyhedronData
AircraftData GeodesyData ProteinData
AirportData GeoElevationData PsychrometricPropertyData
AirPressureData GeogravityModelData PulsarData
AirTemperatureData GeologicalPeriodData RawData
AlgebraicRulesData GeomagneticModelData ResamplingAlgorithmData
AnatomyData GeoProjectionData ResourceData
AstronomicalData GraphData SatelliteData
AudioData GraphElementData
ScheduledTaskInformationD-
ata
BlockchainBlockData GraphicsData SeriesData
BlockchainData HistoricalPeriodData SocialMediaData
BlockchainTransactionData HTTPRequestData SolarSystemFeatureData
BoxData HumanGrowthData SolidData
BridgeData HypothesisTestData SpaceCurveData
BroadcastStationData IconData SpeciesData
BuildingData ImageData SpectralLineData
ButtonData IslandData StandardAtmosphereData
CalendarData IsotopeData StandardOceanData
CellGroupData KnotData StarClusterData
ChartElementData LakeData StarData
ChemicalData LaminaData StoppingPowerData
CityData LanguageData StyleData
CloudAccountData LatticeData SupernovaData
CloudLoggingData LiftingFilterData SurfaceData
CloudObjectInformationData
LinearizingTransformationD-
ata SystemInformationData
14 | Curso de Mathematica.nb
ColorData MannedSpaceMissionData SystemModelSimulationData
ColorProfileData MathematicalFunctionData SystemProcessData
CometData MedicalTestData TemporalData
CompanyData MeteorShowerData TextData
CompressedData MineralData ThermodynamicData
ConstellationData MinorPlanetData TideDataContinuousWaveletData MortalityData TravelDirectionsData
ControllerInformationData MountainData TropicalStormData
CoordinateChartData MovieData TunnelData
CoordinateTransformData NebulaData UnderseaFeatureData
CountryData NeighborhoodData UniverseModelData
DamData NuclearExplosionData UniversityData
DeepSpaceProbeData NuclearReactorData ValuesData
DiscreteWaveletData OceanData VectorGlyphData
DocumentGeneratorInforma-
tionData OLEData VirtualGroupData
EarthImpactData OptimumFlowData VolcanoData
EarthquakeData OutputFormData WeatherData
ElementData ParkData WeatherForecastData
EvaluationData ParticleAcceleratorData WeightedData
EventData ParticleData WikipediaData
ExampleData PersonData WindDirectionData
ExoplanetData PhysicalSystemData WindSpeedData
FetalGrowthData PIDData WindVectorData
FinancialData PlaneCurveData WolframLanguageData
FiniteGroupData PlanetaryMoonData WordData
FormulaData PlanetData WordFrequencyData
GalaxyData PlantData ZIPCodeData
Ejercicios
1. Calcular:
a. 1 /5 +3/8-2/7
b. 1/(2+3/(1-3/2))
Y expresar el resultado como fraccionario y como decimal con 10 cifras.
2. Calcular:
a. Sen(π/10)
b. ln(2)
Curso de Mathematica.nb | 15
3. Factorizar:
a. 2 x5 + 10 x4 - 5 x3 + 14 x2-17x+4
b. 4 x4 y - 11 x3 y2 + 6 x2 y3
4. Simplificar:
a. (-27)2/3 4-5/2
b. 2 x2/3  y1/22 3 x-5/6  y1/3
c. (3 x - 2 y + z)2 + (4 x - 5 z)3 - (2 x + 6 y - 7 z)2
5. Resolver:
a. x2 - x + 1 = 0
b. x3 - 2 x + 1 = 0
c. x (1 - 2 x)-3/2 + (1 - 2 x)-1/2 = 0
d. 1 + x + x = 5
6. Resolver el siguiente sistema de ecuaciones:
x - y + 3 z = 4 (1)
x + 2 y - 2 z = 10
3 x - y + 5 z = 14
(2)
(3)
7. Expandir:
(x + 1)100
8. Graficar las funciones Seno y ArcoSeno en un mismo plano cartesiano.
9. Determinar el comportamiento del peso colombiano frente al dolar durante el presente año.
10. Determinar un gráfico comparativo del número de goles marcados por Cristiano Ronaldo y Lionel
Messi desde 2010.
16 | Curso de Mathematica.nb
Sesión 3. Representación gráfica
Una de las principales características de Mathematica es su capacidad de representación gráfica, tanto
en dos como tres dimensiones. En esta sección se desarrollan los principales entornos gráficos como
las múltiples opciones que cada uno permite.
Visualización de funciones: gráficos básicos
El entorno básico para la representación de una función en dos dimensiones es el comando
Plot f ,  x , xmin , xmax , por ejemplo para graficar la función seno entre -3π y 3π, el programa
determina de forma automática el rango más adecuado para la presentación de la gráfica.
In[]:= Plot[Sin[x], {x, -3 π, 3 π}]
Out[]=
-5 5
-1.0
-0.5
0.5
1.0
Gráfica de varias funciones en un único sistema de coordenadas, cabe resaltar el doble uso de los
corchetes { }, en primer caso para agrupar un conjunto de funciones y en segundo caso para especificar
los valores que toma la variable independiente. Mathematica diferencia las gráficas con el uso de
diferentes colores.
In[]:= PlotSin[x], 2 Sin[2 x],
1
3
Sin[3 x], {x, 0, 2 π}
Out[]=
1 2 3 4 5 6
-2
-1
1
2
Curso de Mathematica.nb | 17
Podemos anexarle una tabla de identificación de las funciones haciendo referencia a su color en la
gráfica.
In[]:= PlotSin[x], 2 Sin[2 x],
1
3
Sin[3 x], {x, 0, 2 Pi}, PlotLegends  "Expressions"
Out[]=
1 2 3 4 5 6
-2
-1
1
2
sin(x)
2 sin(2 x)
1
3
sin(3 x)
También, podemos identificarlas con una etiqueta que aparece al pasar el mouse sobre cada una de las
funciones.
In[]:= PlotTooltipSin[x], 2 Sin[2 x],
1
3
Sin[3 x], {x, 0, 2 Pi}
Out[]=
1 2 3 4 5 6
-2
-1
1
2
18 | Curso de Mathematica.nb
Opciones de gráficos
Se puede editar un gráfico por medio de opciones que se ubican después de su rango separado por
una coma: 
Plot [ f , {x, xmin, xmax}, Opciones]. 
Dada la gráfica:
In[]:= PlotSinx + 2 Sin[x], {x, 0, 3 π}
Out[]=
2 4 6 8
-1.0
-0.5
0.5
1.0
podemos modificar las etiquetas de los ejes.
In[]:= PlotSinx + 2 Sin[x], {x, 0, 3 π}, Ticks  Range0, 3 π,
π
2
, Automatic
Out[]=
π
2
π 3π
2
2π 5π
2
3π
-1.0
-0.5
0.5
1.0
Curso de Mathematica.nb | 19
Cambiando el estilo de las gráficas, por ejemplo: grosor, color y tipo de línea.
In[]:= PlotTooltipSin[x], 2 Sin[2 x],
1
3
Sin[3 x],
{x, 0, 2 π}, PlotStyle  {Thickness[0.05], Red, Dashed}
Out[]=
1 2 3 4 5 6
-2
-1
1
2
Cambiando más de un aspecto para una función.
In[]:= PlotSin[x], 2 Sin[2 x],
1
3
Sin[3 x], {x, 0, 2 π},
PlotStyle  {{Thickness[0.05], Yellow}, Red, Dashed}
Out[]=
1 2 3 4 5 6
-2
-1
1
2
Región sombreando con respecto a la gráfica y el eje.
In[]:= Plot[2 Sin[x] + x, {x, 0, 15}, Filling  Bottom]
Out[]=
2 4 6 8 10 12 14
5
10
15
20 | Curso de Mathematica.nb
Región sombreada entre dos gráficas.
In[]:= Plot[{Sin[x] + x / 2, Sin[x] + x}, {x, 0, 10}, Filling  {1  {2}}]
Out[]=
2 4 6 8 10
2
4
6
8
Opciones: PlotStyle
Otras opciones para PlotStyle en una gráfica.
In[]:= PlotSinx + 2 Sin[x], {x, 0, 3 π}, PlotStyle  {Thick, Dashed, Purple}
Out[]=
2 4 6 8
-1.0
-0.5
0.5
1.0
Para una lista de puntos creados de forma aleatoria.
In[]:= data = RandomInteger[{1, 10}, {12, 2}];
ListPlot[data, PlotStyle  {PointSize[Large], Red}]
Out[]=
2 4 6 8 10
1
2
3
4
5
6
7
Curso de Mathematica.nb | 21
Incorporando una imagen como textura de una gráfica:
In[]:= angelico = ;
In[]:= Plot3DSinx2 + y, {x, -2, 2}, {y, -3, 3},
PlotStyle  Texture[angelico], Mesh  None
Out[]=
Visualización de funciones: gráficos de superficie
 La función Plot3D construye el gráfico de funciones como superficies tridimensionales.
In[]:= Plot3D[Sin[x - Sin[y]], {x, 0, 3 π}, {y, 0, 4 π}]
Out[]=
22 | Curso de Mathematica.nb
Más de una función en un mismo sistema de coordenadas:
In[]:= Plot3D[{Sin[x - Sin[y]], Sin[y - Cos[x]]}, {x, 0, 3 π}, {y, 0, 4 π}]
Out[]=
Editando sus colores:
In[]:= Plot3D[{Sin[x - Sin[y]], Sin[y - Cos[x]]},
{x, 0, 3 π}, {y, 0, 4 π}, PlotStyle  {Yellow, Cyan}]
Out[]=
Curso de Mathematica.nb | 23
Transparencia de una gráfica:
In[]:= Plot3D x2 + y2 Exp1 - x2 - y2, {x, -3, 3},
{y, -3, 3}, PlotStyle  Opacity[0.5], Mesh  None
Out[]=
Escogiendo un dominio para la gráfica, aquí la utilidad de la función RegionFunction radica en poder
tomar dominios no rectangulares.
In[]:= Plot3D[x^2 + y^2, {x, -5, +5}, {y, -5, +5},
RegionFunction  Function[{x, y, z}, x^2 + y^2 ≤ 10]]
Out[]=
24 | Curso de Mathematica.nb
Visualización de funciones: gráficos de funciones paramétricas
Una curva paramétrica en dos dimensiones:
In[]:= ParametricPlot[{Cos[3 t], Sin[5 t]}, {t, 0, 2 π}]
Out[]=
-1.0 -0.5 0.5 1.0
-1.0
-0.5
0.5
1.0
Una región paramétrica en el plano:
In[]:= ParametricPlot[{v Cos[u], v Sin[u]}, {u, 0, Pi / 3}, {v, 1 / 2, 1}]
Out[]=
Curso de Mathematica.nb | 25
Visualización de funciones: curvas y superficies paramétricas 
Curva paramétrica en el espacio de variable t que toma valores entre 0 y 6π. 
In[]:= ParametricPlot3D
t
5
, Sin[t], Cos[t], {t, 0, 6 π}
Out[]=
Gráfica de un Toro (o dona), como una superficie paramétrica:
In[]:= ParametricPlot3D[{(3 + Cos[v]) Cos[u], (3 + Cos[v]) Sin[u], Sin[v]},
{u, 0, 2 Pi}, {v, 0, 2 Pi}, Mesh  None]
Out[]=
26 | Curso de Mathematica.nb
Dos Toros entrelazados, donde se ha editado su color:
In[]:= ParametricPlot3D[{{4 + (3 + Cos[v]) Sin[u], 4 + (3 + Cos[v]) Cos[u], 4 + Sin[v]},
{8 + (3 + Cos[v]) Cos[u], 3 + Sin[v], 4 + (3 + Cos[v]) Sin[u]}},
{u, 0, 2 Pi}, {v, 0, 2 Pi}, PlotStyle  {Red, Green}]
Out[]=
Una cinta de Möbius, como una superficie paramétrica:
In[]:= ParametricPlot3D[{Cos[t] (3 + r Cos[t / 2]), Sin[t] (3 + r Cos[t / 2]), r Sin[t / 2]},
{r, -1, 1}, {t, 0, 2 Pi}, Mesh  {5, 10}, PlotStyle  FaceForm[Red, Yellow]]
Out[]=
Curso de Mathematica.nb | 27
Opciones: Mesh
Es una opción para especificarqué tanto enmallado hacemos en el gráfico.
Veamos sin Mesh:
In[]:= PlotSinx + 2 Sin[x], {x, 0, π}
Out[]=
0.5 1.0 1.5 2.0 2.5 3.0
-0.2
0.2
0.4
0.6
0.8
1.0
Con Mesh:
In[]:= PlotSinx + 2 Sin[x], {x, 0, π}, Mesh  All
Out[]=
0.5 1.0 1.5 2.0 2.5 3.0
-0.2
0.2
0.4
0.6
0.8
1.0
28 | Curso de Mathematica.nb
Con el enmallado convencional que nos predetermina Mathematica:
In[]:= Plot3DCosx + y2, {x, -π, π}, {y, -2, 2}
Out[]=
Con un mayor enmallado:
In[]:= Plot3DCosx + y2, {x, -π, π}, {y, -2, 2}, Mesh  All
Out[]=
Curso de Mathematica.nb | 29
Cambiando el estilo del enmallado, tanto en dirección de las x como de las y:
In[]:= Plot3DSinx + y2, {x, -π, π}, {y, -2, 2},
Mesh  12, MeshStyle  {{Red}, {Blue, Thick}}
Out[]=
 
Opciones: exclusiones
Existen numerosas opciones para controlar la presentación de gráficos tridimensionales.
Las funciones con singularidades pueden presentar dificultades al momento de graficar. Por ejemplo,
la siguiente función tiene una singularidad en y = x2.
In[]:= Plot3D
3
y - x2
, {x, -3, 3}, {y, -3, 4}
Out[]=
30 | Curso de Mathematica.nb
Esta singularidad puede ser removida especificando la exclusión.
In[]:= Plot3D
3
y - x2
, {x, -3, 3}, {y, -3, 4}, Exclusions  y  x2
Out[]=
Visualización de funciones: gráficas de regiones definidas por desigualdades
Representando regiones del plano y del espacio mediante el uso de desigualdades en dos y tres
variables.
In[]:= RegionPlot
x2
9
+
y2
4
≤ 1, {x, -3, 3}, {y, 0, 2}
Out[]=
Curso de Mathematica.nb | 31
In[]:= RegionPlot1 ≤ x2 + 2 y2 ≤ 4 || 1 ≤ 3 (x - 1)2 + (y - 1)2 ≤ 4, {x, -2, 3}, {y, -2, 3}
Out[]=
In[]:= RegionPlot3Dx2 + y2 + z2 > 1 && x + y - z ≤ 2, {x, -1, 1}, {y, 0, 1}, {z, -1, 1}
Out[]=
32 | Curso de Mathematica.nb
Gráficos predeterminados (comando Graphics)
Mathematica contiene una colección de gráficos ya predeterminados a los cuales se puede acceder
dentro de los entornos Graphics[ ] en el plano y Graphics3D[ ] en el espacio.
In[]:= Graphics[{Red, Disk[], Green, Rectangle[{0, 0}, {2, 2}], Blue, Disk[{2, 2}]}]
Out[]=
In[]:= Graphics[{Circle[], Inset[x^2 + y^2  1, {0, 0}]}]
Out[]= x2 + y21
Curso de Mathematica.nb | 33
In[]:= Graphics[Table[{Hue[t / 20], Circle[{Cos[2 Pi t / 20], Sin[2 Pi t / 20]}]}, {t, 20}]]
Out[]=
In[]:= Graphics3D[Polygon[{{0, 0, 0}, {1, 1, 1}, {0, 1, 1}, {1, 0, 0}}]]
Out[]=
34 | Curso de Mathematica.nb
In[]:= Graphics3D[Cylinder[]]
Out[]=
Ejercicios
1. Grafique las funciones seno y coseno en un mismo plano coordenado desde 0 a 2π.
2. Modifique el anterior gráfico de tal forma que seno sea roja y coseno verde.
3. Modifique el anterior gráfico de tal forma que que seno sea punteada y coseno sea más gruesa.
4. Sombree la región comprendida entre las dos funciones del punto 1.
5. Sombree la región comprendida entre las dos funciones del punto 1 entre π/4 y 5π/4, conservando
el rango entre 0 y 2π.
6. Grafique la función -x
2-y2
 sobre el rectángulo [-2,3]x[-3,4].
7. Evalúe la siguiente entrada para determinar una lista de 12 puntos con valores entre 0 y 10 y realice
una representación gráfica de ellos.
data=Sort[RandomReal[{0,10},{12,2}]]
8. Trace líneas uniendo los puntos del gráfico anterior.
Curso de Mathematica.nb | 35
Sesión 4. Asignaciones y definiciones del usuario
Presentación
En Mathematica, aparte de las funciones que ya vienen predeterminadas, se pueden definir
funciones, asignar valores a variables y generar reglas de transformación.
Asignaciones y definiciones del usuario
Para realizar asignaciones dentro de una sección de Mathematica, las variables se pueden
nombrar con letras o combinaciones de letras y números (el primer elemento debe ser una letra)
y se aconseja que sea en minúscula. La asignación se realiza con un igual = (para las ecuaciones
es doble igual ==).
In[]:= a = 4;
El punto y coma al final es para que calcule pero no nos muestre el resultado,
In[]:= a^2 + a - 1
Out[]= 19
reemplazó el valor de a = 4 en la expresión,
In[]:= Solve[a^2 - a - 6  0, a]
Solve : 4 is not a valid variable.
Out[]= Solve[False, 4]
como se le asignó un valor a la letra a en esta sección, Mathematica no la asume como una
variable en la ecuación a resolver. Para limpiar (quitar la asignación hecha) lo hacemos con el
comando
In[]:= Clear[a]
y para todas las asignaciones hechas
In[]:= Clear["Global`*"]
Es importante fijarse en los colores que va tomando las letras con asignaciones (negras) y las no
asignadas (azules).
36 | Curso de Mathematica.nb
Asignaciones postergadas
Al asignar con = la variable inmediatamente toma el valor (o la fórmula) de la derecha, pero al
realizarlo con := la variable tomará el valor de la derecha al ser llamada (no inmediatamente), en
la mayoría de los casos básicos no hay diferencia pero veamos el siguiente caso:
In[]:= ran1 = RandomReal[];
In[]:= Table[ran1, {5}]
Out[]= {0.72397, 0.72397, 0.72397, 0.72397, 0.72397}
In[]:= ran2 := RandomReal[];
In[]:= Table[ran2, {5}]
Out[]= {0.793841, 0.0169638, 0.839856, 0.817869, 0.575161}
Aquí RandomReal[ ] genera un número seudo aleatorio entre 0 y 1, y Table[ ,{5}] una lista calcu-
lando 5 veces ran1 y ran2 en cada caso, analice los resultados.
Reglas de transformación
Sustituciones por medio de patrones: 
Reemplazar /. Replace expr , rules 
En la expresión de la izquierda se realiza el reemplazo de las apariciones de x por el valor 3,
In[]:= 1 + 2 x /. x  3
Out[]= 7
pero, nótese que a la letra x no se le ha realizado ninguna asignación.
In[]:= x
Out[]= x
Realizar la transformación por una expresión y posteriormente a esta expresión darle una nueva
asignación.
In[]:= 1 + x + x^2 /. x  2 - y
Out[]= 3 + (2 - y)2 - y
Curso de Mathematica.nb | 37
In[]:= % /. y  2
Out[]= 1
In[]:= x  3 + y
Out[]= x  3 + y
In[]:= x^2 + 9 /. %
Out[]= 9 + (3 + y)2
In[]:= (x + y) (x - y)^2 /. {x  3, y  1 - a}
Out[]= (4 - a) (2 + a)2
In[]:= {x, x^2, y, z} /. x -> a
Out[]= a, a2, y, z
In[]:= {x, x^2, y, z} /. x -> {a, b}
Out[]= {a, b}, a2, b2, y, z
También, se puede modificar el encabezado de una función o un comando.
In[]:= Sin[x] /. Sin -> Cos
Out[]= Cos[x]
Se puede realizar más de una asignación de forma simultánea, 
In[]:= x /. {x -> 1, x -> 3, x -> 7}
Out[]= 1
In[]:= x /. {{x -> 1}, {x -> 3}, {x -> 7}}
Out[]= {1, 3, 7}
38 | Curso de Mathematica.nb
Cambiando un patrón dentro de una expresión,
In[]:= 1 + x^2 + x^4 /. x^p_ -> f[p]
Out[]= 1 + f[2] + f[4]
el patrón que es x^3 es cambiado inmediatamente por u y no es afectado por la otra transformación,
pues primero estaba la orden de transformar en u.
In[]:= {x^2, x^3, x^4} /. {x^3 -> u, x^n_ -> p[n]}
Out[]= {p[2], u, p[4]}
Funciones
Definición de funciones
Las funciones se definen name  var _ := expr para el nombre de la función (name) y la variable
(var) seguida de guión al piso y se siguen las mismas indicaciones sobre el nombre dadas para la
asignación de variables, las funciones pueden definirse solo con = y no necesariamente := pero
es aconsejable este último.
In[]:= f[x_] := x^2 + 4 x + 1
Al momento de calcular ya no es necesario incluir el guión al piso,
In[]:= f[3]
Out[]= 22
Las funciones tienen la propiedad de actuar sobre listas.
In[]:= f[{1, 2, 3, 4, 5}]
Out[]= {6, 13, 22, 33, 46}
Observe que al calcular con paréntesis redondo Mathematica interpreta el producto de f por 3 y
no f calculado en 3.
In[]:= f (3)
Out[]= 3 f
Curso de Mathematica.nb | 39
Definición de funciones de más de una variable:
In[]:= f[x_, y_] := x + 2 y
In[]:= f[2, 3]
Out[]= 8
Aunque dos funciones tengan el mismo nombre Mathematica las diferencia por el número de argumen-
tos que se definen en ella,
In[]:=f[5]
Out[]= 46
In[]:= f[f[a, b]]
Out[]= 1 + 4 (a + 2 b) + (a + 2 b)2
In[]:= f[f[a], b]
Out[]= 1 + 4 a + a2 + 2 b
Al momento de graficar una función es importante incluir también su argumento.
In[]:= Plot[f[x], {x, -3, 3}]
Out[]=
-3 -2 -1 1 2 3
5
10
15
20
40 | Curso de Mathematica.nb
Sin el argumento
In[]:= Plot[f, {x, -3, 3}]
Out[]=
-3 -2 -1 1 2 3
-1.0
-0.5
0.5
1.0
Manejo simbólico de la expresión
In[]:= gra = Plot3D[f[x, y], {x, -1, 2}, {y, -2, 2}]
Out[]=
In[]:= f[gra]
Out[]= 1 + 4 +
2
Curso de Mathematica.nb | 41
Funciones definidas a trozos
In[]:= g1[x_] := Piecewise[{{x^2, x < 0}, {x, x > 0}}]
In[]:= Plot[g1[x], {x, -3, 3}]
Out[]=
-3 -2 -1 1 2 3
0.5
2.5
4.5
6.5
8.5
Aquí se le asigna el valor 2 para cualquier otro caso que no se haya contemplado dentro de las condi-
ciones sobre la variable independiente,
In[]:= g2[x_] := Piecewise[{{x^2, x < 0}, {x, x > 1}}, 2]
In[]:= Plot[g2[x], {x, -3, 3}]
Out[]=
-3 -2 -1 1 2 3
1
2
3
4
5
6
42 | Curso de Mathematica.nb
También en la Paleta de Ayudante de Clase en la pestaña de Avanzadas podemos encontrar:
In[]:=
expr1 condition1
expr2 condition2
� �
que nos ayuda a definir funciones de forma seccional.
Ejercicios
1. Defina la función f(x) = x - x2, y estudie su comportamiento graficando:
a. f(x-2) b. f(x+2)
c. f(2x) d. 2f(x)
e. f(-x) f. -f(x)
2. Defina la función f(x) = 2x, y realice una tabla de valores para valores de x entre -5 y 5 avanzando de
0.5 en 0.5, posteriormente grafique la tabla de valores.
3. Defina de forma seccional la función valor absoluto y trace su gráfica.
4. Defina y grafique la función parte entera (mayor número entero menor o igual al número x) y trace su
gráfica entre -3 y 3.
5. Calcule la derivada de la función f(x) = x^3-3x+2 y apoyándose en las reglas de transformación,
determine su valor en x = 0, 2, 5.
Curso de Mathematica.nb | 43
Sesión 5. Manejo de listas
Uno de los objetos básicos de Mathematica son las listas, que se utilizan para almacenar información
como también para agrupar objetos dentro de una misma categoría al momento de calcular un
comando como al momento de presentar un resultado. Aquí se verá su creación tanto como la manipu-
lación, diferentes operaciones, que se pueden realizar sobre ellas.
Creación de listas
El comando básico para la creación de listas es el comando Table que tiene la estructura general:
In[]:= Table expr ,  var , start , end 
In[]:= Table[k^2, {k, 1, 5}]
Out[]= {1, 4, 9, 16, 25}
También se puede especificar el salto entre los valores de la variable :
In[]:= Table expr ,  var , start , end , increment 
In[]:= Table[k^2, {k, 1, 5, 0.5}]
Out[]= {1., 2.25, 4., 6.25, 9., 12.25, 16., 20.25, 25.}
Al incluir tablas con dos variables se obtienen listas dentro de una lista, es decir, una lista de listas:
In[]:= Table expr ,  var1 , start , end ,  var2 , start , end 
In[]:= Table[a[i, j], {i, 1, 4}, {j, 1, 6}]
Out[]= {{a[1, 1], a[1, 2], a[1, 3], a[1, 4], a[1, 5], a[1, 6]},
{a[2, 1], a[2, 2], a[2, 3], a[2, 4], a[2, 5], a[2, 6]},
{a[3, 1], a[3, 2], a[3, 3], a[3, 4], a[3, 5], a[3, 6]},
{a[4, 1], a[4, 2], a[4, 3], a[4, 4], a[4, 5], a[4, 6]}}
In[]:= Table[2 i + 3 j, {i, 2, 6}, {j, 1, 10}]
Out[]= {{7, 10, 13, 16, 19, 22, 25, 28, 31, 34},
{9, 12, 15, 18, 21, 24, 27, 30, 33, 36}, {11, 14, 17, 20, 23, 26, 29, 32, 35, 38},
{13, 16, 19, 22, 25, 28, 31, 34, 37, 40}, {15, 18, 21, 24, 27, 30, 33, 36, 39, 42}}
44 | Curso de Mathematica.nb
In[]:= Table[2 i + 3 j, {i, 2, 6}, {j, 1, i}]
Out[]= {{7, 10}, {9, 12, 15}, {11, 14, 17, 20},
{13, 16, 19, 22, 25}, {15, 18, 21, 24, 27, 30}}
Se pueden especificar los valores determinados que se desean que tome la variable:
In[]:= Table expr ,  var ,  value1 , value2 , … 
In[]:= Table[k^2, {k, {1, 5, 6, 7, 20}}]
Out[]= {1, 25, 36, 49, 400}
Otro comando para la generación de listas es el comando Range:
In[]:= Range[5]
Out[]= {1, 2, 3, 4, 5}
In[]:= Range[3, 7]
Out[]= {3, 4, 5, 6, 7}
In[]:= Range[-6, 10, 3]
Out[]= {-6, -3, 0, 3, 6, 9}
Visualización de las listas
Las listas cuyos elementos también son listas, se pueden interpretar de varias formas, esto se eviden-
cia en sus diferentes formas de presentación, aquí algunas de ellas:
In[]:= FullForm[{{a, b}, {c, d}}]
Out[]//FullForm= List[List[a, b], List[c, d]]
Curso de Mathematica.nb | 45
In[]:= TreeForm[{{a, b}, {c, d}}]
Out[]//TreeForm=
List
List
a b
List
c d
In[]:= MatrixForm[{{a, b}, {c, d}}]
Out[]//MatrixForm=
a b
c d
In[]:= TableForm[{{a, b}, {c, d}}]
Out[]//TableForm=
a b
c d
Operaciones básicas con listas
Con las listas se pueden realizar varios tipos de operaciones:
Como matrices
In[]:= suma = {{2, 3}, {1, 4}, {5, 6}} + {{a, b}, {c, d}, {e, f}}
Out[]= {{2 + a, 3 + b}, {1 + c, 4 + d}, {5 + e, 6 + f}}
In[]:= producto = {{2, 3}, {1, 4}, {5, 6}}.{{7, 8}, {9, 0}}
Out[]= {{41, 16}, {43, 8}, {89, 40}}
46 | Curso de Mathematica.nb
In[]:= Transpose[suma]
Out[]= {{2 + a, 1 + c, 5 + e}, {3 + b, 4 + d, 6 + f}}
Como conjuntos 
Por ejemplo las listas:
In[]:= letras1 = {m, u, r, c, i, e, l, a, g, o}
Out[]= {m, u, r, c, i, e, l, a, g, o}
In[]:= letras2 = {d, e, t, e, r, g, e, n, t, e}
Out[]= {d, e, t, e, r, g, e, n, t, e}
Con ellas se puede realizar:
In[]:= letras = {letras1, letras2}
Out[]= {{m, u, r, c, i, e, l, a, g, o}, {d, e, t, e, r, g, e, n, t, e}}
In[]:= Union[letras1, letras2]
Out[]= {a, c, d, e, g, i, l, m, n, o, r, t, u}
In[]:= Join[letras1, letras2]
Out[]= {m, u, r, c, i, e, l, a, g, o, d, e, t, e, r, g, e, n, t, e}
In[]:= Intersection[letras1, letras2]
Out[]= {e, g, r}
In[]:= Complement[letras1, letras2]
Out[]= {a, c, i, l, m, o, u}
In[]:= Complement[letras2, letras1]
Out[]= {d, n, t}
Curso de Mathematica.nb | 47
In[]:= Dimensions[letras]
Out[]= {2, 10}
In[]:= Dimensions[letras1]
Out[]= {10}
In[]:= Flatten[letras]
Out[]= {m, u, r, c, i, e, l, a, g, o, d, e, t, e, r, g, e, n, t, e}
In[]:= Flatten[Partition[letras1, 2, 1]]
Out[]= {m, u, u, r, r, c, c, i, i, e, e, l, l, a, a, g, g, o}
In[]:= Flatten[{{{3, 1}, {2, 4}}, {{6, 7}, {8, 9}}}, 1]
Out[]= {{3, 1}, {2, 4}, {6, 7}, {8, 9}}
Funciones sobre listas
Operaciones para la manipulación de los objetos dentro de las listas:
Se define la lista:
In[]:= vec = {5, 2, 7, 2, 3, 7, 7, 2, 1}
Out[]= {5, 2, 7, 2, 3, 7, 7, 2, 1}
Se puede realizar una operación sobre todos los elementos de la lista:
In[]:= vec^2
Out[]= {25, 4, 49, 4, 9, 49, 49, 4, 1}
In[]:= 1 / vec
Out[]= 
1
5
,
1
2
,
1
7
,
1
2
,
1
3
,
1
7
,
1
7
,
1
2
, 1
48 | Curso de Mathematica.nb
Determinar su longitud:
In[]:= Length[vec]
Out[]= 9
Primer elemento:
In[]:= First[vec]
Out[]= 5
La lista sin su primer elemento:
In[]:= Rest[vec]
Out[]= {2, 7, 2, 3, 7, 7, 2, 1}
El último elemento:
In[]:= Last[vec]
Out[]= 1
Tomar un elemento en una posición determinada:
In[]:= Take[vec, 4]
Out[]= {5, 2, 7, 2}
Eliminar un elemento en una posición de la lista:
In[]:= Drop[vec, -2]
Out[]= {5, 2, 7, 2, 3, 7, 7}
Cambiar su orden:
In[]:= Reverse[vec]
Out[]= {1, 2, 7, 7, 3, 2, 7, 2, 5}
In[]:= Sort[vec]
Out[]= {1, 2, 2, 2, 3, 5, 7, 7, 7}
Curso de Mathematica.nb | 49
In[]:= Reverse[Sort[vec]]
Out[]= {7, 7, 7, 5, 3, 2, 2, 2, 1}
In[]:= RotateLeft[vec]
Out[]= {2, 7, 2, 3, 7, 7, 2, 1, 5}
In[]:= RotateRight[vec]
Out[]= {1, 5, 2, 7, 2, 3, 7, 7, 2}
In[]:= Partition[vec, 3]
Out[]= {{5, 2, 7}, {2, 3, 7}, {7, 2, 1}}
De una lista extraer elementos en alguna posición determinada:
In[]:= Part[vec, 3]
Out[]= 7
In[]:= Part[vec, -1]
Out[]= 1
In[]:= Part[vec, Range[5]]
Out[]= {5, 2, 7, 2, 3}
In[]:= Part[vec, 1 ;; 5]
Out[]= {5, 2, 7, 2, 3}
In[]:= Part[vec, {1, 3}]
Out[]= {5, 7}
In[]:= Position[vec, 2]
Out[]= {{2}, {4}, {8}}
In[]:= vec[[3]]
Out[]= 7
50 | Curso de Mathematica.nb
In[]:= vec[[{1, 3}]]
Out[]={5, 7}
In[]:= vec[[1 ;; 5]]
Out[]= {5, 2, 7, 2, 3}
In[]:= vec[[ ;; 5]]
Out[]= {5, 2, 7, 2, 3}
Por ejemplo, al calcular el valor mínimo de una función cercano a un valor dado, se obtiene como
salida una lista compuesta por el valor mínimo en su primera componente y en la segunda una lista
compuesta por el valor de la variable donde alcanzó dicho valor mínimo:
In[]:= FindMinimum[x Cos[x], {x, 2}]
Out[]= {-3.28837, {x  3.42562}}
Para extraer ese valor mínimo,
In[]:= FindMinimum[x Cos[x], {x, 2}][[1]]
Out[]= -3.28837
o la lista del valor donde lo alcanzó:
In[]:= FindMinimum[x Cos[x], {x, 2}][[2]]
Out[]= {x  3.42562}
Eliminando la presentación como una lista,
In[]:= FindMinimum[x Cos[x], {x, 2}][[2, 1]]
Out[]= x  3.42562
mostrando únicamente el valor de la variable, aquí se utiliza una regla de transformación:
In[]:= x /. FindMinimum[x Cos[x], {x, 2}][[2, 1]]
Out[]= 3.42562
Curso de Mathematica.nb | 51
Determinar el número de apariciones de cada elemento en una lista:
In[]:= Tally[vec]
Out[]= {{5, 1}, {2, 3}, {7, 3}, {3, 1}, {1, 1}}
Su acumulado numérico en cada posición:
In[]:= Accumulate[vec]
Out[]= {5, 7, 14, 16, 19, 26, 33, 35, 36}
La suma total de los elementos de la lista:
In[]:= Total[vec]
Out[]= 36
Adicionando elementos en una lista al final, al comienzo, en una posición determinada o reem-
plazando un valor por otro ya existente en la lista:
In[]:= Append[vec, 99]
Out[]= {5, 2, 7, 2, 3, 7, 7, 2, 1, 99}
In[]:= Prepend[vec, 0]
Out[]= {0, 5, 2, 7, 2, 3, 7, 7, 2, 1}
In[]:= Insert[vec, s, 3]
Out[]= {5, 2, s, 7, 2, 3, 7, 7, 2, 1}
In[]:= ReplacePart[vec, s, 3]
Out[]= {5, 2, s, 2, 3, 7, 7, 2, 1}
Seleccionar por propiedad
Se puede extraer o seleccionar elementos de una lista que cumplan alguna propiedad determinada:
dada la lista:
In[]:= numeros = 2, -3, 5.1, 2 , π, 6, 5, 
Out[]= 2, -3, 5.1, 2 , π, 6, 5, 
52 | Curso de Mathematica.nb
Se seleccionan los números que sean positivos, o enteros, o pares, o mayores que 2:
In[]:= Select[numeros, Positive]
Out[]= 2, 5.1, 2 , π, 6, 5, 
In[]:= Select[numeros, IntegerQ]
Out[]= {2, -3, 6, 5}
In[]:= Select[numeros, EvenQ]
Out[]= {2, 6}
In[]:= Select[numeros, # > 2 &]
Out[]= {5.1, π, 6, 5, }
Podemos preguntar si una lista contiene un elemento,
In[]:= MemberQ[numeros, 3]
Out[]= False
o si por el contrario está libre de este elemento, es decir no lo contiene:
In[]:= FreeQ[numeros, 3]
Out[]= True
En Mathematica los comandos que terminan en Q tienen como salida True o False, verifican si la
propiedad se cumple o no, por ejemplo: 
In[]:= PrimeQ[7]
Out[]= True
In[]:= IntegerQ[2 / 3]
Out[]= False
In[]:= ListQ[{1, 2}]
Out[]= True
Curso de Mathematica.nb | 53
Ejemplo: regresión lineal
En Mathematica se encuentra un grupo de comandos Fit (ubicados en Ayuda), que permiten realizar
procesos de ajuste de datos a una curva, pero se incluye como ejemplo un código para la realización de
una regresión lineal para que se evidencie el manejo de las listas:
In[]:=
Clear[li, xx, xi, xf, ca, m, b];
numero = Input["número de puntos"];
li = Table[{Input[x[i]], Input[y[i]]}, {i, 1, numero, 1}];
xx = Sort@Table[li[[i, 1]], {i, 1, numero, 1}];
xi = First[xx]; xf = Last[xx];
ca = Minimize[Sum[(m li[[j, 1]] + b - li[[j, 2]])^2, {j, 1, numero}], {m, b}]
Show[ListPlot[li], Plot[(m /. ca[[2, 1]]) x + (b /. ca[[2, 2]]), {x, xi, xf}],
PlotLabel  y  (m /. ca[[2, 1]]) x + (b /. ca[[2, 2]])]
Out[]= 
239
86
, m 
83
86
, b 
14
43

Out[]=
1 2 3 4 5 6
1
2
3
4
5
6
7
y 
83 x
86
+
14
43
Ejercicios
1. Determinar el elemento en la posición (4, 6) de lista1:
In[]:= lista1 = Table[i^3 - 4 j^2, {i, 3, 50, 2}, {j, 5, 67, 4}]
2. Dada la lista
In[]:= letras = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l",
"m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"}
54 | Curso de Mathematica.nb
Determinar :
 a. su longitud
 b. las letras en la posiciones pares
 c. las posiciones de las vocales
 d. la lista de letras en orden inverso 
3. Escribir el código para generar la lista de dos formas diferentes utilizando el comando Table.
{{0}, {0, 2}, {0, 2, 4}, {0, 2, 4, 6}, {0, 2, 4, 6, 8}}
4. La siguiente instrucción genera una lista de 30 enteros entre - 5 y 5.
In[]:= RandomInteger[{-5, 5}, 100]
a. Crear una función que calcule el número de ceros que aparecen en la lista, una vez la lista fue
calculada.
b. Que haga lo anterior para cualquier entero entre - 5 y 5.
5. Con la letra de cualquier canción (que tenga letra).
a. Realizar una tabla por orden alfabético que indique cuántas veces aparece cada letra.
a 62
b 2
...
b. Crear una función que al introducirle la letra diga el número de veces que aparece.
c. Realizar un gráfico, abecedario vs. número de veces que aparece cada letra.
6. La siguiente instrucción genera una matriz cuadrada de orden 4
In[]:= RandomInteger[9, {4, 4}] // MatrixForm
Construir una función que de la suma de cada una de las filas y las columnas.
7. Al ejecutar el siguiente comando se genera una lista de datos seudo-aleatorios:
Clear[to, datos]
to[x_] := 100 x - 4 x^3 + 0.1;
datos = Table[{5 x, x + (2 RandomReal[] - 1) / 10,
to[x] + (2 RandomReal[] - 1) / 10}, {x, 0.2, 5, 0.2}];
En la siguiente tabla se listan como tiempo (en segundos) y las coordenadas x y y (en metros):
In[]:= TableForm[datos, TableHeadings  {{}, {"tiempo(Sgs)", "x(mts)", "y(mts)"}},
TableAlignments  Center]
a. Graficar X vs. Y
b. Determinar la curva que mejor se ajusta a los datos, use comando Fit[ ]
c. Graficar la curva y los puntos juntos.
Curso de Mathematica.nb | 55
8. Construir un código de tal forma que dada una función f[x], grafique la función junto con su punto
mínimo.
9. Dadas las listas {1, 2, 3, 4} y {a, b, c, d} construir la lista {1, a, 2, b, 3, c, 4, d}
10. Crear una función que dadas dos listas, lista1 y lista2 de: 1 si lista1 ⊂ lista2, -1 si lista2 ⊂ lista1, 0 si
lista1 = lista2 y 2 en otro caso.
Sesión 6. Comandos lógicos
Mathematica tiene los comandos lógicos usuales que se pueden encontrar en la lógica tradicional,
actúan sobre proposiciones o listas de ellas, dando como salida True (en el caso de ser verdadero) o
False (en el caso de ser falso), si no puede determinar un valor de verdad para la afirmación retorna en
la salida la misma afirmación.
Para clarificar su definición y uso nos remetimos al siguiente conjunto de afirmaciones, proposiciones,
generando las cuatro posibles parejas de combinaciones de verdadero y falso con dos afirmaciones:
In[]:= posibles = {{2 < 3, 4 != 5}, {2 < 3, 4  5}, {2 > 3, 4 ≠ 5}, {2 > 3, 4  5}}
Out[]= {{True, True}, {True, False}, {False, True}, {False, False}}
Not (negación) ! ¬
Cambia el valor de verdad de cada una de las proposiciones a las que se le aplique, es el único
comando lógico que requiere un único argumento:
In[]:= TableForm[Table[{posibles[[n, 2]], Not[posibles[[n, 2]]]}, {n, 1, 2}],
TableHeadings  {None, {"p", "Not[p]"}}]
Out[]//TableForm=
p Not[p]
True False
False True
56 | Curso de Mathematica.nb
Or (o incluyente) ||
Es verdadero si alguna de las proposiciones involucradas lo es:
In[]:= TableForm[Table[
{posibles[[n, 1]], posibles[[n, 2]], Or[posibles[[n, 1]], posibles[[n, 2]]]},
{n, 1, 4}], TableHeadings  {None, {"p", "q", "Or[p,q]"}}]
Out[]//TableForm=
p q Or[p,q]
True True True
True False True
False True True
False False False
Nor (o negado) ⊽
Corresponde a la negación del anterior, es verdadero cuando ambas proposiciones son falsas:
In[]:= TableForm[Table[
{posibles[[n, 1]], posibles[[n, 2]], Nor[posibles[[n, 1]], posibles[[n, 2]]]},
{n, 1, 4}], TableHeadings  {None, {"p", "q", "Nor[p,q]"}}]
Out[]//TableForm=
p q Nor[p,q]
True True False
True False False
False True False
False False True
Xor (o excluyente) ⊻
Es verdaderocuando solo una de las proposiciones es verdadera:
In[]:= TableForm[Table[
{posibles[[n, 1]], posibles[[n, 2]], Xor[posibles[[n, 1]], posibles[[n, 2]]]},
{n, 1, 4}], TableHeadings  {None, {"p", "q", "Xor[p,q]"}}]
Out[]//TableForm=
p q Xor[p,q]
True True False
True False True
False True True
False False False
Curso de Mathematica.nb | 57
Xnor (o excluyente negado) 
Es verdadero cuando las dos proposiciones son verdaderas o las dos son falsas:
In[]:= TableForm[Table[{posibles[[n, 1]], posibles[[n, 2]],
Xnor[posibles[[n, 1]], posibles[[n, 2]]]}, {n, 1, 4}],
TableHeadings  {None, {"p", "q", "Xnor[p,q]"}}]
Out[]//TableForm=
p q Xnor[p,q]
True True True
True False False
False True False
False False True
And (y) &&
Es verdadera cuando las dos proposiciones son verdaderas:
In[]:= TableForm[Table[
{posibles[[n, 1]], posibles[[n, 2]], And[posibles[[n, 1]], posibles[[n, 2]]]},
{n, 1, 4}], TableHeadings  {None, {"p", "q", "And[p,q]"}}]
Out[]//TableForm=
p q And[p,q]
True True True
True False False
False True False
False False False
Nand (y negado) ⊼
Es verdadera cuando alguna o las dos proposiciones son falsas:
In[]:= TableForm[Table[{posibles[[n, 1]], posibles[[n, 2]],
Nand[posibles[[n, 1]], posibles[[n, 2]]]}, {n, 1, 4}],
TableHeadings  {None, {"p", "q", "Nand[p,q]"}}]
Out[]//TableForm=
p q Nand[p,q]
True True False
True False True
False True True
False False True
58 | Curso de Mathematica.nb
Implies (implicación) 
Es falsa cuando una proposición verdadera implica una falsa, es los demás casos es verdadera:
In[]:= TableForm[Table[{posibles[[n, 1]], posibles[[n, 2]],
Implies[posibles[[n, 1]], posibles[[n, 2]]]}, {n, 1, 4}],
TableHeadings  {None, {"p", "q", "Implies[p,q]"}}]
Out[]//TableForm=
p q Implies[p,q]
True True True
True False False
False True True
False False True
Equivalent (equivalente) ⇔
Es verdadera cuando las dos proposiciones tienen el mismo valor de verdad:
In[]:= TableForm[Table[{posibles[[n, 1]], posibles[[n, 2]],
Equivalent[posibles[[n, 1]], posibles[[n, 2]]]}, {n, 1, 4}],
TableHeadings  {None, {"p", "q", "Equivalent[p,q]"}}]
Out[]//TableForm=
p q Equivalent[p,q]
True True True
True False False
False True False
False False True
Ejemplos
Establecer si la afirmación es una tautología, verdadera bajo todos los posibles valores de verdad de
las proposiciones que intervienen en ella.
In[]:= Equivalent[a && (b || c), a && b || a && c] // TautologyQ
Out[]= True
Definición de una función que tiene como resultado el valor de verdad según el número que se ingrese.
In[]:= t[x_] := (x != 0 && 1 / x < 3)
In[]:= {t[0], t[3]}
Out[]= {False, True}
Curso de Mathematica.nb | 59
Se establecen dos afirmaciones sobre el plano: estar dentro del circulo centrado en el origen y de radio
uno, y estar por encima de la diagonal y = x, entonces tenemos:
In[]:= Manipulate[RegionPlot[operador[x^2 + y^2 < 1, x < y], {x, -2, 2}, {y, -2, 2}],
{operador, {And, Or, Xor, Implies, Equivalent, Nor, Nand, Xnor}}]
Out[]=
operador And
Ejercicios
1. Utilizando el comando TautologyQ, verificar:
a. las leyes de DeMorgan
b. la propiedad distributiva de And con respecto a Or
2. Determinar el valor de verdad de las siguientes afirmaciones:
a. ((P∨Q)∧¬T∧(Q→T))⟶P
b. (B∧(B→¬D)∧(A∨B))⟶A∧B
60 | Curso de Mathematica.nb
Sesión 7. Ideas básicas de programación en Mathematica
El lenguaje Wolfram permite de forma fácil e intuitiva realizar rutinas de programación, combinando
los diferentes paradigmas que se tienen en el desarrollo de programas: funcional, orientada a objetos y
procedimental.
Mathematica cuenta con una extensa librería de funciones pre diseñadas e incorporadas que facilitan
su uso, y en una corta línea de código se puede correr una rutina robusta.
Estructura básica de los comandos
Los comandos y elementos de Mathematica tienen la siguiente estructura :
Cabeza[argumento(s)]
Se pueden ver con los comandos FullForm[ ] y TreeForm[ ]:
In[]:= FullForm[a + b]
Out[]//FullForm= Plus[a, b]
In[]:= TreeForm[a + b]
Out[]//TreeForm=
Plus
a b
In[]:= FullForm[a b]
Out[]//FullForm= Times[a, b]
Curso de Mathematica.nb | 61
In[]:= TreeForm[a b + c^2]
Out[]//TreeForm=
Plus
Times
a b
Power
c 2
In[]:= FullForm[{a, b, c}]
Out[]//FullForm= List[a, b, c]
In[]:= TreeForm[{a, b, c}]
Out[]//TreeForm=
List
a b c
62 | Curso de Mathematica.nb
Comandos de Programación Funcional
Composición @ //
Muchos comandos de Mathematica se pueden componer entre ellos.
Ejemplo 1
Resolver la ecuación: x5 - x - 6 = 0.
Forma I
Primero se calcula la solución y luego se halla la forma numérica de las soluciones.
In[]:= sol = Solve[x^5 - x - 6  0, x]
Out[]= x  1.50… , x  -1.14… - 0.773…  , x  -1.14… + 0.773…  ,
x  0.390… - 1.40…  , x  0.390… + 1.40…  
In[]:= N[sol]
Out[]= {{x  1.49612}, {x  -1.13772 - 0.772999 }, {x  -1.13772 + 0.772999 },
{x  0.389655 - 1.40282 }, {x  0.389655 + 1.40282 }}
Forma II
En una sola línea se combina los dos cálculos anteriores, 
In[]:= N[Solve[x^5 - x - 6  0, x]]
Out[]= {{x  1.49612}, {x  -1.13772 - 0.772999 }, {x  -1.13772 + 0.772999 },
{x  0.389655 - 1.40282 }, {x  0.389655 + 1.40282 }}
o también, para ahorrar la escritura de paréntesis se utiliza el símbolo @ siempre que la operación
exterior tenga un único argumento.
In[]:= N@Solve[x^5 - x - 6  0, x]
Out[]= {{x  1.49612}, {x  -1.13772 - 0.772999 }, {x  -1.13772 + 0.772999 },
{x  0.389655 - 1.40282 }, {x  0.389655 + 1.40282 }}
Ejemplo 2
Forma I
Se puede realizar el cálculo línea por línea primero cargando desde WolframAlpha, donde se encuentra
toda la información del Genoma Humano, el gen correspondiente en este caso el llamado MRPS29P2,
Curso de Mathematica.nb | 63
luego convertir la cadena en una lista y por último calcular el número de veces que aparece cada una
de las cuatro letras que intervienen en el gen.
In[]:= gene = GenomeData["MRPS29P2"];
chars = Characters[gene];
Tally[chars]
Out[]= {{A, 150}, {T, 132}, {G, 131}, {C, 102}}
Forma II
Mediante la composición en una sola línea realizar todo el cálculo.
In[]:= Tally@Characters@GenomeData["MRPS29P2"]
Out[]= {{A, 150}, {T, 132}, {G, 131}, {C, 102}}
Limpiar todas las variables que ha cargado el kernel, núcleo, de Mathematica.
In[]:= Clear["Global`*"]
Comando Apply[ f , expr ] @@
Este comando sustituye la cabeza de una expresión por otra, su sintaxis es:
In[]:= Apply[cabezafinal, cabezainicial[argumento]]
Out[]= cabezafinal[argumento]
Aquí, al argumento x ya no le aplica g sino le aplica f,
In[]:= Apply[f, g[x]]
Out[]= f[x]
Ejemplo
Sumar los 100 primeros números enteros positivos.
Primero se genera la lista de los 100 primeros números enteros positivos.
64 | Curso de Mathematica.nb
In[]:= Range[100]
Out[]= {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100}
¿Qué forma tiene?
In[]:= FullForm[%]
Out[]//FullForm= List[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
Se cambia la cabeza List por la cabeza Plus:
In[]:= Apply[Plus, Range[100]]
Out[]= 5050
De forma resumida:
In[]:= Plus @@ Range[100]
Out[]= 5050
Comando Apply[ f , expr , {1}] @@@
Cambia la Cabeza de una expresión en un segundo nivel:
In[]:= Apply[cabezafinal,cabezainicial[cabezaintermedia[argumento]], {1}]
Out[]= cabezainicial[cabezafinal[argumento]]
Dejando g intacta, aplica al argumento x primero f, en lugar de h, y al resultado le aplica g.
In[]:= Apply[f, g[h[x]], {1}]
Out[]= g[f[x]]
Curso de Mathematica.nb | 65
Para cambiar g por f, dejando la cabeza List intacta, obsérvese que se actúa en un segundo nivel.
In[]:= f[{g[a], g[b], g[c]}]
Out[]= f[{g[a], g[b], g[c]}]
In[]:= Apply[f, {g[a], g[b], g[c]}]
Out[]= f[g[a], g[b], g[c]]
In[]:= Apply[f, {g[a], g[b], g[c]}, {1}]
Out[]= {f[a], f[b], f[c]}
In[]:= f @@@ {g[a], g[b], g[c]}
Out[]= {f[a], f[b], f[c]}
Comando Map[ f , expr ] /@
Aplica f a todos los elementos de una lista, a diferencia de Apply no cambia una cabeza por otra.
In[]:= Map[f, {a, b, c, d, e}]
Out[]= {f[a], f[b], f[c], f[d], f[e]}
Ejemplo
Sumar los logaritmos naturales de los 100 primeros enteros positivos.
Primero se utiliza Map, para obtener una lista formada por el logaritmo natural de los 100 primeros
enteros positivos.
Log /@ Range[100];
Mediante Apply se cambia la cabeza List por la cabeza Plus,
Plus @@ Log /@ Range[100];
por último se compone con el comando N, para calcular su valor decimal, de forma numérica,
In[]:= Plus @@ Log /@ Range[100] // N
Out[]= 363.739
66 | Curso de Mathematica.nb
Comando Nest[ f , expr , n ]
Aplica el comando f n veces partiendo de expr, ideal para procesos iterativos.
In[]:= Nest[f, x, 4]
Out[]= f[f[f[f[x]]]]
la lista de las composiciones sucesivas
In[]:= NestList[f, x, 4]
Out[]= {x, f[x], f[f[x]], f[f[f[x]]], f[f[f[f[x]]]]}
Ejemplo
considere la tarea de calcular el valor futuro de $1000 con un interés compuesto del 5% mensual,
después de 2 años.
Se sabe que la fórmula que permite realizar este cálculo es:
In[]:= valor[p_] := p 1 +
.05
12
componiéndola iterativamente a 1000 por 24 veces, se tiene:
In[]:= Nest[valor, 1000, 24]
Out[]= 1104.94
Se puede también obtener todos los valores intermedios de la iteración.
In[]:= NestList[valor, 1000, 24]
Out[]= {1000, 1004.17, 1008.35, 1012.55, 1016.77, 1021.01, 1025.26, 1029.53, 1033.82,
1038.13, 1042.46, 1046.8, 1051.16, 1055.54, 1059.94, 1064.36, 1068.79,
1073.24, 1077.72, 1082.21, 1086.72, 1091.24, 1095.79, 1100.36, 1104.94}
Para limpiar todas las variables utilizadas hasta ahora en el kernel de Mathematica, utilizamos el
comando:
Clear["Global`*"]
Curso de Mathematica.nb | 67
Comandos de programación procedimental (Do-For-While)
Estos comandos permiten realizar rutinas del tipo iterativas, donde uno o más parámetros van
tomando valores de forma secuencial y realizando una tarea.
Comando Do[ expr , { i , imin , imax , di }]
Es muy parecido a Table, o mejor Table es un caso de Do. Ejecuta expr durante los parámetros dados
por el iterador.
Ejemplo 1
Sumar los 100 primeros números enteros positivos.
In[]:= resultado = 0;
Do[resultado = resultado + i, {i, 1, 100, 1}]
resultado
Out[]= 5050
Ejemplo 2
Encontrar los 10 primeros números de la sucesión de Fibonacci.
Los dos primeros elementos son unos y los demás son la suma de los dos anteriores.
In[]:= fib = {1, 1};
Do[AppendTo[fib, fib[[-1]] + fib[[-2]]], {i, 3, 10, 1}]
fib
Out[]= {1, 1, 2, 3, 5, 8, 13, 21, 34, 55}
Ejemplo 3
Encontrar los 10 primeros primos de Mersenne.
Mersenne conjeturó que existen infinitos números primos de la forma 2n - 1. Hasta el momento se han
encontrado 45 y la conjetura aún está abierta.
In[]:= mers = {};
Do[If[PrimeQ[2^n - 1], AppendTo[mers, n]], {n, 100}]
mers
Out[]= {2, 3, 5, 7, 13, 17, 19, 31, 61, 89}
68 | Curso de Mathematica.nb
In[]:= (2^# - 1) &@mers
Out[]= {3, 7, 31, 127, 8191, 131 071, 524287, 2147483647,
2305843 009 213 693 951, 618 970019642690137449562111}
In[]:= Clear["Global`*"]
Comando For[start,test,incr,body]
Comienza con start y ejecuta body incrementando en cada paso incr mientras test sea verdadero.
Ejemplo 1
Sumar los 100 primeros números enteros positivos.
In[]:= resultado = 0;
For[i = 1, i <= 100, i++, resultado = resultado + i]
resultado
Out[]= 5050
Ejemplo 2
Encontrar los primeros 10 números de la sucesión de Fibonacci.
Los dos primeros elementos son unos y los demás son la suma de los dos anteriores.
In[]:= fib = {1, 1};
For[i = 3, i ≤ 10, i = i + 1, AppendTo[fib, fib[[-1]] + fib[[-2]]]]
fib
Out[]= {1, 1, 2, 3, 5, 8, 13, 21, 34, 55}
Ejemplo 3
Encontrar los 10 primeros números primos de Mersenne.
In[]:= mers = {};
For[n = 1, Length[mers] < 10, n++, If[PrimeQ[2^n - 1], AppendTo[mers, n]]]
mers
Out[]= {2, 3, 5, 7, 13, 17, 19, 31, 61, 89}
Curso de Mathematica.nb | 69
In[]:= (2^# - 1) &@mers
Out[]= {3, 7, 31, 127, 8191, 131 071, 524287, 2147483647,
2305843 009 213 693 951, 618 970019642690137449562111}
Comando While[ test , body ]
In[]:= While test , body 
Ejecuta body mientras test sea verdadero. Se pueden adicionar en la parte de body más de un proceso
separando con punto y coma.
Ejemplo 1
Sumar los 100 primeros números enteros positivos.
In[]:= resultado = 0; i = 0;
While[i <= 100, resultado = resultado + i; i++]
resultado
Out[]= 5050
Ejemplo 2
Encontrar los 10 primeros números de la sucesión de Fibonacci.
Los dos primeros elementos son unos y los demás son la suma de los dos anteriores.
In[]:= fibonacci = {1, 1}; i = 3;
While[i ≤ 10, AppendTo[fibonacci, fibonacci[[-1]] + fibonacci[[-2]]];
i++]
fibonacci
Out[]= {1, 1, 2, 3, 5, 8, 13, 21, 34, 55}
Programación en paralelo
Los computadores ahora cuentan con más de un núcleo incorporado que permite dividir tareas y así
realizar rutinas largas en un menor tiempo. Mathematica permite fácilmente partir los núcleos y
realizar computación en paralelo. Es claro que la programación en paralelo es útil cuando el proceso es
largo, en un proceso corto no se justifica, pues toma más tiempo en la inicialización de los núcleos que
realizando la tarea.
70 | Curso de Mathematica.nb
Comando AbsoluteTiming[ ]
Muestra el tiempo de computo, en segundos, necesario para realizar un proceso, permite comparar el
tiempo empleado al realizar un mismo procedimiento con diferentes ordenes y estilos de
programación.
Comando ParallelDo[ expr , { i , imin , imax , di }]
Con la misma sintaxis y función del comando Do.
Ejemplo
Encontrar los primeros 100 números primos de Mersenne.
In[]:= mers = {};
In[]:= SetSharedVariable[mers];(*reparte en cada núcleo la variable mers*)
In[]:= AbsoluteTiming[ParallelDo[If[PrimeQ[2^n - 1], AppendTo[mers, n]], {n, 1000}];
mers]
Out[]= {4.06606, {2, 3, 89, 5, 107, 7, 13, 127, 17, 19, 31, 61, 521, 607}}
In[]:= Clear["Global`*"]
In[]:= mers = {};
AbsoluteTiming[Do[If[PrimeQ[2^n - 1], AppendTo[mers, n]], {n, 1000}];
mers]
Out[]= {0.188651, {2, 3, 5, 7, 13, 17, 19, 31, 61, 89, 107, 127, 521, 607}}
Comparación de diferentes estilos de programación
Se utilizará el comando AbsoluteTiming para comparar la eficiencia de diferentes estilos de progra-
mación, verifique en su computador el tiempo empleado para cada proceso.
Ejemplo
Generar una lista aleatoria de números entre 0 y 1.
In[]:= ale = Table[RandomReal[], {10^6}];
Curso de Mathematica.nb | 71
Calcular la suma de los elementos de la lista llamada ale, de tres formas diferentes:
Forma I
In[]:= AbsoluteTiming[Plus @@ ale]
Out[]= {0.247148, 499 940.}
Forma II
In[]:= AbsoluteTiming[resultado = 0;
For[i = 1, i <= 1000000, i++, resultado += ale[[i]]];
resultado]
Out[]= {1.72742, 499 940.}
Forma III
In[]:= AbsoluteTiming[Total@ale]
Out[]= {0.005591, 499 940.}
Vuelva a realizar el ejercicio aumentando la cantidad de números aleatorios a 1012.
Ejercicios
1. Dada la tabla:
In[]:= tabla1 = Table[{RandomInteger[10], RandomReal[]}, {100}]
Generar una lista que cada entrada sea la suma de la pareja correspondiente.
2. Construir una lista que tenga cada pareja de la lista tabla1 en orden contrario.
3. Se conocencomo primos gemelos, primos primos y primos sexis las parejas de números primos que
se distancian de 2, 4 y 6 unidades respectivamente, por ejemplo (3,5) son primos gemelos, (3,7) son
primos primos y (5,11) son primos sexis. Se conjetura que existen infinitas parejas de cada uno.
Determinar 100 parejas de cada clase.
Ayuda: Estudie los comandos Prime[ ] y NextPrime[ ].
4. Se conjetura que existen infinitos números primos de la forma n2 + 1para n entero positivo. Encuen-
tre 20 de estos números.
5. Determinar el número de cifras del número de Mersenne número 20
6. Dada una matriz de tamaño 3×3 crear una función que en una lista de 6 elementos muestre la suma
de filas y de columnas.
7. Generalizar el problema anterior para una matriz de tamaño n×n.
72 | Curso de Mathematica.nb
Sesión 8. Objetos dinámicos: comando Manipulate
Desde la versión 6 de Mathematica, aparece una serie de comandos que permiten la creación de
objetos dinámicos manipulables por el usuario. Estos comandos, encabezados por el comando Manipu-
late[ ], dan la posibilidad de crear elegantes demostraciones (visualizaciones) del comportamiento de
gráficos, tablas al cambiar uno o varios de sus parámetros.
Introducción a comando Manipulate
Mathematica incorpora una interfaz de programación, que hace fácil para los no expertos la creación
rápida de interfaces sofisticadas y personalizadas. Estas interfaces se pueden ejecutar por medio de
controles utilizando el lenguaje simbólico de Mathematica, creando cálculos dinámicos y estupendas
visualizaciones.
 Decenas de controles y elementos de la interfaz: reguladores, casillas de verificación, etiquetas, infor-
mación sobre herramientas, ventanas emergentes, etc.
 Integración completa de la presentación gráfica, textual y tabular.
 Construcción de aplicativos dinámicos de forma rápida.
 Creación de presentaciones exportables en formato CDF (Formato de Documento Computable).
Ejemplos
Se comparan las visualizaciones, primero como las conocemos en los libros, de forma estática con-
siderando únicamente valores enteros de los parámetros y como fácilmente se pueden convertir en
forma dinámica, donde los parámetros recorren valores de forma continua y no discreta.
Es importante observar la sintaxis para cada uno de los comandos de Manipulate y como con
pequeños cambios se pueden obtener resultados diferentes, pero todos enmarcados en la misma
lógica y estructura de la sintaxis general de Mathematica.
Al realizar aplicativos por el comando Manipulate se realza la diferencia entre parámetros y variables
en una fórmula.
Curso de Mathematica.nb | 73
Ejemplo 1
Graficar la función Sin[n x], donde x toma valores entre 0 y 2π, y n valores positivos.
Estática
Realizando uno a uno gráficos para algunos valores de n,
In[]:= Plot[Sin[x], {x, 0, 2 π}]
Out[]=
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
In[]:= Plot[Sin[2 x], {x, 0, 2 π}]
Out[]=
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
In[]:= Plot[Sin[3 x], {x, 0, 2 π}]
Out[]=
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
In[]:= Plot[Sin[4 x], {x, 0, 2 π}]
Out[]=
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
74 | Curso de Mathematica.nb
o representar varios utilizando el comando Table.
In[]:= Table[Plot[Sin[n x], {x, 0, 2 π}], {n, 1, 4}]
Out[]= 
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
,
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
,
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
,
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0

Dinámica
Ahora, en la última instrucción con el comando Table se cambia la cabeza por el comando Manipulate,
obteniendo una presentación donde aparece un slider (deslizador) para el parámetro n que varía de
forma continua entre 1 y 4, ejecutando de forma dinámica estos cambios en la gráfica.
In[]:= Manipulate[Plot[Sin[n x], {x, 0, 2 π}], {n, 1, 4}]
Out[]=
n
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
Curso de Mathematica.nb | 75
Ejemplo 2
Determinar las primeras 30 potencias de 2.
Estática
Como una lista estática,
In[]:= Table[2^n, {n, 0, 30}]
Out[]= {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536,
131 072, 262144, 524 288, 1048576, 2097152, 4194304, 8388608, 16777216,
33 554432, 67108864, 134 217 728, 268435456, 536870912, 1073741824}
Dinámica
Como una presentación dinámica, aquí es importante aclarar en el slider que el parámetro n varía de
uno en uno:
In[]:= Manipulate[2^n, {n, 0, 30, 1}]
Out[]=
n
4096
Al quitar el 1 en {n, 0, 30, 1} la variable toma valores continuos y no de uno en uno:
In[]:= Manipulate[2^n, {n, 0, 30}]
Out[]=
n
35.7532
76 | Curso de Mathematica.nb
Ejemplo 3
Graficar las funciones trigonométricas en el intervalo entre 0 y 2π.
Estática
Graficando cada función por separado:
In[]:= Plot[Sin[x], {x, 0, 2 π}]
Out[]=
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
In[]:= Plot[Cos[x], {x, 0, 2 π}]
Out[]=
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
In[]:= Plot[Tan[x], {x, 0, 2 π}]
Out[]=
1 2 3 4 5 6
-6
-4
-2
2
4
6
Curso de Mathematica.nb | 77
O mediante una tabla que contiene por separado la gráfica de las tres (seno coseno y tangente):
In[]:= Table[Plot[f[x], {x, 0, 2 π}], {f, {Sin, Cos, Tan}}]
Out[]= 
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
,
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
,
1 2 3 4 5 6
-6
-4
-2
2
4
6

Dinámica
En una única presentación, observe que aquí no se genera un slider sino una botonera para los valores
discretos correspondientes a cada función.
In[]:= Manipulate[Plot[f[x], {x, 0, 2 π}], {f, {Sin, Cos, Tan}}]
Out[]=
f Sin Cos Tan
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
78 | Curso de Mathematica.nb
Ejemplo 4
Graficar las funciones f[n x], x en el intervalo entre 0 y 2π, f sea seno, coseno, tangente y n tome valores
entre 1 y 4 de forma.
Estática
Combinando los ejemplos 1 y 3, en un solo código:
In[]:= Table[Plot[Sin[n x], {x, 0, 2 π}], {n, 1, 4}]
Out[]= 
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
,
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
,
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
,
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0

In[]:= Table[Plot[Cos[n x], {x, 0, 2 π}], {n, 1, 4}]
Out[]= 
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
,
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
,
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
,
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0

Curso de Mathematica.nb | 79
In[]:= Table[Plot[Tan[n x], {x, 0, 2 π}], {n, 1, 4}]
Out[]= 
1 2 3 4 5 6
-6
-4
-2
2
4
6
,
1 2 3 4 5 6
-6
-4
-2
2
4
6
,
1 2 3 4 5 6
-6
-4
-2
2
4
6
,
1 2 3 4 5 6
-6
-4
-2
2
4
6

Dinámica
Incluyendo etiquetas para cada uno de los comandos:
In[]:= Manipulate[Plot[f[n x], {x, 0, 2 π}],
{{f, Sin, "Función"}, {Sin  "Seno", Cos  "Coseno", Tan  "Tangente"}},
{{n, 2, "Frecuencia"}, 1, 4}]
Out[]=
Función Seno Coseno Tangente
Frecuencia
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
80 | Curso de Mathematica.nb
Otros Ejemplos
Curvas de Lissajous
Observe que los slider no se mueven de forma continua sino discreta de uno en uno:
In[]:= Manipulate[ParametricPlot[{Cos[a t], Sin[b t]}, {t, 0, 2 π}],
{a, 3, 8, 1}, {b, 3, 13, 1}]
Out[]=
a
b
-1.0 -0.5 0.5 1.0
-1.0
-0.5
0.5
1.0
Curso de Mathematica.nb | 81
Etiqueta de salida
Observe que el slider muestra a la derecha el valor que está tomando:
In[]:= Manipulate[Plot[Sin[n x], {x, 0, 2 π}], {n, 1, 20, Appearance  "Labeled"}]
Out[]=
n 8.18
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
Los controles del slider aparecen visibles:
In[]:= Manipulate[Plot[Sin[n x], {x, 0, 2 π}], {n, 1, 20, Appearance  "Open"}]
Out[]=
n
7.7
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
82 | Curso de Mathematica.nb
Etiqueta dinámica
Para que muestre dentro de la misma presentación los valores del parámetro n:
In[]:= Manipulate[
Plot[Sin[n x], {x, 0, 2 π},
PlotLabel 
Style[StringForm["El Parámetro n = `1`", PaddedForm[n, {4, 2}]], 16]],
{n, 1, 20}
]
Out[]=
n
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
El Parámetro n = 5.82
Manipulandode forma dinámica los límites de una integral:
In[]:= ManipulateRowStringForm"
`2`
`1`
xx = ", b, a, Integrate[x, {x, a, b}],
{a, 1, 4}, {b, 5, 6}
Out[]=
a
b

2.274
5.557
xx = 12.8546
Curso de Mathematica.nb | 83
Etiquetando los parámetros
La función seno variándole tres parámetros:
Manipulate[Plot[a Sin[b (x + c)], {x, 0, 2 π}, PlotRange  4],
{a, 1, 4}, {b, 1, 5}, {c, 0, 2 π}]
Out[]=
a
b
c
1 2 3 4 5 6
-4
-2
2
4
Como no es claro en la salida a qué corresponde cada parámetro, es apropiado identificarlos
(etiquetarlos):
Manipulate[Plot[a Sin[b (x + c)], {x, 0, 2 π}, PlotRange  4],
{{a, 2, "Amplitud"}, 1, 4}, {{b, 3, "Frecuencia"}, 1, 5}, {{c, 0, "Fase"}, 0, 2 π}]
Out[]=
Amplitud
Frecuencia
Fase
1 2 3 4 5 6
-4
-2
2
4
84 | Curso de Mathematica.nb
Tipos de controles en Manipulate
Tipo de Control Ejemplo
Slider
x
0.35
2DSlider
x
{0.646, 0.77}
PopupMenu 0.4330
13
RadioButtonBar 1 2 3 4 5 5
CheckBoxBar 1 2 3 {}
TogglerBar 1 2 3 4 5 {}
InputField
entrada 566
566
ColorSlider
Para una lista completa, ver la ayuda de Mathematica para el comando Manipulate.
Curso de Mathematica.nb | 85
Control PopupMenu
Si la lista tiene más de cinco elementos:
Manipulate[Plot[Sin[a x] + Sin[b x], {x, 0, 2 Pi}, Filling  sombra, PlotRange  2],
{a, 1, 20}, {b, 1, 20},
{sombra, {None, Axis, Top, Bottom, Automatic, 1, 0.5, 0, -0.5, -1}}]
Out[]=
a
b
sombra Top
1 2 3 4 5 6
-2
-1
1
2
Si tiene menos de cinco genera una botonera para las opciones:
Manipulate[Plot[Sin[a x] + Sin[b x], {x, 0, 2 Pi}, Filling  sombra, PlotRange  2],
{a, 1, 20}, {b, 1, 20}, {sombra, {None, Axis, Top, Bottom}}]
Out[]=
a
b
sombra None Axis Top Bottom
1 2 3 4 5 6
-2
-1
1
2
86 | Curso de Mathematica.nb
Explicitando el tipo de control
Dejando que Mathematica escoja:
In[]:= Manipulate[Plot[f[x], {x, 0, 2 π}], {f, {Sin, Cos, Tan}}]
Out[]=
f Sin Cos Tan
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
Forzando el tipo de presentación de los controles:
In[]:= Manipulate[Plot[f[x], {x, 0, 2 π}], {f, {Sin, Cos, Tan}, ControlType  PopupMenu}]
Out[]=
f Sin
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
Curso de Mathematica.nb | 87
Control CheckBox
Sintaxis de la lista del parámetro: {parámetro, {True, False}}.
Manipulate[Plot[Sin[a x] + Sin[b x], {x, 0, 2 Pi}, Frame  frame, PlotRange  2],
{a, 1, 20}, {b, 1, 20}, {frame, {True, False}}]
Out[]=
a
b
frame
0 1 2 3 4 5 6
-2
-1
0
1
2
Manejando dos parámetros para Checkbox:
Manipulate[Graphics[{c, Disk[]}, Axes  a],
{a, {True, False}, ControlType  Checkbox},
{c, {Red, Blue}, ControlType  Checkbox}]
Out[]=
a
c
-1.0 -0.5 0.5 1.0
-1.0
-0.5
0.5
1.0
88 | Curso de Mathematica.nb
Control RadioButtonBar
In[]:= Manipulate
Sum
1
ni
, {n, 1, ∞},
{i, {2, 4, 6, 8, 10, 12}, ControlType  RadioButtonBar}
Out[]=
i 2 4 6 8 10 12
π6
945
Control ColorSlider
Sintaxis de la lista del parámetro: {parámetro, color}:
In[]:= Manipulate[
Graphics3D[{Opacity[0.6], color, Cone[]}],
{color, Red}
]
Out[]=
color
Curso de Mathematica.nb | 89
Gráfica de cos(t) entre -π y π, incluyendo un comando ColorSlider para editar el color de la línea de
forma dinámica. Crea la etiqueta “Color del Gráfico” y un color inicial LightBlue.
In[]:= Manipulate[
Plot[Cos[t], {t, -π, π}, PlotStyle  {{Thickness[0.02], color}}],
{{color, LightBlue, "Color del Gráfico"}, Red}
]
Out[]=
Color del Gráfico
-3 -2 -1 1 2 3
-1.0
-0.5
0.5
1.0
Control ColorSetter
Incluye ColorSetter para cambiar el color de un gráfico desde una paleta de colores.
In[]:= Manipulate[
Plot[Cos[t], {t, -π, π}, PlotStyle  {Thick, color}],
{color, Red, ControlType  ColorSetter}
]
Out[]=
color
-3 -2 -1 1 2 3
-1.0
-0.5
0.5
1.0
90 | Curso de Mathematica.nb
Control 2DSlider
Sintaxis de la lista del parámetro: {parámetro, {xmin, ymin}, {xmax, ymax}}.
In[]:= Manipulate
Graphics
LineTable{{Cos[t], Sin[t]}, pt}, t,
2 π
30
, 2 π,
2 π
30
, PlotRange  1,
{pt, {-1, -1}, {1, 1}}
Out[]=
pt
Curso de Mathematica.nb | 91
Control Locator
Crea un objeto manipulable con el movimiento del mouse. Su posición es seguida por Mathematica y
esta posición se puede atar a cualquier comando como una pareja ordenada.
Gráfico estático de una línea con extremos en (0, 0) y (1, 1).
In[]:= Graphics[Line[{{0, 0}, {1, 1}}]]
Out[]=
Si uno de los puntos es un Locator, entonces se mueve con el mouse. La sintaxis es: 
{{parámetro, {x, y}}, Locator}
In[]:= Manipulate[
Graphics[Line[{pt, {1, 1}}], PlotRange  3],
{{pt, {0, 0}}, Locator}, ContentSize  {300, 160}]
Out[]=
ContentSize determina el tamaño de la caja de salida.
92 | Curso de Mathematica.nb
Opciones avanzadas
Para finalizar, se dan algunas opciones avanzados de las posibilidades del comando Manipulate,
ejecútelos y observe las diferentes posibilidades que se tienen.
In[]:= Manipulate
Graphics
LineTable{{Cos[t], Sin[t]}, pt}, t,
2 π
12
, 2 π,
2 π
12
, PlotRange  1,
{{pt, {0, 0}}, Locator}
Out[]=
Curso de Mathematica.nb | 93
Creación de un polígono con tres vértices generados por el comando Locator. Haciendo click con el
mouse se logra que el vértice más cercano cambie a la posición actual del mouse.
In[]:= Manipulate[
Graphics[{Pink, Polygon[pts]}, PlotRange  {{-2, 2}, {-0.2, 1.5}}],
{{pts, {{0, 0}, {1, 0}, {0, 1}}}, Locator}, ContentSize  {300, 150}]
Out[]=
Se genera una representación dinámica de un polígono donde se pueden adicionar vértices con la
combinación de teclas +click en Windows y ⌘+click en Mac.
In[]:= Manipulate[
Graphics[{Pink, Polygon[pts]}, PlotRange  {{-2, 2}, {-0.2, 1.5}}],
{{pts, {{0, 0}, {1, 0}, {0, 1}}}, Locator, LocatorAutoCreate  True},
ContentSize  {300, 150}]
Out[]=
94 | Curso de Mathematica.nb
Formateando las salidas
Se puede definir la forma de la salida, aquí algunas opciones :
ManipulateStyleTraditionalFormSum
1
in
, {i, 1, ∞}, "DisplayFormula",
{n, 2, 16, 1}
Out[]=
n
π6
945
ManipulateExpand(α + β)n, {n, 1, 10, 1},
BaseStyle  {Blue, FontFamily  "Times", 20}
Out[]=
n
α4 + 4 α3 β + 6 α2 β2 + 4 α β3 + β4
Manipulate
GridTablei, im, {i, 1, n}, Alignment  {{Left, Right}, Automatic},
Frame  All, ItemStyle  {Blue, FontFamily  "Helvetica"},
Background  LightGray, {n, 1, 20, 1}, {m, 1, 100, 1}
Out[]=
n
m
1 1
2 65536
3 43046721
Curso de Mathematica.nb | 95
Controlando el tamaño del área del gráfico
A veces el tamaño de la salida de Manipulate cambia de forma dinámica con los controles, lo cual
puede ser molesto.
In[]:= ManipulateExpand(α + β)n, {n, 1, 20, 1}
Out[]=
n
α
6
+ 6 α5 β + 15 α4 β2 + 20 α3 β3 + 15 α2 β4 + 6 α β5 + β6
Con el comando ContentSize se puede elegir el tamaño destinado a la salida:
In[]:= ManipulateExpand(α + β)n, {n, 1, 40, 1}, ContentSize  {400, 200}
Out[]=
n
α
11
+ 11 α10 β + 55 α9 β2 + 165 α8 β3 + 330 α7 β4 + 462 α6 β5 +
462 α5 β6 + 330 α4 β7 + 165 α3 β8 + 55 α2 β9 + 11 α β10 + β11
96 | Curso de Mathematica.nb
Ejercicios
1. Dada la gráfica:
In[]:= Plot[Sin[x], {x, 0, 2 π}]
Out[]=
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
Cambiar su estilo manipulando: grosor, punteado y color.
2. Hacer un manipulate que comience con un plano cartesiano vacío y al avanzar un Slider se vaya
dibujando la función seno.
3. Dada la gráfica:
In[]:= Plot[Sin[x], {x, 0, 2 π}]
Out[]=
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
Hacer que un punto se mueva sobre ella.
4. Construir un Manipulate que genere una a una las letras de la palabra murciélago al ir deslizando un
slider.
5. Construir un Manipulate que represente la traslación de una función.
6. Consultar la página demonstrations.wolfram.com buscar un aplicativo de su interés, descargarlo y
estudiar su código.
a. Traducir las etiquetas que aparecen.
b. Cambiar colores.
c. Agregar o quitar opciones de los parámetros.