INTRODUCCION

Se ha observado a menudo que Julia no tiene un comando de gráficos incorporado. Esto significa que
no es posible crear algunos conjuntos de datos y emitir un comando de trazado sin primero instalar y
cargar un paquete.

Una razón para esto es que Julia necesita construir desde una fuente una variedad de sistemas
operativos diferentes y cualquier biblioteca que se envíe, como OpenBLAS y LibUV, debe estar en
forma de fuente y no interferir con el proceso de construcción.

Los motores gráficos tienen una variedad de backends diferentes como Gtk, Qt; y, mientras que los
paquetes especializados pueden estar restringidos en su compatibilidad con SO, es posible que el
sistema general de Julia no lo haga.

Al principio, la inclusión de gráficos integrados se veía como un objetivo a largo plazo y uno que se
agregaría en versiones futuras. Sin embargo, con un énfasis en la compilación del paquete y la carga
rápida, esto no parece tan apremiante como originalmente lo hizo. Volveré sobre este tema al final
de este capítulo.

Un punto adicional para notar es que el método de Julia de importar símbolos a su espacio de nombres
principal mediante el comando using significa que la mayoría de los paquetes gráficos, que tienden
a tener funciones como plot () y display (), no producen un choque de nombre. Por supuesto, es
posible usar importar y calificar completamente cualquier llamada a función. Normalmente
trabajaremos con un solo paquete.

Para abordar el enfoque de Julia sobre los gráficos, clasificaré los enfoques en tres secciones
principales:

• Gráficos básicos
• Motores gráficos
• Gráficos web

La clasificación está lejos de ser perfecta, pero me refiero a los gráficos básicos en los que la mayor
parte del trabajo se realiza en codificación Julia, aunque utilizando llamadas a bibliotecas de bajo
nivel. Los motores gráficos se basan en el soporte de terceros, como Gnuplot o Matplotlib de Python,
y la categoría final utiliza navegadores web y HTML.

Gráficos básicos en Julia

Ya hemos encontrado algunos gráficos en los capítulos anteriores de este libro, tanto gráficos de texto
como gráficos bidimensionales que usan módulos como ASCIIPlots y Winston. En esta sección,
vamos a analizar un poco más estos y otros paquetes similares.

Esto ha sido reemplazado en gran parte con un segundo paquete, el paquete TextPlots. Si bien no
proporciona una visualización sofisticada, vale la pena verla, ya que es muy liviana y se carga
rápidamente, siendo independiente de cualquier biblioteca gráfica o controlador.

La llamada básica usa una función de una sola variable junto con un rango opcional de valores para
esa variable.

El rango se puede especificar en la forma x0: x1 o como argumentos separados (,,,. X0, x1). Si no se
proporciona un rango, se usa un valor predeterminado de -10: 10.

Es posible definir más de una función, pero la pantalla puede ser confusa.

Considere la siguiente sinusoide amortiguada en el rango 0: 3π, que pasamos como una función
anónima:
Julia> using TextPlots
julia> plot(x->x*sin(3x)*exp(-0.3x),0,3pi)
El resultado es el siguiente

CAIRO
Cairo es una biblioteca de gráficos 2D con soporte para múltiples dispositivos de salida.

Este es el siguiente nivel desde los gráficos base, ya que implementa un contexto de dispositivo para el sistema
de visualización y funciona con X Windows (Linux), OS X y Windows. Además, Cairo puede crear archivos de
disco en formatos PostScript, PDF y SVG.

El siguiente es un ejemplo para dibujar una línea (trazo) a través de cuatro puntos:

1. Primero creamos un contexto cr y agregamos un rectángulo de 512x128 con un fondo gris:

using Cairo
c = CairoRGBSurface(512, 128);
cr = CairoContext(c);
save(cr);
set_source_rgb(cr, 0.8, 0.8, 0.8); # rectangulo Gris claro

rectangle(cr, 0.0, 0.0, 512.0, 128.0); # relleno de fondo(cr);

restore(cr);
save(cr);

2. Luego, definimos los puntos y trazamos la línea a través de los puntos:

x0=51.2; y0=64.0;

x1=204.8; y1=115.4;

x2=307.2; y2=12.8;

x3=460.8; y3=64.0;

move_to (cr, x0, y0);

 curve_to (cr, x1, y1, x2, y2, x3, y3);
set_line_width (cr, 10.0);
stroke (cr);
restore(cr);

3. Finalmente, podemos agregar algo de texto y escribir los gráficos resultantes en el disco:
move_to(cr, 12.0, 12.0);
set_source_rgb (cr, 0, 0, 0);
show_text(cr,"Figure 7-2")
write_to_png(c,"fig7-2.png");

Winston
Winston es un paquete 2D y se asemeja a los gráficos integrados disponibles dentro de MATLAB.
El uso típico que ya hemos visto es a través de la función plot ():

using Winston
t = linspace(0,4pi,1000);
f(x::Array) = 10x.*exp(-0.3x).*sin(3x);
g(x::Array) = 0.03x.*(2pi - x).*(4pi - x);
h(x::Array) = 1./(1 + x.^2);
y1 = f(t); y2 = g(t); y3 = h(t)
plot(t,y1,"b--")

Alternativamente, use fplot () y defina la función directamente que produce el mismo gráfico como se
muestra a continuación:

fplot(x->10*x.*exp(-0.3*x).*sin(3*x), [0,4pi],"b—")

Además, hay una función plothist () que puede tomar el resultado de la función histo ().

El siguiente código genera un conjunto de números distribuidos normalmente y muestra el histograma

de frecuencia para 100 intervalos:

a = randn(10000) ha
= hist(a,100)
plothist(ha)
Cuando necesitamos trazar curvas múltiples en un solo gráfico, hemos visto que esto se puede hacer usando una
sola declaración:
plot(t, y1, "r-", t, y2, "b-")
Visualización de datos
La visualización es la presentación de datos en una variedad de formatos gráficos y pictóricos. El lector
estará familiarizado con ejemplos tales como gráficos de sectores y de barras. Las visualizaciones nos
ayudan a ver cosas que no son inmediatamente obvias, incluso cuando los volúmenes de datos son
patrones muy grandes se pueden detectar rápida y fácilmente.

La interactividad es una de las características útiles de las visualizaciones exitosas, que proporciona la
capacidad de ampliar, filtrar, segmentar y ordenar datos.

En esta sección, veremos el paquete Gadfly Julia.

Gadfly
Gadfly es un paquete grande y complejo, y proporciona una gran flexibilidad en el rango y la amplitud
de las visualizaciones posibles en Julia.

El paquete fue escrito por Daniel Jones, y la fuente en GitHub contiene numerosos ejemplos de pantallas
visuales junto con el código que lo acompaña.

La llamada estándar es a la función plot () que crea un gráfico en el dispositivo de visualización a través
de un navegador directamente o bajo el control de IJulia, si eso se está utilizando como un IDE.

Es posible asignar el resultado de plot () a una variable e invocar esto usando display (). De esta forma,
la salida se puede escribir en archivos que incluyen: SVG, SVGJS / D3, PDF y PNG:

A menos que se especifique, el tipo de gráfico producido es un diagrama de dispersión.

La capacidad de trabajar directamente con marcos de datos es especialmente útil.

using Gadfly, RDatasets, DataFrames;

set_default_plot_size(20cm, 12cm);
mlmf = dataset("mlmRev","Gcsemv")
df = mlmf[complete_cases(mlmf), :]

Si deseamos ver los valores de los datos para el examen y los resultados del trabajo del curso y, al
mismo tiempo, diferenciar entre niños y niñas, esto puede mostrarse mediante:

plot(df, x="Course", y="Written", color="Gender")

Compose
Compose es un sistema de gráficos vectoriales declarativos que también es creado por Daniel Jones
como parte del sistema Gadfly, pero que puede usarse por derecho propio.

A diferencia de la mayoría de las bibliotecas de gráficos vectoriales, Compose es completamente

declarativa. Los gráficos se definen usando una estructura de árbol, ensamblando varias primitivas y
luego dejando que el módulo decida cómo dibujarlas.

Las primitivas se pueden clasificar como: contexto, forma y propiedad, y la operación de ensamblaje se
logra mediante la función compose ():

El siguiente código crea tres formas rellenas. El contexto predeterminado tiene un color de relleno azul de
aciano (el valor predeterminado es negro) y los subcontextos definen cuadros de límite y llaman a las funciones
de circle(), rectangle(), y polygon() dentro de esos cuadros.

Los valores posibles para el color de relleno se dan en el módulo Color.jl. Tenga en cuenta que el valor
predeterminado es una forma completa, pero especificar el fill(nothing) producirá una forma no rellena:

shapes = compose(context(), fill("cornflowerblue"),

(context( 0.1, 0.1, 0.15, 0.1 ), circle()),
(context( 0.35, 0.06, 0.2, 0.18 ), rectangle(),
fill("red")),
(context( 0.6, 0.05, 0.2, 0.2), fill("magenta3"),
polygon([(1, 1), (0.3, 1), (0.5, 0)]) ));
img = SVG("shapes.svg", 10cm, 8.66cm)
draw(img,shapes)

Motores gráficos
Los gráficos nativos se construyen desarrollando las tramas en Julia y usando llamadas de contenedor
a bibliotecas como cairo, pango y tk.

En esta sección, consideraremos la creación de gráficos mediante tareas externas (programas) en lugar
de bibliotecas compartidas.

PyPlot
PyPlot es una parte del trabajo de Steven Johnson de MIT, que surgió del desarrollo anterior del módulo
PyCall. Junto con Winston y Gadfly, es la tercera parte del triunvirato gráfico de Julia.

Proporciona una interfaz para la biblioteca de trazado matplotlib de Python y en particular a

matplotlib.pyplot. La API de matplotlib se puede usar como base para fuente de referencia completa
para las diversas llamadas de función: matplotlib.org/api.
Por lo tanto, para utilizar PyPlot, es necesaria la instalación de Python y matplotlib. Si tiene éxito,
funcionará creando una ventana independiente (a través de Python) o incrustándola en un libro de
trabajo de Jupyter.

Como ejemplo, seleccioné uno de la documentación de PyPlot anterior, que era una sinusoide
sinusoidal modulada. El código que fluye crea el código, lo muestra (a través de una ventana nativa de
Python) y también escribe el disco como un archivo SVG:

using PyPlot
x = linspace(0,2pi,1000)
y = sin(3*x + 4*cos(2*x));
plot(x, y, color="red", linewidth=2.0, linestyle="--");
title("A sinusoidally modulated sinusoid");
savefig("sinusoid.svg");

Gaston
Gaston fue escrito por Miguel Bazdresch y es uno de los primeros paquetes de gráficos en Julia. Aunque
prácticamente no ha sido tocado recientemente, sigue siendo un paquete de trazado flexible.

Gaston usa el programa de utilidad gnuplot GNU que se instala fácilmente en Linux y también en OS
X a través de XQuartz. En Windows hay un proyecto de sourceforge, pero usarlo con Gaston es un poco
torpe.

Con el aumento de los gráficos a través de PyPlot, ha caído un poco fuera de favor, pero sin embargo
es interesante cuando se trabaja en Linux y también arquitectónicamente. El paquete emplea un sistema
de mensajería para enviar comandos de Julia a gnuplot, por lo que todas las funciones de este último
están potencialmente disponibles.

Este ejemplo ilustra la capacidad de Gaston para producir gráficos en 3D. Esta es la trama Sombrero
que se crea como una curva de estilo sin (ф) / ф, definida como una función anónima y utilizada en la
rutina meshgrid ().
 using Gaston g = Gaston; set_terminal("x11"); c = g.CurveConf();
c.plotstyle = "pm3d";
x = -15:0.33:15;
y = -15:0.33:15;
Z = g.meshgrid(x, y, (x,y) ->.* y)); g.addcoords(x,y,Z,c); a = g.AxesConf();
a.title = "3D: Sombrero";
g.addconf(a);
g.llplot()

PGF plots

En contraste con Gaston, este es un paquete relativamente nuevo que usa pgfplots LaTeX rutinas para
producir parcelas. Se integra bien con IJulia para mostrar imágenes SVG a el cuaderno.

El usuario proporciona etiquetas de eje, entradas de leyenda y las coordenadas de trazado para uno o
más trazados. PGFPlots aplica la escala del eje, calcula los logaritmos y los tics del eje, y dibuja los
trazados.

La biblioteca TEX admite gráficos de línea, dispersión, barra, área, histograma, malla y superficie, pero
al momento de escribir esto, no todos se han implementado en el paquete Julia.

Al igual que con todos los paquetes de tipo de motor gráfico, algunos ejecutables adicionales deben
estar presentes para que PGFPlots funcione.

Este ejemplo siguiente genera múltiples curvas en el mismo eje y asigna sus entradas de leyenda (en
formato LaTeX):

using PGFPlots;
p = Axis( [ Plots.Linear(x->sin(3x)*exp(-0.3x), (0,8),
legendentry = L"$\sin(3x)*exp(-0.3x)$"),
Plots.Linear(x->sqrt(x)/(1+x^2), (0,8),
legendentry = L"$\sqrt{2x}/(1+x^2)$") ]);
save("linear-plots.svg", p);
Usando la Web
Todos los sistemas operativos pueden mostrar páginas web y estándares modernos de HTML5 y CSS3,
incluidas las capacidades de dibujo. La adición de bibliotecas del lado del cliente de JavaScript, como
jQuery y D3, proporciona medios sencillos para agregar funcionalidad interactiva y de arrastrar y soltar.

Estos están disponibles hasta cierto punto en el paquete Gadfly. Esto se clasificó como un paquete
nativo a pesar de que requirió bibliotecas adicionales como cairo, pango y tk, ya que se accedió a ellas
mediante funciones de envoltura utilizando ccall ().

En esta sección, exploraremos un par de enfoques que usan gráficos HTML directamente. La primera
se ejecuta en la estación de trabajo y la otra es un enfoque diferente usando un sistema en línea.

Bokeh
Bokeh es una biblioteca de visualización interactiva de Python que utiliza navegadores web para la
presentación.

El paquete Julia está escrito en código nativo. Es independiente del módulo original de Python, pero
funciona de la misma manera. La operación básica consiste en crear código HTML y escribirlo en el
disco. Esto luego se pasa al navegador (predeterminado).

La implementación actual es relativamente escasa en comparación con la implementación de Python,

pero todavía es muy capaz de producir gráficos de líneas básicos.

Todos los valores de los parámetros se predeterminan usando el parámetro global, pero el paquete
incluye un conjunto de rutinas para cambiarlos.

La salida HTML se envía a un archivo bokeh_plot.html (temporal) que serásobrescrito utilizando la

función plotfile ().

Bokeh también funcionará bien con los portátiles IJulia. En este caso, es necesario llamar a la función
setupnotebook () que escribe una hoja de estilo CSS y un conjunto de rutinas JavaScript en el archivo.

El siguiente código crea un gráfico de las dos funciones de prueba que definimos cuando considerando
el paquete PGFPlots y esto se ejecuta bajo IJulia:
using Bokeh
setupnotebook()
x = linspace(0,3pi)
f1(x) = sin(3x).*exp(-0.3x)

f2(x) = sqrt(x)./(1 + x.^2)

 y = [f1(x) f2(x)]
title("Two test functions")
plot(x, y, "r;|b--")

Plotly
Plotly es una aplicación web de análisis de datos y gráficos capaz de crear gráficos precisos y hermosos.
Se basa en D3 y, como tal, incorpora un alto grado de interacción, como texto desplegable, panorámica
y controles de zoom, así como en tiempo real
opciones de transmisión de datos.

Originalmente, el acceso a Plotly era a través de una API REST para el sitio web http://plot.ly pero una
variedad de lenguajes de programación ahora pueden acceder a la API, incluida Julia.