VARIABLES Y FUNCIONES

Las variables comienzan con letras y también pueden contener números:
(Es mejor comenzar con letras en minúsculas, reservando las mayúsculas para objetos incorporados)

a1/2

Un espacio entre dos variables o números indica multiplicación:
(En otras palabras, “a b” es igual a a por b, mientras que “ab” corresponde a la variable ab)

a b+5 x x

Use /. y -> para realizar sustituciones en una expresión:
(La “regla” -> puede ser escrita como ->)

1+2 x/. x->2

Clear[x]

También podemos hacerlo:

f[x_]:=1+2x;
f[2]

ÁLGEBRA

Puedes factorizar o expandir expresiones algebraicas:
(Utiliza CTRL+6 para exponentes de composición tipográfica.)

Factor[x^2+2 x+1]

Wolfram Language utiliza == (dos signos de igual) para probar equidad:

2+2==4

Los comandos como Solve encuentran soluciones exactas a ecuaciones:

Solve[x^2+5 x-6==0,x]

Para resultados aproximados, usa NSolve:

NSolve[7 x^2+3 x-5==0,x]

Pasa un sistema de ecuaciones como una lista:

Solve[{x^2+5==y,7 x-5==y},{x,y}]

Encuentra las raíces de una ecuación:
(|| es el símbolo para Or.)

Roots[x^2+3 x-4==0,x]

Si un polinomio no es fácilmente factorizable, los resultados aproximados pueden ser más útiles:

NRoots[360+234 x-1051 x^2+11 x^3+304 x^4-20 x^5==0,x]

El comando Reduce reduce un conjunto de desigualdades a una forma simple:
(Escribe <= para el símbolo ≤.)

Reduce[{0<x<2,1<=x<=4},x]

La forma reducida puede incluir múltiples intervalos:

Reduce[(x-1) (x-2) (x-3) (x-4)>0,x]

NumberLinePlot es una forma útil de visualizar estos resultados:

NumberLinePlot[x<1||2<x<3||x>4,{x,-10,10}]

GRÁFICOS EN 2D

Genera un gráfico en 2D de una función de polinomio:
(La notación de intervalo de {x,min,max} define el dominio.)

Plot[x^2+2 x+1,{x,-10,10}]

O representa gráficamente una región en 2D para un conjunto de desigualdades:
(&& es el símbolo para And.)

RegionPlot[Reduce[{x^2+y<2&&x+y<1}],{x,-3,3},{y,-3,3}]

Existen muchas opciones muy útiles para personalizar las visualizaciones, tales como agregar leyendas:

Plot[{x^3,x^2,x},{x,-2,2},PlotLegends->"Expressions"]

O rellenar un gráfico para visualizar el área bajo una curva:

Plot[1/x,{x,-3,3},Filling->Axis]

Combina distintos tipos de representaciones gráficas con Show:

Show[{Plot[x^2+2,{x,-3,3}],RegionPlot[2 x>y-3,{x,-3,3},{y,0,9}]}]

TRIGONOMETRÍA

Para funciones trigonométricas básicas, usa abreviaturas estándar (con la primera letra mayúscula):

Sin[x]/Cos[x]==Tan[x]

Agrega “Arc” para la función inversa:

ArcTan[1]

Usa Pi cuando trabajes con expresiones de radianes:
(Escribe ESCpiESC para el carácter π.)

Sin[π/2]

O escribe ESCdegESC para el símbolo incorporado de grado:

Sin[90 °]

Automáticamente expande (o reduce) expresiones trigonométricas usando identidades:

TrigExpand[Sin[2 x]]

Factoriza polinomios trigonométricos:

TrigFactor[Cos[x]^2-Sin[x]^2]

Resuelve ecuaciones trigonométricas:

Solve[Cos[x]^2+Sin[x]^2==x]

Especifica un dominio para soluciones:

Solve[{Tan[x]==1,0<x<2 Pi}]

COORDENADAS POLARES

Crea un gráfico polar en 2D:
(Escribe ESCthESC para el símbolo θ.)

PolarPlot[Sin[2 θ]+Cos[2 θ],{θ,0,2 Pi}]

Muestra los ejes polares:

PolarPlot[Sin[2 θ]+Cos[2 θ],{θ,0,2 Pi},PolarAxes->Automatic,PolarTicks->{0 °,90 °,180 °,270 °}]

Convierte coordenadas cartesianas a polares:

ToPolarCoordinates[{1,1}]

EXPONENCIALES Y LOGARITMOS

El logaritmo natural (neperiano) de una expresión:

N[Log[2]]

Sería lo mismo si lo escribimos:

N[Log[E,2]]

Log[(E^2)]

El logaritmo decimal de un número:

N[Log[10,2]]

El logaritmo en base 2 de un número:

N[Log[2,64]]

Crea representaciones gráficas en una escala logarítmica:

LogPlot[E^x,{x,1,5}]

En una escala doblemente logarítmica:

LogLogPlot[x^2+x^3,{x,1,100}]

LÍMITES

Calculamos el límite de una expresión, cuando la variable tiende a un número:

Limit[(x^3-1)/(x-1),x->1]

Calculamos el límite de una expresión, cuando la variable tiende a infinito:

Limit[(2 x^3-1)/(5 x^3+x-1),x->∞]

Podemos calcular límites laterales de la función 1/x. En primer lugar la representamos:

Plot[1/x,{x,-10,10}]

Los límites laterales son:

Limit[1/x,x->0,Direction->1]

Limit[1/x,x->0,Direction->-1]

Usamos la expresión TraditionalForm para escribir una expresión matemática sin calcular:

TraditionalForm[HoldForm[Limit[1/x,x->Infinity]]]

DERIVADAS

Calculamos las derivadas de la siguiente forma:

D[(x^6),x]

Podemos utilizar la notación de primas:

Sin'[x]

Podemos derivar una función creada por el usuario:

f[x_]:=(x^2)+2x+1;

f'[x]

Podemos representar gráficamente una función y su derivada:

Plot[{f[x],f'[x]},{x,-3,3}]

Podemos calcular múltiples derivadas:

D[(x^6),{x,3}]

Y también lo podemos hacer:

Sin''[x]

INTEGRALES

Podemos calcular la integral de una función como:

Integrate[8(x^4),x]

O también, escriba ESC intt ESC:

∫8(x^4)\[DifferentialD]x

Si queremos una aproximación numérica, debemos utilizar NIntegrate:

NIntegrate[x^3 Sin[x]+2 Log[3 x]^2,{x,0,Pi}]

SECUENCIAS, SUMAS Y SERIES

Las secuencias de números se representan mediante listas:

Table[(x^2),{x,1,10}]

Podemos utilizar secuencias ya incorporadas:

Table[Fibonacci[x],{x,1,9}]

Podemos definir secuencias recurrentes usando RecurrenceTable. Por ejemplo, calcula los 8 primeros términos de la sucesión (Subscript[a, n ])=2 (Subscript[a, n-1]) , (Subscript[a, 1]) = 1

RecurrenceTable[{a[n]==2 a[n-1],a[1]==1},a,{n,1,8}]

Si queremos calcular la suma total de los términos:

Total[%]

Si queremos calcular una secuencia a partir de una fórmula generadora:

Sum[i(i+1),{i,1,10}]

Esto mismo, lo podemos escribir, ESC sumt ESC:

(∑_(i=1)^10)i(i+1)

Podemos realizar sumas indefinidas y múltiples:

(∑_(i=1)^n)(∑_(j=1)^n)ij

Podemos generar aproximaciones por series de potencias:

Series[Exp[(x^2)],{x,0,8}]

Donde ((O[x])^9) representa términos de orden superior que han sido omitidos. Podemos eliminar ese término:

Normal[%]

Un ejemplo de una serie convergente:

(∑_(n=0)^∞)(0.5^n)

GRÁFICOS EN DOS DIMENSIONES

Usa ParametricPlot para representar gráficamente un conjunto de ecuaciones paramétricas:

ParametricPlot[{2 Cos[t]-Cos[2 t],2 Sin[t]-Sin[2 t]},{t,0,2 Pi}]

Creamos un ContourPlot de una función en múltiples variables:

ContourPlot[Sqrt[x^2+y^2],{x,-1,1},{y,-1,1}]

Para la versión contínua usar DensityPlot:

DensityPlot[Sqrt[x^2+y^2],{x,-1,1},{y,-1,1}]

GRÁFICOS EN TRES DIMENSIONES

Plot3D representará una curva o superficie cartesiana en 3D:

Plot3D[x^2-y^2,{x,-3,3},{y,-3,3}]

Usa ParametricPlot3D para representar una curva en el espacio 3D:

ParametricPlot3D[{Sin[u],Cos[u],u/10},{u,0,20}]

Si queremos la representación  en coordenadas esféricas usa SphericalPlot3D:

SphericalPlot3D[Sin[θ],{θ,0,Pi},{ϕ,0,2 Pi}]

RevolutionPlot3D construye la superficie formada girando una expresión sobre un eje:

RevolutionPlot3D[x^4-x^2,{x,-1,1}]

CÁLCULO MULTIVARIABLE

D funciona para derivadas parciales, simplemente especifica las variables a diferenciar:

D[(x^3) z+2 (y^2) x+y (z^3),y,z]

Podemos usar el símbolo  (∂_□)□.  (Escribe ESC pd ESC para ∂ y CTRL+- para el subíndice.):

(∂_(x,y))((x^2)-2x y+x y z)

Las integrales múltiples usan la misma notación que las integrales simples.  
(Escribe ESC int ESC para ∫ y ESC dd ESC para d.)

∫∫∫((x^2)+(y^2)+(z^2))\[DifferentialD]x\[DifferentialD]y\[DifferentialD]z

Los resultados simbólicos, a menudo, suelen ser complicados:

(∫_(-1)^1)(∫_(-2)^x)(x Sin[(y^2)]+y Cos[(x^2)])\[DifferentialD]y\[DifferentialD]x

Cuando sucede esto, siempre se puede obtener una salida aproximada, utilizando el comando N:

N[%,5]

ANÁLISIS Y VISUALIZACIÓN DE VECTORES

En Wolfram los vectores se representan por medio de listas de longitud n.

Por ejemplo, calcula el producto escalar de dos vectores:

{1,2,3}.{a,b,c}

Otra forma de escribir el producto escalar, sería:

Dot[{1,2,3},{a,b,c}]

Si queremos calcular el producto vectorial de los vectores:
(Escribe ESC cross ESC para el símbolo del producto vectorial)

{1,2,c}\[Cross]{a,b,c}

Otra forma de escribir el producto vectorial, sería:

Cross[{1,2,3},{a,b,c}]

Si queremos calcular el módulo (norma) de un vector:

Norm[{1,1,1}]

Si queremos calcular la proyección de un vector en el eje x:

Projection[{8,6,7},{1,0,0}]

Podemos encontrar el ángulo formado por dos vectores:

VectorAngle[{1,0},{0,1}]

Si queremos calcular el gradiente de un vector:
(Para el símbolo ∇, usa ESC grad ESC.)

(Subscript[∇, {x,y}]){(x^2)+y,x+(y^2)}

Si lo que queremos es computar la divergencia o rotacional de un campo vectorial:

Div[{f[x,y,z],g[x,y,z],h[x,y,z]},{x,y,z}]

Wolfram Language posee funciones para 2D y 3D adecuadas para la visualización de campos vectoriales:

VectorPlot[{y,-x},{x,-3,3},{y,-3,3}]

VectorPlot3D[{y,-x,z},{x,-3,3},{y,-3,3},{z,-3,3}]

Representa gráficamente un campo vectorial sobre una superficie de corte:

SliceVectorPlot3D[{y,-x,z},"CenterPlanes",{x,-2,2},{y,-2,2},{z,-2,2}]

ECUACIONES DIFERENCIALES

DSolveValue toma una ecuación diferenciaL y regresa una solución general:
(C[1] representa una constante de integración.)

sol=DSolveValue[y'[x]+y[x]==x,y[x],x]

Usa /. para remplazar la constante:

sol/. C[1]->1

O agrega condiciones para una solución específica:

DSolveValue[{y'[x]+y[x]==x,y[0]==-1},y[x],x]

NDSolveValue encuentra soluciones numéricas:

NDSolveValue[{y'[x]==Cos[x^2],y[0]==0},y[x],{x,-5,5}]

Puedes representar gráficamente esta función InterpolatingFunction directamente:

Plot[%,{x,-5,5}]

Para resolver sistemas de ecuaciones diferenciales, incluye todas las ecuaciones y sus condiciones en una lista:
(Nota que los saltos de línea no tienen efecto.)

{xsol,ysol}=NDSolveValue[{x'[t]==-y[t]-x[t]^2,
                                                       y'[t]==2 x[t]-y[t]^3,
                                                       x[0]==y[0]==1},
                                                         {x,y},{t,20}]

Visualiza la solución como una representación gráfica paramétrica:

ParametricPlot[{xsol[t],ysol[t]},{t,0,20}]

ANÁLISIS COMPLEJO

La unidad imaginaria (Sqrt[-1]) se representa como I:

(I^2)

La mayoría de las operaciones manejan números complejos de forma automática:

(1+I) (2-3 I)

Expande expresiones complejas:

ComplexExpand[Sin[x+I y]]

Convierte las expresiones entre formas exponenciales y trigonométricas:

ExpToTrig[(E^((I x)))]

TrigToExp[%]

Escribe ESCcoESC para el símbolo del conjugado:

(3+2I)\[Conjugate]

Extrae las partes reales e imaginarias de una expresión:

ReIm[3+2 I]

O encuentra el valor absoluto y el argumento:

AbsArg[(1+I)]

Representamos una función compleja de forma paramétrica:

ParametricPlot[ReIm[E^(I ω)],{ω,0,2 π}]

Usamos AbsArg en un PolarPlot:

PolarPlot[AbsArg[E^(I ω)],{ω,0,π}]

Visualizamos componentes complejos con un DensityPlot:

DensityPlot[Im[ArcSin[(x+I y)^2]],{x,-2,2},{y,-2,2}]

MATRICES Y ALGEBRA LINEAL

Wolfram Language representa matrices como listas de listas:

MatrixForm[{{1,2},{3,4}}]

Puedes construir una matriz con funciones iterativas:

MatrixForm[Table[x+y,{x,1,3},{y,0,2}]]

Puedes importar datos que representan una matriz:

MatrixForm[Import["/Users/msm/Documents/Ciencia/Mathematica/Aprendizaje/Matemáticas/Aprendizaje/Recordatorios/data.csv"]]

Las operaciones de matriz estándar funcionan con base en elementos:

{1,2,3} {a,b,c}

Computa el producto escalar de dos matrices:

{{1,2},{3,4}}.{{a,b},{c,d}}

Otra forma de escribirlo:

Dot[{{1,2},{3,4}}.{{a,b},{c,d}}]

Si queremos calcular el determinante:

Det[{{a,b},{c,d}}]

Si queremos calcular la matriz inversa:

Inverse[{{1,1},{0,1}}]

Use LinearSolve para resolver un sistema lineal:

LinearSolve[{{1,1},{0,1}},{x,y}]

MATEMÁTICAS DISCRETAS

Realiza operaciones básicas de teoría de números tales como la factorización:

FactorInteger[30]

Encuentra el GCD (máximo común divisor) y el LCM (mínimo común múltiplo) de dos números enteros cualquiera:

GCD[24,60]

LCM[24,60]

Muestra el cuarto número primo:

Prime[4]

Prueba si el número es primo:

PrimeQ[%]

Table[Prime[n],{n,1,100}]

Si queremos calcular el resto de una división:

Mod[17,5]

Obtener las permutaciones posibles de una lista:

Permutations[{a,b,c}]

Genera un Graph a partir de una lista de bordes:
(Usa ESCueESC para un UndirectedEdge o ESCdeESC para un DirectedEdge.)

Graph[{1<->2,2\[DirectedEdge]3,3\[DirectedEdge]4,4<->1,3\[DirectedEdge]1,2\[DirectedEdge]2},VertexLabels->All]

Encuentra la ruta más corta entre dos vértices:

FindShortestPath[%,3,2]

PROBABILIDAD

Calcula factoriales usando la notación:

5!

Para combinaciones, usa Binomial:

Binomial[4,3]

Computa probabilidades para una distribución binomial:
(Escribe ESCdistESC para el símbolo \[Distributed].)

Probability[x==1,x\[Distributed]BinomialDistribution[1,1/2]]

Calcula la expectación de una expresión polinómica:

Expectation[2 x+3,x\[Distributed]NormalDistribution[]]

Obtén el PDF de una distribución normal en forma simbólica:

PDF[NormalDistribution[0,1],x]

Crea una representación del resultado:

Plot[%,{x,-5,5},Filling->Axis]

ESTADÍSTICA

Computa la media de una lista de números:

Mean[{1,2,4,5}]

Encuentra la correlación de múltiples listas:

Correlation[{1,3,5},{6,4,2}]

Encuentra la desviación estándar de una distribución de Poisson:

StandardDeviation[PoissonDistribution[2]]

Calcula el momento de una lista de símbolos:

Moment[{x,y,z},2]

Obtén la función generadora del momento de una distribución:
(Escribe ESCmESC para μ y ESCsESC para σ.)

MomentGeneratingFunction[NormalDistribution[μ,σ],t]

Genera datos estadísticos con RandomVariate:
(Usa //Short para obtener un resumen breve de la salida.)

RandomVariate[NormalDistribution[0,1],{500,2}]//Short

Visualiza los datos resultantes:

Histogram3D[%]

GRÁFICOS DE DATOS Y CURVAS DE MEJOR AJUSTE

Usa ListPlot para visualizar los datos en un gráfico de dispersión:

ListPlot[{1,3,4,7,9,15}]

O también podemos representarlos como un diagrama de barras:

BarChart[{1,3,4,7,9,15}]

Múltiples conjuntos de datos son coloreados de forma distinta automáticamente:

ListLinePlot[{{1,2,3,4,5},{1,3,7,10,17}}]

Encuentra una curva de mejor ajuste con el comando Fit:
({1,x,x2} significa ajuste cuadrático sobre x.)

Fit[{2,3,5,7,11,13},{1,x,x^2},x]

Usa Show para comparar la curva con sus puntos de datos:

Show[{Plot[%,{x,1,6}],ListPlot[{2,3,5,7,11,13}]}]

TEORIA DE GRUPOS

Obtén una lista de elementos de grupo:

GroupElements[SymmetricGroup[2]]

Determina los generadores de un grupo:

GroupGenerators[SymmetricGroup[3]]

Crea un grupo de permutación a partir de los generadores:

PermutationGroup[{Cycles[{{3,1,2}}],Cycles[{{2,5,6}}]}]

Computa su orden:

GroupOrder[%]

Muestra la tabla de multiplicación para un grupo:

TableForm[GroupMultiplicationTable[DihedralGroup[2]],TableHeadings->Automatic]

Visualízalo como un grafo de Cayley:

CayleyGraph[DihedralGroup[2]]

MODELOS INTERACTIVOS

El comando Manipulate te permite explorar de forma interactiva lo que sucede cuando varias los parámetros en tiempo real:

Manipulate[Plot[Sin[f x],{x,-3,3},Filling->Axis],{f,1,5}]

Un sólo comando Manipulate puede tener múltiples controladores, y Wolfram Language, selecciona automáticamente la mejor presentación de esos controladores:

Manipulate[Plot[Sin[f*x+p],{x,-3,3},Filling->fill,PlotStyle->color],{f,1,5},{p,3,9},{fill,{Bottom,Top,Axis}},{color,Red}]

Cualquier expresión en Wolfram Language puede ser manipulada, incluyendo las expresiones no gráficas:

Manipulate[Expand[(((a+b))^n)],{n,1,20,1}]

IMPLEMENTACIÓN EN LA NUBE

CloudDeploy implementa objetos en Wolfram Cloud.

Crea una página web que tenga una imagen de un gráfico de onda sinusoidal.

CloudDeploy[Plot[Sin[x],{x,0,50}]]

Podemos desplegar una interfaz dinámica:

CloudDeploy[Manipulate[Plot[Sin[f x],{x,0,2 Pi}],{f,1,10}]]