Aprende X en Y minutos

(* Esto es un comentario *)

(* En Mathematica en lugar de utilizar estos comentarios, puede crear una celda de texto
   Y anotar su código con texto e imágenes bien escritas *)

(* Escribe una expresión devuelve el resultado *)
2*2              (* 4 *)
5+8              (* 13 *)

(* Llamada de función *)
(* Nota, los nombres de funciones (y todo lo demás) distingue entre mayúsculas y minúsculas *)
Sin[Pi/2]        (* 1 *)

(* Sintaxis alternativa para la Llamada de una función con un parámetro *)
Sin@(Pi/2)       (* 1 *)
(Pi/2) // Sin    (* 1 *)

(* Cada sintaxis en WL tiene algún equivalente como una llamada de función *)
Veces[2, 2]      (* 4 *)
Mas[5, 8]       (* 13 *)

(* El uso de una variable por primera vez lo define y lo hace global *)
x = 5             (* 5 *)
x == 5            (* verdadero, Estilo-C asignación y pruebas de igualdad *)
x                 (* 5 *)
x = x + 5         (* 10 *)
x                 (* 10 *)
Modifique[x, 20]  (* No estaba bromeando cuando dije que TODO tiene una función equivalente *)
x                 (* 20 *)

(* Debido a que WL se basa en un sistema de álgebra computacional, *)
(* El uso de variables indefinidas está bien, simplemente obstruyen la evaluación *)
cow + 5          (* 5 + cow, cow es indefinido por lo que no puede evaluar más *)
cow + 5 + 10     (* 15 + cow, Va a evaluar lo que puede *)
%                (* 15 + cow, % Busca el último retorno *)
% - cow          (* 15, cow variable indefinida cancelada *)
moo = cow + 5    (* Cuidado, moo ahora tiene una expresión, no un número! *)

(* Definición de una función *)
Double[x_] := x * 2    (* Nota: = para evitar la evaluación inmediata del RHS
                          y después de x para indicar que no hay restricciones de concordancia de patrones *)
Double[10]             (* 20 *)
Double[Sin[Pi/2]]      (* 2 *)
Double @ Sin @ (Pi/2)  (* 2, @-Sintaxis evita colas de paréntesis *)
(Pi/2) // Sin // Double(* 2, //-Sintaxis lista las funciones en orden de ejecución *)

(* Para un uso de programación de estilo imperativo; Para separar declaraciones *)
(* Descarta cualquier salida de LHS y ejecuta RHS *)
miPrimero[] := (Print@"Hola"; Print@"Mundo")  (* Tenga en cuenta que los padres externos son críticos
                                                ; La precedencia es menor que := *)
miPrimero[]                                    (* Hola Mundo *)

(* Estilo-C para bucle *)
PrintTo[x_] := For[y=0, y<x, y++, (Print[y])]  (* Start, test, incr, body *)
PrintTo[5]                                     (* 0 1 2 3 4 *)

(* bucle *)
x = 0; While[x < 2, (Print@x; x++)]     (* Ciclo con prueba y cuerpo *)

(* Si y condicionales *)
x = 8; If[x==8, Print@"Yes", Print@"No"]   (* Condición, Caso verdadero, Caso distinto*)
Switch[x, 2, Print@"Two", 8, Print@"Yes"]  (* Interruptor de estilo de coincidencia de valor *)
Which[x==2, Print@"No", x==8, Print@"Yes"] (* estilo de caso distinto *)

(* Las variables distintas de los parámetros son globales por defecto, incluso dentro de las funciones *)
y = 10             (* 10, Variable global y *)
PrintTo[5]         (* 0 1 2 3 4 *)
y                  (* 5, Global por contador de bucle dentro de PrintTo *)
x = 20             (* 20, Variable global x *)
PrintTo[5]         (* 0 1 2 3 4 *)
x                  (* 20, x en PrintTo Es un parámetro y automáticamente local *)

(* Las variables locales se declaran utilizando la metafunción del módulo *)
(* Version con variable local*)
BetterPrintTo[x_] := Module[{y}, (For[y=0, y<x, y++, (Print@y)])]
y = 20             (* Variable global y *)
BetterPrintTo[5]   (* 0 1 2 3 4 *)
y                  (* 20, eso es mejor *)

(* El módulo realmente nos permite declarar cualquier ámbito que nos guste *)
Module[{count}, count=0;        (* Declare el alcance de este recuento de variables *)
  (IncCount[] := ++count);      (* Estas funciones están dentro de ese ámbito *)
  (DecCount[] := --count)]
count              (* count - Variable global count no esta definida *)
IncCount[]         (* 1, usando count variable dentro del alcance *)
IncCount[]         (* 2, incCount lo actualiza *)
DecCount[]         (* 1, decCount tambien lo hace *)
count              (* count - Aún ninguna variable global con ese nombre*)

(* listas *)
miLista = {1, 2, 3, 4}     (* {1, 2, 3, 4} *)
miLista[[1]]               (* 1 - Los índices de la lista de notas comienzan en 1, no 0 *)
Map[Double, miLista]       (* {2, 4, 6, 8} - Lista de estilo funcional mapa función *)
Double /@ miLista          (* {2, 4, 6, 8} - Sintaxis abreviada para arriba *)
Scan[Print, miLista]       (* 1 2 3 4 - Lista de bucle sobre estilo imperativo *)
Fold[Plus, 0, miLista]     (* 10 (0+1+2+3+4) *)
FoldList[Plus, 0, miLista] (* {0, 1, 3, 6, 10} - Guardar los resultados intermedios *)
Append[miLista, 5]         (* {1, 2, 3, 4, 5} - Note que miLista no está actualizada *)
Prepend[miLista, 5]        (* {5, 1, 2, 3, 4} - añada "miLista = " Si quieres que lo sea *)
Join[miLista, {3, 4}]      (* {1, 2, 3, 4, 3, 4} *)
miLista[[2]] = 5          (* {1, 5, 3, 4} - Esto actualiza miLista *)

(* Asociaciones, aka Diccionarios /Hashes *)
miHash = <|"Green" -> 2, "Red" -> 1|>   (* crea una asociación *)
miHash[["Green"]]                       (* 2, uselo *)
miHash[["Green"]] := 5                  (* 5, actualizalo *)
miHash[["Puce"]] := 3.5                 (* 3.5, extiendalo *)
KeyDropFrom[miHash, "Verde"]            (* Limpia la llave Verde *)
Claves[miHash]                            (* {Rojo} *)
Valores[miHash]                          (* {1} *)

(* Y no puedes hacer ninguna demo de Wolfram sin mostrar esto *)
Manipular[y^2, {y, 0, 20}] (* Devuelve una interfaz de usuario reactiva que muestra y ^ 2
                               Y permite ajustar y entre 0-20 con un deslizador.
                               Sólo funciona en interfaces gráficas *)