Author Archives: Abel Soares Siqueira

Installing CUTEst and CUTEst.jl

By: Abel Soares Siqueira

Re-posted from: http://abelsiqueira.github.io/installing-cutest-and-cutest.jl/

This post will tell you how to install CUTEst using a different tool that makes
it much easier. Also, I’ll install CUTEst.jl, the CUTEst interface for Julia.

Edit: Now, CUTEst.jl install CUTEst by itself. Check this
post
.
Also, for Linux, I’ve created this CUTEst
installer
, which should be
easier to use. February, 11, 2017
.

Edit: Some corrections were made on February, 15, 2016.

Edit: Some corrections were made on November, 11, 2015.

By now you probably know
CUTEst,
the repository for testing and comparing nonlinear programming algorithms.
It’s widely used in the community for some time (considering CUTE and CUTEr,
the previous versions).
If not, this is a good change to test it, using
Julia to play around.
This is a not a post to convince you to use Julia, but I have to say that it is
much easier to use CUTEst on Julia than on MatLab.
So, if you are starting on it, I suggest you take a look.

We will use Homebrew to install CUTEst, for two reasons:

  • It’s much easier (when you learn it)
  • Julia requires shared libraries, that the original installation did not
    provide.

Homebrew is a kind of package manager (such as apt-get, pip, etc.).
For linux, there are many things that we don’t need from Homebrew, because you
normally already have a package manager. However, Homebrew is widely used by OSX
users, so it has a lot of packages.
The linux version is Linuxbrew.

The installation is quite simple:

  • Install brew
  • Install CUTEst
  • Install CUTEst.jl

I just made these steps and record my terminal, so you can check
Asciinema, or the embedded version on the
bottom of the page. Be warned, though, that I was “cold running” them, so some
parts are very slow.

To install brew, I recommend you check the page. For the impatient,

ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/linuxbrew/go/install)"
echo 'export PATH="$HOME/.linuxbrew/bin:$PATH"' >> $HOME/.bashrc
source $HOME/.bashrc
sudo apt-get install build-essential subversion
brew doctor

To install CUTEst, read the
tap cutest.
Again, for the impatient

brew tap optimizers/cutest
brew install cutest
brew install mastsif
for f in archdefs mastsif sifdecode cutest; do \
  echo "source $(brew --prefix $f)/$f.bashrc" >> \
  $HOME/.bashrc; \
done
echo 'export LD_LIBRARY_PATH="$HOME/.linuxbrew/lib:$LD_LIBRARY_PATH"' >> $HOME/.bashrc
source $HOME/.bashrc

This should get CUTEst installed.
Notice the LD_LIBRARY_PATH variable, which points to where the CUTEst library
will be.

Test it with

brew test sifdecode
brew test cutest

That’s it. You have CUTEst installed to use with Fortran or C.
A can’t provide a simple example, because they aren’t simple (enough).
I’ll now go to Julia, and I recommend you try it.

To install Julia, go to their page, then downloads, then download the
static version of the stable release (or do what you want, I’m not your boss).
Then, in julia, to install
CUTEst.jl,
issue the commands

Pkg.clone("https://github.com/abelsiqueira/CUTEst.jl")
Pkg.checkout("CUTEst", "fix/issue4")

If nothing goes wrong, then you can play around.
For instance, to open problem HS32 and get the objective function value at point
(2,3), we do

using CUTEst
nlp = CUTEstModel("HS32")
f = obj(nlp, [2.0;3.0])

If you’re familiar with CUTEst, you can use the classic functions cfn and
ufn too, in the default way (as called from C) or a more Julian way.
This would become too long to explain now, so I’ll make a post in a few days (or
months).
If you need it, please contact me.

This concludes the new installation of CUTEst.

Warning: Due to current limitations we cannot open two problems at the same
time in CUTEst without the possibility of a segmentation fault.
So, if you need to run cutest for a list of problems, I suggest you use a bash
script to loop over each problem and call your Julia code passing the problem as
an input argument.

Ths embedded Asciinema video is below.

Workshop de Ferramentas Computacionais – Maio de 2015

By: Abel Soares Siqueira

Re-posted from: http://abelsiqueira.github.io/workshop-2015-05-30

Sobre

No dia 30 de Maio de 2015 acontecerá uma Oficina de Ferramentas Computacionais
para Pesquisadores.
Essa oficina será focada em três ferramentas básicas para desenvolvimento de
software:

  • Bash
  • Git
  • Julia

O Bash é o terminal tradicinal dos sistemas GNU/Linux (a tela preta).
As possibilidades de uso são ilimitadas, mas vamos focar no básico,
tentando chegar até a criação de um script simples.

O Git é uma ferramenta para controlar versões de softwares e outros arquivos.
Você consegue guardar versões anteriores dos seus arquivos, assim como versões
alternativas, com uma estrutura escondida que melhora a organização e o design.
Ela é usada principalmente para controle de versões de software, permitindo que
cada programador saiba o que foi feito por quem e quando, mas também pode ser
utilizado para controle de versões de artigos, teses e apresentações.
O modelo de tese do IMECC – UNICAMP
usa o Git, e este site está armazenado usando o
Git
.
É uma das ferramentas principais para gerenciamento de versões, e muitos
projetos importantes o usam
.
O Git pode ser usado apenas em seu computador, mas o uso comum envolve algum
servidor remoto (principalmente para colaboração). A oficina tentará mostrar um
pouco de cada.

Julia é uma nova linguagem de programação que tem o objetivo de ser rápido como
C/Fortran, permitindo uma interfaca simples entre C e Fortran, e com sintaxe
parecida com a de Matlab e Python.
Como é uma linguagem livre, acreditamos ser uma escolha melhor que o Matlab para
software livre.
Também é uma boa linguagem inicial por ser prática, e tem muito espaço para
expansão por nova.

Ministrantes

  • Eu – Trabalho com GNU/Linux desde minha graduação,
    e trabalho com software livre. Meus trabalhos individuais são de código
    aberto, e acredito que esse é o caminho mais correto para o desenvolvimento
    acadêmico.
  • Raniere Gaia – Estuda matemática aplicada na
    Universidade Estadual de Campinas, e trabalha em alguns projetos de nível
    internacional. Faz contribuições para Mozilla, e é um membro mantenedor do
    Software Carpentry.

Requerimentos

Para participar da oficina voce precisa de um computador portátil
com alguns softwares instalados.
Idealmente, um computador com algum tipo Unix (Ubuntu, Fedora, OSX) é melhor
para o desenvolvimento na opinião do autor da página.
Veja
discussões
.
Além disso, os instrutores não tem o conhecimento para dar suporte completo no
Windows (Aceitamos voluntários).
(Nota: Teremos alguns computadores com sistema operacional Windows disponíveis,
mas não teremos tempo para testar todos, ou instalar tudo que julgamos
essencial).

Softwares que você precisa

  • Bash
    • No GNU/Linux, o Bash já deve estar instalado.
      Procure pelo terminal ou console no seu sistema. Quando ele abrir,
      digite

      bash --version
      

    Uma mensagem deve aparecer indicando qual versão está instalada.

    • No OSX, o terminal padrão também é o Bash. Você pode acessar pelo
      /Applications/Utilities/. Dica: coloque o terminal no dock.

    • No Windows existem algumas opções,
      uma delas é o Git Bash, que você já usa para o
      Git também.

  • Git
    • No Windows, instale o Git Bash, que falei
      acima.
      Nota: Uma das opções da instalações é sobre o fim de linha (line
      ending). Escolha a opção de seguir o padrão Unix (ou algo parecido).

    • No OSX, você pode instalar o Git para Mac baixando um instalador
      aqui.

    • Num computador tipo Unix, siga as instruções.
      Teste que o git foi instalado fazendo

      git --version
      

      no seu terminal.

  • Julia: Siga as instruções.
    Para testar, verifique que o Julia foi instalado abrindo o terminal de
    Julia, e verificando que o texto introdutório contém Version 0.x.x.

  • Um editor de texto, preferencialmente com suporte a UTF-8, código colorido
    automaticamente, indentação automática e inclusão de espaços no lugar de
    TAB. Existem algumas opções, e se você não tem preferência nenhuma, o
    atom.io é um bom para começar. Se for usá-lo,
    recomendamos buscar pelo pacote language-julia.

Certifique-se de ter essas ferramentas instaladas ANTES do evento. Entre em
contato em caso de dúvidas.

Inscrições

As inscrições estão fechadas. Caso tenha interesse em participar, me mande um
e-mail para confirmar se ainda temos vagas.

Cronograma

O evento acontecerá no dia 30 de Maio de 2015, seguindo o cronograma abaixo:
(Nota: Mudamos o horário de Julia para melhor acomodar o cronograma).

  • 08:00 : Abertura
  • 08:30 : Bash (com Raniere)
  • 09:30 : Coffee Break
  • 10:00 : Julia (com Abel)
  • 11:30 : Almoço
  • 13:30 : Git Local (com Abel)
  • 15:00 : Coffee Break
  • 15:30 : Git Remoto (com Raniere)

Local

Utilizaremos o Laboratório de Matemática e Desenho (LAMADE) no bloco PC, sala
PC12.

Apresentação no VII Simpósio de Análise Numérica e Otimização – UFPR

By: Abel Soares Siqueira

Re-posted from: http://abelsiqueira.github.io/apresentacao-no-vii-simposio-de-analise-numerica-e-otimizacao-ufpr/

No dia 24 de Fevereiro de 2015 aconteceu o (primeiro dia do) VII Simpósio de
Análise Numérica e Otimização.
Participei deste congresso fazendo uma apresentação sobre
Ferramentas Computacionais para
Pesquisadores

(ver código).

Nesta apresentação, introduzo algumas ferramentas que considero bastante
importantes para pesquisadores, principalmente da área de matemática
computacional.
Um resumo do que apresento é

  • Aprenda outras linguagens. Recomendo, por exemplo, conhecer Python ou Ruby,
    Shell e Makefile. Com essas ferramentas já é possível automatizar testes e
    fazer scripts com uso variado. Makefile, por exemplo, é uma das maneiras
    mais usadas de se instalar programas (no Unix).
  • Conheça a linguagem Julia.
    É uma linguagem com foco na matemática computacional, considerando ainda que
    você irá querer utilizar código em C e Fortran, e com sintaxe parecido com a
    de MatLab/Octave. É uma linguagem nova, mas tem potencial para ser o próximo
    concorrente do MatLab/Octave, e é livre.

    • Dentro do Julia, conheça o JuliaOpt, que é
      um grupo que está desenvolvendo ferramentas de otimização em Julia.
      Desde interfaces para softwares conhecidos, até linguagens de modelagem,
      passando por implementações de métodos de otimização não-linear, tanto
      puramente em Julia, quanto utilizando códigos de baixo nível.
    • Também anunciei que estamos trabalhando no
      CUTEst.jl, uma interface para o
      CUTEst.
  • Escolha um editor e um ambiente de desenvolvimento.
    Sugiro ver algumas opções (Vim, Emacs, Atom, Sublime Text, Eclipse), testar,
    e ver qual combina mais com você. Em adição, conheça o Sharelatex e/ou o
    Writelatex.
  • Conheça o perprof-py,
    que é uma ferramenta para gerar perfis de desempenho, com gráficos de alta
    qualidade.
  • Conheça o git, que é uma ferramenta para controle de
    versão, que você pode usar sozinho; ou em grupo; fazer ramificações;
    verificar versões anteriores; misturar versões; trabalhar online; dentro
    outras.

    • Conheça o GitHub, que é um site onde você pode
      colocar o código que foi feito com git.
    • Conheça o Travis CI, que é um serviço que baixa
      seu código do GitHub e roda testes (definidos por você) nele, sempre que
      você subir o seu código.
    • Conheça o Coveralls.io, que é um serviço que
      verifica seus testes e diz que parte do seu código foi verificado, e qual
      não foi.
  • TikZ e PgfPlots do Latex: Comentei um pouco sobre gráficos usando esses
    pacotes, e mostrei alguns exemplos.

Também falei sobre o Software Carpentry,
que é uma organização sem fins lucrativos que realiza workshops e promove
conhecimento mundialmente. Comentei também sobre o trabalho do
Raniere Silva no Software Carpentry, e do
trabalho que ele está
propondo
para os próximos meses.

Algumas boas perguntas foram feitas, e gostaria de parafraseá-las e
atualizar minha resposta para algumas delas.

  • Por que sair do MatLab para o Julia?
    Recomendo sair do MatLab porque ele é um software proprietário, pra começar.
    Mas desconsiderando isso, e também considerando o Octave, dou a seguinte
    resposta: O Julia está sendo desenvolvido com o intuito de substituir o
    MatLab, sabendo que o matemático computacional costuma fazer código que
    precisa de velocidade em C ou Fortran.
    A interface para C e Fortran em Julia é consideravelmente fácil,
    e isso facilita o processo de criar um código que você vê que funciona, e
    posteriormente otimizá-lo.
    Gostaria de acrescentar a ressalva que Julia é uma linguagem nova, e
    obviamente não tem tudo que gostaríamos implementado. Seu código pode
    quebrar. Mas vale a pena conhecer para saber se vale investir.
  • Por que sair do Python para o Julia?
    Não sei se você deve. O Python básico não é suficiente para um matemático
    computacional, mas eu sei que existem vários pacotes que conseguem deixar o
    Python muito eficiente para Análise Numérica e Otimização. Também é possível
    fazer uma transição C com Python, mas não conheço, logo não posso julgar.
    Atualmente, provavelmente, o Python parece ser mais eficiente.
    E já que estamos aqui, se você conseguir tirar alguém do MatLab para o
    Python, já é uma vitória.
  • Por que usar o TikZ/PgfPlots no lugar desta outra ferramenta de
    gráficos?

    Se for o MatLab, vide meu rant anterior sobre MatLab ser proprietário.
    Para outras ferramentas, não sei. Muitas ferramentas fazem um trabalho, no
    mínimo, tão bom quanto o TikZ/PgfPlots, e.g., o MatplotLib (que
    usamos no perprof, junto com o PgfPlots).
    Uma coisa que eu gosto é misturar com o Beamer, gerando figuras iterativas
    (não interativas).
    Então, alguns comandos podem ser misturados para fazer uma sequência de
    figuras que o Beamer vai descobrindo (por exemplo o caminho de um
    algoritmo).
  • Se fosse para você escolher apenas uma dessas ferramentas para
    recomendar, qual seria?

    Sem dúvida o git, que é útil para qualquer área onde você escreve código, ou
    até mesmo um artigo em .tex (ou outros formatos binários de texto).
    Você nunca sabe quando vai precisar voltar numa versão anterior do código.
    Por exemplo, você faz atualizações no seu código, e alguém diz que estava
    usando o seu código antes, mas depois que essa pessoa atualizou, o código
    parou de funcionar.
    Bem, como fazer pra saber o que quebrou o código? Se você está fazendo o
    controle corretamente, você terá vários commits indicando o trabalho
    feito. Você pode navegar nesses commits e descubrir a última versão que
    funcionava. Assim você reduz consideravelmente a quantidade de código que
    pode ter estragado o seu pacote.
    Além disso, você pode trabalhar com versões paralelas, colaborativamente, e
    ainda aproveitar de serviços fantásticos para quem usa git (GitHub, Travis,
    Coveralls).

É importante ficar claro que eu não estou apresentado as melhores ferramentas
para seus respectivos objetivos, apenas aquelas que eu conheço e que podem
resolver o problema. Talvez alguma ferramenta seja melhor do que a que eu
apresentei, mas o ponto é você conhecer alguma ferramenta, e às vezes conhecer
alguma nova.