O arredondamento preciso de valores numéricos desempenha um papel muito importante em diversas aplicações científicas e de engenharia. No contexto da programação em Python, a biblioteca NumPy se destaca como uma ferramenta poderosa para manipulação eficiente de arrays e cálculos numéricos em geral.

Neste artigo, exploraremos algumas funções de arredondamento numérico disponíveis no NumPy, mostrando alguns exemplos de como empregar essas funções para realizar arredondamentos diversos, incluindo arredondamento de valores de ponto flutuante e para números inteiros.

Ao entender como usar essas funções, será possível otimizar nossos códigos e garantir resultados numericamente estáveis em uma variedade de cenários.

Vamos às funções de arredondamento de valores com NumPy, para Python.

Importar o NumPy

O primeiro passo para usar as funções que serão abordadas é importar a biblioteca NumPy no script que usará as funções de arredondamento (o módulo numpy deve estar instalado previamente; caso não esteja, realize a instalação do NumPy seguindo estas instruções):

import numpy as np

Após importar a biblioteca, vejamos as funções mais importantes para arredondamento de valores numéricos.

1. Função numpy.round

Ou seu alias numpy.around(): Arredonda o valor até uma precisão desejada

Sintaxe

numpy.round(valor,[num_casas_decimais])

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.round.html

Exemplo de uso

# Criar um array de valores a serem arredondados:
valores = np.array([5.0, 6.98, 0.9863, 555, 10.099])
# Podemos usar também uma simples lista (descomentar para testar):
# valores = [5.0, 6.98, 0.9863, 555, 10.099] 
print('Array original:')
print(valores)

print('\nValores arredondados:')
print(np.round(valores, decimals = 2))
print(np.round(valores, decimals = 3))
print(np.around(valores)) # valores são exibidos no formato float64
print(np.around(valores).astype(int)) # converter valores para int antes da exibição (não mostra o ponto)

Resultado:

Array original:
[ 5. 6.98 0.9863 555. 10.099 ]

Valores arredondados:
[ 5. 6.98 0.99 555. 10.1 ]
[ 5. 6.98 0.986 555. 10.099]
[ 5. 7. 1. 555. 10.]
[ 5 7 1 555 10]

2. Função numpy.floor

Arredonda para o maior inteiro menor que o valor de entrada (“tipo” arredonda para baixo).

Retorna o menor inteiro i, tal que i <= valor

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.floor.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])
print('Array original:')
print(valores)
print('\nValores arredondados:')
print(np.floor(valores))

Resultado:

Array original:
[ 6.3 0.786 55. 10.999 -0.63 ]
Valores arredondados:
[ 6. 0. 55. 10. -1.]

3. Função numpy.ceil

Arredonda para o inteiro imediatamente maior que valor de entrada (“tipo” arredonda para cima). Essa função retorna o menor número inteiro i, tal que i >= valor

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.ceil.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])  # mesmo array usado em np.floor
print('Array original:')
print(valores)
print('\nValores arredondados:')
print(np.ceil(valores))

Resultado:

Array original:
[ 6.3 0.786 55. 10.999 -0.63 ]
Valores arredondados:
[ 7. 1. 55. 11. -0.]

4. Função numpy.trunc

Truncar um valor numérico. Retorna o valor truncado da entrada, elemento a elemento.

O valor truncado do escalar x é o inteiro mais próximo i que está mais próximo de zero do que x. Resumindo, a parte fracionária do valor atribuido é descartada.

O que é truncar?

O verbo “truncar” se refere ao ato de cortar ou remover a parte fracionária de um número, mantendo apenas a parte inteira. A operação de truncamento geralmente é realizada em números de ponto flutuante, onde há uma parte inteira e uma parte decimal. Também é possível aplicar a operação de truncagem em strings, o que não é o caso aqui.

Por exemplo, se tivermos o número de ponto flutuante 7.75 e quisermos truncá-lo para um inteiro, o resultado será 7, pois a parte decimal (0.75) foi removida.

É importante observar que o truncamento difere do arredondamento, onde a parte decimal é arredondada para o inteiro mais próximo. No truncamento, a parte decimal é simplesmente removida, resultando sempre em um número menor ou igual ao número original.

Documentação de numpy.trunc: https://numpy.org/doc/stable/reference/generated/numpy.trunc.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])
print('Valores truncados:')
print(np.trunc(valores))

Resultado:

Valores truncados:
[ 6. 0. 55. 10. -0.]

5. Função numpy.fix

Arredonda para o número inteiro mais próximo em direção a zero.

Arredonda um array de pontos flutuantes elemento a elemento para o número inteiro mais próximo de zero. Os valores arredondados são retornados como valores de ponto flutuante.

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.fix.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])
print('Valores Arredondados:')
print(np.fix(valores))

Resultado:

Valores Arredondados:
[ 6. 0. 55. 10. -0.]

Conclusão

As funções de arredondamento proporcionadas pela biblioteca NumPy conferem uma grande flexibilidade aos programadores Python ao lidar com operações numéricas. Seja em análises estatísticas, processamento de dados ou simulações complexas, o entendimento aprofundado dessas funções é fundamental para assegurar resultados confiáveis e consistentes.

Neste artigo, trabalhamos com as principais funções de arredondamento do NumPy, com exemplos de códigos simples para melhor entendimento de cada função. Ao incorporar esses conhecimentos em seus projetos, você estará mais preparado para resolver desafios numéricos e obter soluções eficientes e precisas ao criar aplicações com Python.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post 5 Funções de Arredondamento de Valores com NumPy em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

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.

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.

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.

No artigo anterior mostramos como instalar e rodar o software para computação numérica e científica GNU Octave no Debian Linux (e sistemas derivados). Vamos agora mostrar como baixar e instalar o GNU Octave no Microsoft Windows 10, além de executar um comando de teste após a instalação do programa.

O procedimento é bem simples e relativamente rápido, e vamos começar acessando o site do Octave e baixando o pacote necessário.

Download do Octave

A página para download do GNU Octave é www.gnu.org/software/octave/download. Nela encontraremos links para download de versões do software para GNU/Linux, macOS, BSD e Windows, além do código-fonte para compilar.

Clique no link MS Windows. Vamos baixar a versão de 64 bits (recomendada), que, no caso, é a versão 5.2 do Octave. Basta clicar no link do instalador (arquivo executável .exe), que tem cerca de 300 MB de tamanho, e aguardar o download do programa.

Observação: há uma outra versão para download na mesma página, contendo pacotes para operações com álgebra linear e grandes volumes de dados. Essa versão é recomendada apenas para computadores com ao menos 32 GB de memória RAM e trabalhos que envolvam arrays com mais de 2 bilhões de elementos. Não é nosso caso, de modo que não instalaremos essa versão.

Atenção: Para executar o Octave, é necessário ter o JRE (Java Runtime Environment) instalado na máquina. Caso seu computador não tenha, baixe e instale o ambiente Java em www.java.com/pt-BR/download/manual.jsp.

Instalação do GNU Octave no Windows

Após o término do download, execute o arquivo do instalador para iniciar o processo de instalação do Octave no Windows. Após abrir o instalador, clique em Next > para iniciar.

Na tela License Agreement, clique em Next > para aceitar a licença GNU GPL e prosseguir com a instalação.

Na próxima tela temos as opções de instalação. Deixe as opções marcadas – não é necessário alterar nada. Clique em Next >.

Na sequência, você pode escolher o local de instalação do Octave no computador. Vamos aceitar a localização padrão – C:\Octave\-Octave-5.2.0 – e clicar em Install para iniciar a instalação propriamente dita. Note que são necessários 1,7 GB de espaço livre em disco para instalar o software.

Aguarde enquanto a instalação é efetuada.

Após o término da instalação, clique em Finish para finalizar o instalador, e deixe marcada a caixa Run GNU Octave para abrir o programa, pois vamos testar nossa nova instalação rodando um comando na Janela de Comandos posteriormente:

Porém, antes disso, devemos criar um arquivo de configuração do Octave. Para isso, basta clicar em Avançar na próxima tela (note que a janela já está em Português).:

Na próxima tela, marque a caixa “Permitir que o Octave se conecte à Internet durante a inicialização para buscar as novidades e informações atuais da comunidade“, e clique em Próximo:

Na tela seguinte, clique em Finalizar para terminar a instalação e configuração do Octave no Windows. Após o término da instalação, serão criados dois atalhos na área de trabalho: um para acesso à interface gráfica do Octave (GNU Octave GUI) e um para acesso ao software via prompt de comandos (GNU Octave CLI).

Excelente! A interface gráfica do GNU Octave será aberta automaticamente agora:

Testando o GNU Octave

E, para finalizar, vamos testar o programa executando um comando na Janela de Comandos. Vamos criar e exibir uma matriz 3×3. Para isso, digite o seguinte comando no prompt >> da janela de comandos e pressione a tecla Enter logo após:

>> A = [2, 5, 7; 3, 6, 0; 1, 8, 3]

Resultado:

É isso aí! GNU Octave instalado com sucesso no Microsoft Windows. no próximo artigo vamos começar a explorar o programa, falando sobre as partes constituintes de sua interface, sobre variáveis, comandos variados e muito mais.

Até!

O post Como instalar o GNU Octave no Microsoft Windows 10 apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste artigo vamos proceder à instalação e teste do GNU Octave no Debian Linux (e derivados, como o Ubuntu e Linux Mint).

O GNU Octave é uma linguagem de alto nível empregada para a realização de computação numérica de alta performance, como a resolução de equações lineares e não-lineares, álgebra linear, análise estatística e muitas outras operações, de forma análoga à linguagem MATLAB. Porém, ao contrário desta, o Octave é software livre.

O Octave está disponível em inúmeras plataformas, como várias distribuições Linux, macos, Windows e BSD, entre outras.

Instalação do Octave no Debian

Para instalar o GNU Octave no Linux Debian, basta executar os comandos a seguir:

$ sudo apt update
$ sudo apt install octave

Instalaremos também os arquivos de desenvolvimento do Octave:

$ sudo apt install liboctave-dev

Após executar esses comandos, o Octave estará pronto para ser usado. Vamos executar o Octave para teste, usando o Terminal:

$ octave

Será exibido o prompt do Octave, como segue:

octave:1>

Vejamos agora alguns exemplos de cálculos com o Octave para testar nossa nova instalação.

Exemplos

Exemplo 01: realizar um cálculo aritmético simples:

octave:1> 2 * 3 + 5 * 2

Note que ans é uma variável interna que guarda a resposta do cálculo realizado, para exibição.

Exemplo 02: ver o valor de pi:

octave:1> pi

Exemplo 03: criar uma matriz 3×3 preenchida com valores aleatórios:

octave:1> A = rand(3,3)

Para obter ajuda sobre os comandos do Octave, usamos o comando help, seguido do nome do comando que desejamos consultar, como nos exemplos a seguir:

octave:1> help randw
octave:1> help plot

No Terminal, podemos limpar a tela de forma simples:

octave:1> Ctrl+l

Finalmente, para sair do Octave no terminal podemos usar quit ou exit:

octave:1> quit
ou
octave:1> exit

Interface Gráfica do GNU Octave

Também podemos abrir o Octave no modo de Interface Gráfica. Para tal, no GNOME, clique em Atividades -> Mostrar Aplcativos -> GNU Octave:

Será aberta a GUI do Octave:

Os comandos podem ser digitados na tela central, a Janela de Comandos, bastando pressionar a tecla Enter para executá-los:

É isso aí! No próximo artigo vamos iniciar a exploração do GNU Octave e conhecer mais de seus recursos.

Mais informações: Documentação Oficial do GNU Octave.

O post Como instalar o GNU Octave no Linux Debian e derivados apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.