Transmitiendo a través de arreglos en Julia

Julia es un lenguaje de programación dinámico de alto rendimiento que tiene una sintaxis de alto nivel. Es gratis para que todos lo usen y fácil de aprender. Julia se usa generalmente para fines de análisis y visualización de datos.

Una cuadrícula que contiene objetos en varias dimensiones se denomina array multidimensional. Puede contener cualquier tipo de objeto, pero para la mayoría de los fines computacionales o de tipo deben estar presentes. Es comparativamente más fácil implementar Arrays en Julia que otros lenguajes computacionales. Las arrays se pueden escribir en el código de una manera comprensible y el compilador se encarga de la implementación que es eficiente en términos de rendimiento y tiempo. En Julia, también se puede definir un tipo de array personalizado al heredar de .

Difusión a través de arreglos

A veces es muy útil aplicar operaciones solo en algunos elementos de una array, como agregar un vector de dos elementos a la array. Pero puede ser ineficiente si se hace aumentando el tamaño del vector al tamaño del arreglo, especialmente para arreglos con una gran cantidad de elementos y más dimensiones. 

# Creating two arrays with random elements
a = rand(2, 1);
b = rand(2, 4);
 
# Repeat function repeats the elements,
# specified number of times.
# Adding vector 'a' to 'b' by increasing the size of 'a'
repeat(a, 1, 4) + b

Producción: 

Para abordar este problema, Julia proporciona la función que aumenta el tamaño de una array de dimensión única a la array en la que queremos operar y aplica la función que proporcionamos, sin usar memoria adicional. Por lo tanto, para arreglos grandes, la memoria no se desperdicia. La función es válida no solo para arreglos sino también para otras estructuras.

Los argumentos que podemos pasar en la función son los siguientes:

1. Operador/función
2. Array a agregar
3. Array que se agregará

Aplicando la función en una array 1D: 

# Creating two 1D arrays of different sizes
A = [1];
B = [5,6,7,8];
 
# Adding 'A' to 'B' by increasing it's size
# We use the addition operator in the broadcast function
broadcast(+, A, B)

Aplicando la función en una array 2D:

# Applying the broadcast function
# to perform addition on a 2D array
A = [1 2];  
B = [5 6; 7 8; 9 10; 11 12]; 
broadcast(+, A, B)

Aplicando la función en una array 3D:

# Applying the broadcast function
# to perform addition on a 3D array
A = [2 3]; 
B = cat([4 5;6 7], [8 9;10 11],
                   [12 13;14 15], dims = 3);  
broadcast(+, A, B)

Usando el operador de punto

Podemos usar el operador punto (.+, .-, .*, .=) para implementar las mismas operaciones que hicimos con la función

Usando el operador punto en una array 1D:

# Equating all elements of the 1D array to the element '7'
[1, 2, 3, 4].= [7]

Usando el operador punto en una array 2D:

# Implementing addition, multiplication and
# subtraction operations to broadcast to a 2D array
[1,2].+[1 2 3; 4 5 6]  
[1,2].*[1 2 3; 4 5 6]  
[1,2].-[1 2 3; 4 5 6]

Usando el operador de punto en una array 3D:

# Implementing addition operator to broadcast to a 3D array
cat([4 5; 6 7] , [8 9; 10 11] , [12 13; 14 15] , dims = 3).+[1, 2]

Julia nos proporciona muchas funciones que pueden transmitir en arreglos, aplicando varias operaciones. Y podemos implementar estas funciones usando el operador punto como se muestra a continuación.

# Broadcasting to create strings with additional elements to a 1D array
string.(1:3, ".", ["ONE", "TWO", "THREE"])

# Broadcasting to convert elements
# of a 2D array to the type Float32
convert.(Float32, [1 2 3; 4 5 6])

#  Broadcasting to calculate ceiling
# of the decimal elements in a 3D array
ceil.((UInt8,), cat([4 5; 6 7] ,
                    [8 9; 10 11] ,
                    [12 13; 14 15] , dims = 3))