Na lição anterior vimos como criar arrays de até três dimensões em Python usando a biblioteca NumPy. Vimos também como atribuir valores a um array no momento de sua criação.

É possível preencher um array de outras formas, por exemplo com valores específicos ou repetidos, o que pode ser útil em determinadas circunstâncias ou em cálculos especiais, por exemplo, em álgebra linear.

O método mais usual de preenchimento de um array em NumPy consiste em passar valores a partir de uma lista ao criar o array, como vimos na aula anterior. Porém, podemos preencher arrays específicos de outras formas também.

Algumas das formas especiais de preenchimento de arrays incluem:

• Preenchimento com zeros
• Preenchimento com uns
• Preenchimento com outro valor numérico repetido
• Preenchimento a partir de uma faixa de valores
• Preenchimento com números gerados aleatoriamente

Vamos estudar cada uma dessas técnicas a partir de agora.

Preencher array com valores específicos

Com os métodos zeros, ones e full podemos criar arrays preenchidos automaticamente com zeros, uns ou com um valor numérico específico, respectivamente.

Os métodos zeros e ones produzem valores do tipo float64 por padrão, mas podemos alterar o tipo de dado se for necessário.

Vejamos alguns exemplos desses métodos.

# Criar array com 10 elementos iguais a 0
print(np.zeros(10))

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

# Criar array com 15 elementos iguais a 1
print(np.ones(15))

[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

# Criar array com 8 elementos iguais a 12 (int).
# O primeiro argumento corresponde ao número de elementos desejados.
print(np.full(8,12)) 

[12 12 12 12 12 12 12 12]

# Criar array com 10 elementos iguais a 0, do tipo inteiro
print(np.zeros(10, dtype=int))

# Criar array com 15 elementos iguais a 1, do tipo inteiro
print(np.ones(15, dtype=int))

# Criar array com 8 elementos iguais a 12, do tipo ponto flutuante
print(np.full(8,12, dtype=float)) # primeiro argumento: núm. de elementos.

[0 0 0 0 0 0 0 0 0 0]
[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
[12. 12. 12. 12. 12. 12. 12. 12.]

# Criar um array bidimensional 2x5 preenchido com zeros, do tipo inteiro:
print(np.zeros((2, 5),dtype=int))

[[0 0 0 0 0]
 [0 0 0 0 0]]

Criar array a partir de faixas de valores: método arange

Também é possível criar um array  a partir de uma faixa de valores especificada, tanto de números inteiros quanto de números de ponto flutuante.

Para isso usamos os métodos arange e linspace.

Criar array com método arange

# Array de 10 elementos, números de 0 a 9
print(np.arange(10))

[0 1 2 3 4 5 6 7 8 9]

# Array de 10 elementos float, números de 0 a 9
print(np.arange(10.))

[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

Basta usar um ponto . na definição da quantidade de elementos do array e automaticamente a função irá criar números de ponto flutuante em vez de números inteiros.

# Array com valores no intervalo de 5 a 15 (usamos 16, pois o último número é sempre limite superior - 1)
print(np.arange(5,16))

[ 5  6  7  8  9 10 11 12 13 14 15]

# Array com os números pares de 50 até 1
# O terceiro argumento, -2, indica o intervalo de contagem dos valores ("passo").
print(np.arange(50, 1, -2))

[50 48 46 44 42 40 38 36 34 32 30 28 26 24 22 20 18 16 14 12 10  8  6  4  2]

Criar array com método linspace

# Criar array com valores de ponto flutuante com o método linspace. 
print(np.linspace(0.0,2.0,num=5))

[0.  0.5 1.  1.5 2. ]

Os argumentos passados para o método linspace são:

• primeiro argumento: valor inicial
• segundo argumento: valor final
• terceiro argumento (num): quantidade de itens a gerar

Preencher array com valores aleatórios (randômicos)

Podemos criar arrays e preenchê-los com números aleatórios, inteiros ou de ponto flutuante, usando os métodos rand e randint da biblioteca NumPy.

# Criar e preencher array com valores aleatórios

import numpy as np

# Array de 10 elementos entre 0 e 1
a = np.random.rand(10)
print(a)

[0.07418479 0.95672716 0.19361192 0.32394591 0.29980946 0.20812523
 0.92100292 0.49129843 0.78413243 0.07830975]

# Gerar um número aleatório inteiro entre 0 e 8 com random.randint
print('Número aleatório:', np.random.randint(9))

Número aleatório: 3

# Array unidimensional com 10 números aleatórios inteiros entre 1o e 20
b = np.random.randint(10,21,size=10)
print(b)

[13 17 16 16 16 12 18 15 14 12]

# Array bidimensional 3x3
c = np.random.rand(3,3)
print(c)

[[0.56700019 0.56581178 0.47336097]
 [0.5626577  0.75670315 0.8608974 ]
 [0.71296439 0.09674716 0.95800157]]

# Array bidimensional 10x10 com números aleatórios inteiros entre 1 e 100
d = np.random.randint(1,101,size=(10,10))
print(d)

[[ 50  55  74  93  77  42  71  69  44  50]
 [ 13  13  79  50  82  75  91  11  79  26]
 [ 76  47  59  79  20  58  30  20  22  36]
 [ 13  81   9  77  34  21   3  91  21  29]
 [ 88  38  76 100   9  18  20  11  39  94]
 [ 45  23  81  13  59   1  13  44  36  33]
 [ 48  93  82  99  97  39  94  23  41  86]
 [ 17  21  65  52  85  87  15  75  50  75]
 [ 61  35  17  52  71  32  29  61  21  62]
 [ 66  19  78  47  92  23  52  58  81  68]]

É isso aí! Nesta lição aprendemos como preencher um ndarray em NumPy usando métodos variados, que permitem atribuir valores específicos, listas de valores ou valores gerados de forma aleatória ao array.

Aproveite e assista a uma aula em vídeo sobre o preenchimento de arrays em NumPy:

Até a próxima!

O post Como preencher arrays com NumPy (ndarrays) apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Por Fábio dos Reis

O NumPy, (Numerical Python) é uma biblioteca de código aberto criada em 2006, sendo um pacote fundamental extensivamente empregado para computação numérica e científica de alta performance e velocidade em Python.

Escrita em linguagem C, é a implementação de estruturas de dados do tipo arrays preferida em Python, fornecendo um tipo de array de alta performance chamado de ndarray.

As operações sobre arrays do NumPy chegam a ser até duas ordens de magnitude mais rápidas do que om o emprego de listas comuns em Python, o que certamente é uma grande vantagem quando pensamos em grandes volumes de dados a serem manipulados e analisados, por exemplo em aplicações para Big Data e Computação Numérica / Científica.

O NumPy trabalha com um objeto de array especial de N dimensões poderoso chamado de ndarray (N-Dimensional Array / Array de N Dimensões), e possui diversas funções e métodos para sua manipulação, além de ouros tipos de objetos como masked arrays e matrizes, dos quais trataremos futuramente.

Muitas bibliotecas populares e altamente importantes dependem do NumPy para operar, como por exemplo as bibliotecas SciPy (para computação científica), Pandas (Análise de Dados), OpenCV, Scikit-learn e Keras (para Machine Learning / Deep Learning), entre centenas de outras bibliotecas.

Neste tutorial vamos mostrar como criar arrays de uma, duas e três dimensões usando o NumPy.

Módulo NumPy

O módulo NumPy fornece diversas funções para criação e manipulação de arrays. Os elementos em um array podem ser acessados por meio de seus números de índice (posição), e os índices de arrays iniciam sua contagem em 0, de modo que o primeiro elemento armazenado é o elemento de índice 0, o segundo elemento é o elemento de índice 1, e assim por diante.

Para trabalhar com o NumPy devemos importar o módulo correspondente usando a seguinte declaração no início do script:

import numpy as np

Não é obrigatório usar o alias np, mas vamos usá-lo em nossos tutoriais por se tratar de um nome bastante utilizado pela comunidade e recomendado na documentação oficial da biblioteca.

Arrays Unidimensionais com NumPy

Um array de uma dimensão, ou unidimensional, é semelhante a um vetor, que costumamos estudar em lógica de programação. Com o NumPy, podemos criar arrays de uma dimensão com muita facilidade, contendo elementos de um tipo específico.

Podemos criar um array usando o método np.array(), passando para ele uma lista com os elementos que comporão o array.

Vamos criar um array de uma dimensão contendo seis elementos numéricos, a partir de uma lista de valores comum:

# Importar o módulo numpy. Recomenda-se importá-lo como "np",
# de acordo com a documentação oficial, para padronização.
import numpy as np

# Criar um array (objeto ndarray) de nome "números" a partir de
# uma lista de valores com o método np.array()
números = np.array([4,8,16,32,64,128])

# Opcionalmente, podemos especificar o tipo de dado dos objetos
# do array com um segundo parâmetro. Por exemplo, np.int16 significa
# um número inteiro de 16 bits, no intervalo de -32768 a 32767:
# números = np.array([4,8,16,32,64,128], np.int16) # Elementos do tipo Int 16 bits.

# Com a função type podemos ver o tipo do objeto criado
print(type(números))

# Ver o conteúdo do array (valores alinhados à direita, ocupando
# o mesmo número de casas de acordo com o maior número presente)
print(números)

# Ver elementos específicos no array por meio de seus números de índice
# (sempre começando em zero)
print(números[0]); print(números[1]); print(números[2]); print(números[-1])

Resultado:

<class 'numpy.ndarray'>
[  4   8  16  32  64 128]
4
8
16
128

Podemos verificar o tipo dos elementos que compõem o array consultando o atributo dtype

números.dtype
Out: dtype('int32')

Arrays Bidimensionais com NumPy

Costumamos chamar de “matriz” a um array bidimensional (o NumPy possui um objeto específico para matrizes). Podemos criar um array bidimensional com NumPy a partir de uma lista de duas dimensões passada como parâmetro:

# Array bidimensional 2x3
# Cada colchete aninhado representa uma dimensão do array.
# Dois pares de colchetes - [[ ]]- indicam duas dimensões:
x = np.array([[1,2,3],[6,4,2]], np.int16)

# Mostrar a matriz completa
print(x)

# Exibir elementos em posições específicas na matriz:
print(x[0,0]); print(x[0,1]); print(x[0,2]); print(x[0,-1])
print(x[1,0]); print(x[1,1]); print(x[1,2]); print(x[1,-1])

Resultado:

[[1 2 3]
[6 4 2]]
1
2
3
3
6
4
2
2

É possível trabalhar com linhas ou colunas individuais do array de duas dimensões, usando fatiamento (slicing). Vejamos alguns exemplos:

Colunas inteiras

# Imprimir colunas inteiras
print('Primeira coluna: ', x[:,0]) 
print('Segunda coluna: ', x[:,1])
print('Terceira coluna: ', x[:,2])

Saída:

Primeira coluna: [1 6]
Segunda coluna: [2 4]
Terceira coluna: [3 2]

Linhas Inteiras

# Imprimir linhas inteiras
print('Primeira linha: ', x[0,:])
print('Segunda linha: ', x[1,:])

Saída:

Primeira linha: [1 2 3]
Segunda linha: [6 4 2]

Alguns atributos dos arrays

Podemos determinar o número de dimensões de um array (se é uni, bi ou tridimensional) com o atributo ndim

print(números.ndim)
print(x.ndim)

Dimensões do array números: 1
Dimensões da matriz: 2

E também é possível determinar as dimensões de um array com o atributo shape (tamanho do array)

print('Tamanho do array números: ', números.shape)
print('Tamanho da matriz x: ', x.shape)

Tamanho do array números: (6,)
Tamanho da matriz x: (2, 3)

E ainda o número total de elementos de um array, por meio do atributo size:

print('Total de elementos do array números: ', números.size)
print('Total de elementos da matriz x: ', x.size)

Total de elementos do array números: 6
Total de elementos da matriz x: 6

Outro atributo útil é o atributo itemsize, que permite descobrir o tamanho dos elementos de um array (número de bytes necessário para seu armazenamento).

print(números.itemsize)
print(x.itemsize)

4
4

E o atributo flat permite iterar por um array multidimensional como se ele fosse unidimensional:

for i in x.flat:
    print(i, end=' ')

1 2 3 6 4 2 

O parâmetro end=’ ‘ é usado para mostrar os itens em uma única linha, em vez de um item por linha.

Arrays Tridimensionais com NumPy

Damos o nome genérico de “cubo” a um array de três dimensões, contendo os eixos x, y e z no plano cartesiano. Podemos  criar um array tridimensional (lista de três dimensões) com o NumPy usando o mesmo método usado anteriormente, o método np.array().

# Criar um array tridimensional
# Cada colchete aninhado representa uma dimensão do array.
# Três pares de colchetes - [[[  ]]]- indicam três dimensões:
cubo = np.array([[[1,4,7],[3,5,2]],[[5,6,0],[7,4,1]],[[2,8,8],[0,3,6]]])
print('Array tridimensional:\n ', cubo)

# Visualizar elementos específicos do cubo (array tridimensional):

print('\nItem na posição 0,0,0: ', cubo[0,0,0])
print('Item na posição 1,0,0: ', cubo[1,0,0])
print('Item na posição 2,0,0: ', cubo[2,0,0])

Resultado:

Array tridimensional:
  [[[1 4 7]
  [3 5 2]]

 [[5 6 0]
  [7 4 1]]

 [[2 8 8]
  [0 3 6]]]

Item na posição 0,0,0:  1
Item na posição 1,0,0:  5
Item na posição 2,0,0:  2

Conclusão

É isso aí! Neste tutorial aprendemos a criar arrays usando NumPy n Python, incluindo arrays unidimensionais (“vetor”), arrays bidimensionais (“matriz”) e arrays tridimensionais (“cubo”). 

Na próxima lição vamos estudar métodos para preencher os arrays com valores específicos, e como realizar operações aritméticas e matemáticas sobre os elementos de um array.

Enquanto isso, assista a um vídeo da Bóson Treinamentos sobre arrays com NumPy:

Até!

O post Como criar um array no Python com NumPy apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O software para computação numérica e científica GNU Octave possui algumas constantes numéricas pré-definidas, que podem ser empregadas em cálculos diversos ou ainda retornadas como resultado de operações matemáticas. Elas estão listadas na tabela a seguir:

A constante eps indica o valor de precisão da máquina, ou o valor entre dois números adjacentes no sistema de ponto flutuante da máquina.

Exemplos

Vamos chamar essas constantes na Janela de Comandos do Octave e visualizar o que é retornado em cada exemplo. A variável de sistema ans armazena o resultado de cada chamada:

>> format long
>> pi
ans = 3.141592653589793
>> e
ans = 2.718281828459045
>> i
ans = 0 + 1i
>> j
ans = 0 + 1i
>> inf
ans = Inf
>> NaN
ans = NaN
>> realmax
ans = 1.797693134862316e+308
>> realmin
ans = 2.225073858507201e-308
>> eps
ans = 2.220446049250313e-16

Usamos o comando format long no início dos exemplos para exibir os valores com até 15 algarismos significativos, quando aplicável.

A seguir, alguns exemplos de retorno dessas constantes em operações aritméticas.

>> sqrt(-1)
ans = 0 + 1i
>> 25 / 0
warning: division by zero
ans = Inf
>> 10E300 ^ 2
ans = Inf

No primeiro exemplo, calculamos a raiz quadrada de -1 usando a função sqrt(). O resultado é o número imaginário i, representado por 0 + 1i. Logo após, tentamos dividir um número por zero, e o resultado foi um aviso de divisão por zero, com a variável ans mostrando o valor Inf (infinito). E, finalmente, tentamos elevar o número 1×10³⁰⁰ (10E300) ao quadrado, gerando um número maior que o maior valore representável – e, assim, retornando o valor Inf também (infinito).

O post Constantes pré-definidas no Octave apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O GNU Octave é um software / linguagem extremamente poderoso para computação numérica de alta complexidade. Mas, para realizar cálculos avançados usando esta aplicação precisamos primeiramente saber como fazer cálculos simples – mais especificamente, como realizar aritmética simples no Octave.

O Octave possui operadores aritméticos para as principais operações aritméticas, similares aos encontrados em outras linguagens de programação. A tabela a seguir mostra esses operadores, com seus símbolos e operações que realizam. Note que para o cálculo do resto da divisão inteira – operação de módulo – em vez de um operador simples é empregada uma função – mod().

Os operadores podem ser aplicados diretamente sobre valores escalares, arrays, variáveis e outros tipos de objetos. Vejamos alguns exemplos de cálculos bem simples usando esses operadores aritméticos no GNU Octave:

1 – Soma e subtração de valores

>> a = 10;
>> b = 12;
>> c = 3;
>> a + b - c
ans = 19
>> a - b - 1
ans = -3

Sem segredos aqui. Podemos somar e subtrair valores diretamente (escalares) ou armazenados em variáveis.

2 – Multiplicação e divisão de valores

>> a = 3;
>> b = 5;
>> f = 4;
>> a * b
ans = 15
>> f / b
ans = 0.80000
>> b * f / a
ans = 6.6667

Perceba que a divisão retorna um número de ponto flutuante sempre que ao menos um dos operandos seja de ponto flutuante, ou que o resultado obtido o seja. Se ambos os operandos forem números inteiros, e a divisão resultar em resultado inteiro, o dado não será retornado como ponto flutuante, mas sim, inteiro,

3 – Módulo (resto da divisão)

>> d = 9;
>> e = 2;
>> f = 3;
>> d / e
ans = 4.5000
>> mod(d,e)
ans = 1
>> d / f
ans = 3
>> mod(d,f)
ans = 0

A função mod(a,b) toma dois argumentos,a  e b, e retorna o resto da divisão inteira de a por b.

5 – Exponenciação no Octave

>> a = 2;
>> b = 5;
>> c = 10;
>> b ^ a
ans = 25
>> a ^ c
ans = 1024
>> c ^ a ^ b
ans = 10000000000
>> 3 * c ^ a
ans = 300
>> 1 / b ^ c
ans = 0.00000010240
>> format rat
>> 1 / b ^ c
ans = 1/976562

Note que executamos o último exemplo duas vezes: uma co o formato de exibição normal, e outra precedendo a operação aritmética com o comando format rat, que permite exibir o resultado de um cálculo no formato racional (números fracionários). Para voltar a exibir os resultados no modo de exibição normal (decimal), basta executar o comando format short:

>> format short

É isso aí! Na próxima lição vamos explorar algumas funções matemáticas muito úteis no Octave, incluindo funções trigonométricas, logarítmicas, cálculo de raízes, de arredondamento e outras. Até!

O post Operações Aritméticas simples no Octave apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

A linguagem Julia é uma linguagem de programação multiparadigma, dinâmica, de alto nível e alta performance, amplamente utilizada para computação científica, análise numérica e ciência de dados.

Como características da linguagem Julia podemos citar:

• Suporta computação paralela, concorrente e distribuída
• Disponibiliza diversas bibliotecas eficientes para cálculos em ponto flutuante
• Permite gerar números aleatórios de forma eficiente
• Trabalha de forma poderosa e ao mesmo tempo simplificada com álgebra linear
• Trabalha com coletor de lixo (Garbage Collector)
• Possui bibliotecas que permitem realizar transformadas rápidas de Fourier
• Tem suporte em várias IDEs, como o Atom (Juno) e VS Code
• Permite chamar diretamente bibliotecas Fortran e C sem usar wrappers (glue code)

e muitas outras.

Neste tutorial vamos mostrar como baixar e instalar a linguagem Julia no Linux Debian, além de testar nossa instalação executando alguns cálculos simples posteriormente.

• Website oficial da linguagem: www.julialang.org
• Versão estável mais atual: 1.5.3

Instalação do Julia no Debian Linux

Primeiramente, devemos verificar se a linguagem Julia já está instalada no sistema:

$ julia

Se o prompt da linguagem não for apresentado, significa que você ainda não tem a linguagem Julia instalada em seu sistema Linux. Vamos realizar sua instalação a partir de agora.

Podemos instalar a Julia no Debian Linux de várias formas; a que vamos apresentar neste tutorial é por meio da loja de aplicativos Snap.

Os snaps são aplicativos empacotados com todas as suas dependências, prontos para serem instalados em inúmeras distribuições Linux, com atualizações automáticas simplificadas.

Para instalar um pacote snap, basta usar a loja Snap Store, na qual é possível pesquisar e instalar milhares de aplicativos.

Porém, para tal é necessário ter o pacote snapd já instalado em seu sistema. Caso você ainda não o tenha, instale-o com os comandos a seguir:

$ sudo apt install snapd
$ sudo snap install core

Reinicie sua sessão após instalar o snapd para configuração automática da variável de ambiente $PATH.

Instalar a linguagem Julia no Debian via Snap

Após instalar e atualizar o snapd, instale a linguagem de programação Julia com o comando a seguir:

$ sudo snap install julia --classic

Após terminar a instalação, vamos testar a linguagem Julia. Digite o comando a seguir para abrir o interpretador da linguagem:

$ julia

Será exibido o prompt do interpretador de comandos da linguagem Julia:

julia>

Execute o comando a seguir no prompt do interpretador Julia para testar a instalação realizada:

julia> println("Bem-Vindos à Bóson Treinamentos!")

Excelente! Linguagem Julia instalada com sucesso no Debian Linux 10, por meio de um pacote Snap.

Para sair do interpretador Julia e voltar ao terminal do Linux, digite a combinação de teclas Ctrl + d.

No próximo tutorial iniciamos o estudo da linguagem Julia em si. Até!

Veja também: Como instalar a linguagem Julia no Microsoft Windows

O post Como instalar a linguagem Julia no Linux Debian apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma variável, em programação, é uma área reservada na memória do sistema, que armazena de forma temporária um dado que será utilizado para processamento pelo programa ou script. As variáveis também podem armazenar o resultado do processamento de expressões ou funções, para posterior exibição ao usuário, armazenamento em um banco de dados, ou processamento adicional.

Neste tutorial veremos como declarar (criar) e usar variáveis no GNU Octave.

Declaração de variáveis no Octave

No Octave, não é necessário declarar as variáveis de antemão. Elas podem ser declaradas no momento em que serão utilizadas. Seus tipos e tamanhos são alocados automaticamente.

Os nomes de variáveis no Octave devem seguir algumas regras básicas, comuns a diversas linguagens de programação, tais como:

• Não podem iniciar com um número
• Pode haver números no nome da variável
• As variáveis são case-sensitive (diferenciam maiúsculas de minúsculas)
• Não se pode usar palavras reservadas da linguagem (for, while, clear, etc)
• Podem incluir underscores _

Note que o número máximo de caracteres possíveis no nome de uma variável é 63 (verificado consultando a propriedade namelengthmax)

>> namelengthmax
ans = 63

Atribuição de valores a variáveis

Atribuir um valor a uma variável significa gravar um valor (armazenar) na variável. O operador de atribuição de valor a uma variável é o sinal de igual =. Assim, o comando

variavel = valor

atribui valor à variável nomeada.

É possível criar diversas variáveis em uma mesma linha de comando, bastando para isso separar as declarações com vírgulas.

Vejamos alguns exemplos.

>> a = 2 * log(5);
>> n1 = 2, n2 = 4, n3 = 9;
n1 = 2
n2 = 4
>> a
a = 3.2189
>> n2 * n3
ans = 36
>> res = n1 / a;
>> res
res = 0.62133

ans: Variável que armazena os últimos valores obtidos como resultado de uma expressão avaliada. Trata-se de uma variável global.

Listar as variáveis

Com os comandos who e whos podemos listar as variáveis definidas na sessão atual do programa:

1 – Listar as variáveis no escopo atual do ambiente de trabalho (workspace):

>> who

Variables in the current scope:

a ans n1 n2 n3 res

2 – Listar as variáveis com informações mais detalhadas:

>> whos

Variables in the current scope:

Attr Name Size Bytes Class
==== ==== ==== ===== =====
     a    1x1      8 double
     ans  1x1      8 double
     n1   1x1      8 double
     n2   1x1      8 double
     n3   1x1      8 double
     res  1x1      8 double

Total is 6 elements using 48 bytes

Limpar as variáveis da memória

Podemos limpar todas as variáveis do ambiente de trabalho (workspace) com o comando clear:

>> clear

Também é possível limpar uma variável específica, bastando para isso fornecer seu nome ao comando clear:

>> clear res

É isso! Na próxima lição vamos falar sobre as Constantes no Octave. Até!

O post Declaração e atribuição de Variáveis no Octave apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial vamos mostrar como instalar e configurar o IDE Juno, para desenvolvimento em linguagem Julia. O Juno é um ambiente de desenvolvimento para Julia que é instalado junto ao editor de textos Atom, e por isso é necessário ter o Atom pré-instalado em sua máquina – é a partir dele que o Juno será baixado, instalado e configurado.

O website oficial do Juno, com informações detalhadas e manuais de uso é o https://junolab.org.

Instalando o Juno no Windows 10

Vamos seguir os passos abaixo para instalar o IDE Juno em um computador com Windows:

1. É necessário ter a linguagem Julia já instalada na máquina antes de instalar o IDE Juno. Caso não a tenha, siga os passos deste tutorial para instalar a Julia no Windows.

2. Com a linguagem Julia já instalada, baixe e instale o editor Atom, se você ainda não tiver esse editor de textos em seu sistema. Logo após instalá-lo, abra-o.

3. No IDE Atom, vá até Configurações (Ctrl+,), e entre no painel de instalação (Install Packages).

Digite uber-juno na caixa de pesquisa Packages e pressione enter. Clique no botão de instalação do pacote da JunoLab com o mesmo nome (Install).

O Juno será instalado e configurado pelo Atom, incluindo todos os pacotes necessários. Aguarde enquanto o processo é executado

Após o término da instalação, pode ser necessário incluir o caminho do executável do Julia nas configurações do IDE para que seja possível utilizar a linguagem (no meu caso foi). Para isso, clique no menu do Atom em Packages -> Juno -> Settings.

Procure a caixa “Julia Path (The location of the Julia binary)” e nela insira o caminho completo do executável do Julia. Esse caminho pode ser obtido clicando com o botão direito do mouse sobre o ícone do Julia da área de trabalho do Windows, e selecionando Propriedades -> Atalho.
Geralmente o caminho é algo como C:\Users\nome-usuário\AppData\Local\Programs\Julia 1.5.3\bin\julia.exe, onde nome-usuário é o nome do usuário que você usou para se logar no sistema.

Copie e cole o link na caixa Julia Path (retire as aspas, se houverem). Pressione enter para finalizar.

Testar o Juno IDE

Para testar o IDE, clique no menu Juno -> Open REPL. Na seção “Press Enter to start Julia“, pressione a tecla enter para iniciar o ambiente da Julia. Pode demorar um pouco para que o interpretador esteja disponível, portanto, aguarde.

Para testar a linguagem e o IDE, vamos digitar as linhas de código a seguir no interpretador de comandos do Julia para executar um cálculo aritmético simples:

julia> a = 5;
julia> b = 8;
julia> c = a * b / 2;
julia> println(c)

Resultado:

É isso aí! Maiores informações sobre a instalação do Juno IDE, incluindo a resolução de problemas, podem ser obtidas na página de documentação oficial: docs.junolab.org/latest/man/installation/

O post Como instalar o IDE Juno para programação em Julia no Windows apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Julia é uma linguagem de programação dinâmica, multiparadigma de alto nível e de alta performance, muito empregada nos campos da análise numérica e computação científica.

Algumas das principais características da linguagem Julia incluem:

• Suporta computação paralela, concorrente e distribuída
• Possui bibliotecas eficientes para cálculos de ponto flutuante
• Trabalha de forma simplificada com álgebra linear
• Geração de números aleatórios eficiente
• Possui bibliotecas para transformadas rápidas de Fourier
• Opera com Garbage Collector (coletor de lixo)
• Permite chamada direta de bibliotecas Fortran e C sem usar glue code (wrapper)
• Pode ser codificada em várias IDEs, como o VS Code

e muitas outras.

Neste tutorial vamos mostrar como baixar e instalar a linguagem Julia no Windows 10, além de testar nossa instalação executando alguns comandos simples na linguagem.

Como obter a linguagem Julia

É possível executar a linguagem Julia de várias formas:

• Pela linha de comandos (terminal)
• Usando imagens Docker do Docker Hub
• Por meio da interface Julia IDE

Neste tutorial vamos fazer a instalação da linguagem Julia e a testaremos pelo terminal (prompt), e em outra lição vamos baixar e instalar a IDE Juno (junolab.org), que irá facilitar muito nossos estudos de programação com Julia.

• Website oficial da linguagem: www.julialang.org
• Versão estável mais atual: 1.5.3

Para baixar a Julia, na página inicial do site, clique no link Download, ou vá diretamente para a página www.julialang.org/downloads

Na página de downloads vamos encontrar versões da Julia para várias plataformas, como Linux (x86 / ARM), macOS, FreeBSD e Windows, tanto 32 quanto 64 bits. Instalaremos a versão de 64 bits no Windows 10.
No site também está disponível o código-fonte para compilação da linguagem em outras plataformas.

No caso do Windows ainda há uma versão portable (que não necessita de instalação). Tome cuidado para não baixar esta versão, pois a que utilizaremos é a versão instalada na máquina.

Instalação da linguagem Julia

Na página de downloads no website indicado, clique no link 64-bit (installer) para baixar o instalador da linguagem Julia.

Após baixar o arquivo, execute-o para abrir o instalador. Verifique o diretório de instalação (não é necessário alterar) e clique em Next >:

Na tela seguinte você pode selecionar tarefas adicionais – basicamente, criar um atalho na área de trabalho e uma entrada no menu iniciar do Windows. Deixarei ambas as opções marcadas. Clique em Next > para prosseguir.

Agora aguarde enquanto a linguagem Julia é instalada em seu sistema.

Após a instalação vamos testar a linguagem. Deixe a caixa Run Julia marcada e clique em Finish para encerrar o instalador.

Será aberto uma janela de comandos (terminal) com o prompt da Julia pronto para receber comandos. Para obter ajuda, basta digitar ? e pressionar enter.

Testar a linguagem Julia

Vamos testar nossa instalação da Julia agora. Para isso, digite os comandos a seguir no terminal aberto, pressionando enter após cada comando:

julia> a = 5
julia> b = 3
julia> a^b

Resultado esperado:

É isso aí! Linguagem Julia instalada e testada com sucesso em um computador com Windows. A documentação oficial da linguagem Julia pode ser acessada nesta página: Documentação do Julia 1.5

Nos próximos tutoriais vamos mostrar como usar a linguagem Julia para criar programas e scripts diversos. Até!

O post Como instalar a linguagem Julia no Windows apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.