Continuando o Guia Latex, vamos aprender a colorir e colocar imagens em documentos LaTeX.

Coloração

Começaremos pela coloração, já que essa é uma parte muito mais simples e já acrescenta um grande diferencial ao texto.

Para podermos usar o pacote com as cores, precisamos importá-lo. Usaremos para texto, o seguinte pacote:

\usepackage[pdftex]{color,graphicx}

E para as tabelas…
\usepackage{colortbl}
\usepackage[table]{xcolor}

Excelente. Com esses pacotes à disposição, já podemos usar o comando para colorir o texto:

\textcolor{cor}{texto a ser colorido}, onde a variável cor é uma cor escrita em inglês.

red	blue
cyan	yellow
orange	gray
teal	green

Colocando imagens

Muitos tutoriais de LaTeX passam a sensação de que toda imagem tem que estar dentro de um ambiente “figure”. Vamos deixar bem claro, logo de cara, que esse é apenas um environment que favorece colocar imagens, em uso geral - podemos colocar legendas facilmente nele.

Para usarmos imagens, precisamos dos pacotes que lidam com elas:
\usepackage{graphicx}

E, no mais, de apenas um simples comando:

\includegraphics[opções]{imagem.png}

As opções são quatro e podem ser usadas conjuntamente, separadas por vírgulas (e não espaços):

• width: corresponde à largura;
• height: a altura da sua imagem;
• scale: proporção do tamanho real da imagem.
• angle: ângulo de rotação da imagem (sentido anti-horário);

O formato da imagem pode ser jpg, png, pdf e algumas outras menos comuns. Outros pacotes, como o graphics, têm suporte a outros formatos.

Ambiente figure

Como mencionei mais cedo, o modo mais comum de vermos imagens apresentadas em LaTeX é num ambiente figure. Por que isso acontece?

Esse ambiente procura o melhor lugar para se encaixar numa página, flutuando texto para cima ou para baixo conforme melhor disposição, seguindo, claro, uma heurística própria que infelizmente eu desconheço. Figure também possui uma tag própria de legenda, chamada caption.

\begin{figure}
\includegraphics[width=0.5\textwidth]{imagem.jpg}
\caption{Minha imagem em latex}
\end{figure}

Com isso, você já é capaz de tratar figuras em LaTeX e colorir seu texto. Se restou alguma dúvida sobre esse assunto, incentivo perguntas - muito foi deixado de lado nesse breve tutorial. Divirtam-se!

Posts Relacionados:

Guia Linux - Parte IV: Aplicativos

Guia Latex - Parte III: Estruturando e marcando o texto

Guia Latex - Parte II: O Básico

Gentoo no Summer of Code

Guia Latex - Parte I: O que é e por que usar

Séries

Quer trabalhar na Google?

Assine nosso RSS feed!

Após um período de recesso, o Guia Latex segue. Dessa vez, veremos marcação de texto básica e as maneiras mais comuns e simples de se estruturar uma página, com seções e subseções, listas e, por fim, tabelas.

Marcação de texto

Em LaTeX, é possível fazer todas as marcações de texto com as quais vocês está acostumado.

Negrito:	\textbf{termo em negrito}
Itálico:	\textit{termo em itálico}ou similar: \emph{termo enfatizado}
Monospace:	\texttt{termo em monospace} (letra de máquina de escrever)
Serifado:	\textsf{termo em letras serifadas}
Maiúsculas	\textsc{termo em SmallCaps} (letras maiúsculas, diferenciadas pelo tamanho)

Também podemos alterar o tamanho da fonte. Algumas das possibilidades de tamanho são:

Muito pequena:	\tiny
Pequena:	\small
Normal:	\normalsize
Grande:	\Large
Muito Grande:	\LARGE
A maior:	\Huge

Estruturando o texto

O LaTeX é uma excelente ferramenta para criar textos bem estruturados e confortáveis de se ler. Para facilitar esse processo, dispomos de alguns comandos:

Seção:	\section{Nome da seção}
Subseção:	\subsection{Nome da subseção}
Subsubseção:	\subsubsection{Nome da subseção da subseção}

Listas

Ainda, é bastante útil saber fazer listas. As listas abrem um ambiente próprio que contém e sabe entender o comando \item. Este, por sua vez, recebe o texto de um ítem da lista.

Para fazer uma lista com os pontos de marcação padrão (as bolinhas) use:

\begin{itemize}
\item{Um ítem}
\item{Outro ítem}
…
\item{Último ítem}
\end{itemize}

Já para criar uma lista numerada, usamos o ambiente enumerate:

\begin{enumerate}
\item{Primeiro ítem}
\item{Segundo ítem}
…
\item{N-ésimo ítem}
\end{enumerate}

Tabelas

Tabelas são velhas conhecidas e tidas como problemáticas por usuários mais antigos de Tex e LaTeX. A razão da má fama é proveniente do ambiente table, que é um corpo flutuante. Isso significa que, se não houver espaço para uma tabela do tipo table na página, ela não hesita em passar o texto seguinte para preencher o espaço em branco e se posicionar alguns parágrafos abaixo.

Se isso não lhe parece terrível, é porque você nunca teve esse problema. Seu texto fica extremamente confuso quando uma tabela de referência vai parar 3 parágrafos abaixo, onde ela julgou que cabe.

Para não ter esse tipo de inconveniente, foi criado, para LaTeX, um ambiente novo não-flutuante chamado tabular. A seguir, um exemplo de como fazer uma tabela nesse ambiente:

\begin{tabular}[opções de alinhamento]{| alinhamento da primeira coluna | alinhamento da segunda coluna |}
\hline
conteúdo da 1a. linha, 1a. coluna & conteúdo da 1a. linha, 2a. coluna \\
\hline
conteúdo da 2a. linha, 2a. coluna & conteúdo da 2a. linha, 2a. coluna \\
\hline
…
conteúdo da Na. linha, 1a. coluna & conteúdo da Na. linha, 2a. coluna \\
\hline
\end{tabular}

As opções de alinhamento são quatro:

l (L minúsculo)	Alinhamento à esquerda
c	Alinhamento centralizado
r	Alinhamento à direita
p{2.7cm}	Justificado com tamanho de célula indicado entre {}

As barras verticais indicam as linhas verticais da tabela. Mas atenção: elas são necessárias no começo e no fim da definição das colunas. Se você não colocá-las ali, sua tabela não vai ter as bordas laterais exteriores.

Similarmente, as linhas que recebem somente \hline servem para fazer as linhas horizontais da tabela. Assim, é importante colocá-las a cada vez que você desce para a próxima linha e, se quiser as bordas inferior e superior externas, antes da primeira linha e depois da última.

Pronto! Agora você já tem todas as ferramentas que precisa para escrever 90% dos textos com os quais você vai se deparar. Experimente tranformar seu último texto escolar ou relatório do trabalho em LaTeX e veja a qualidade da saída em .pdf.

Na próxima parte desse tutorial, veremos como colocar imagens em latex, importando ou construindo-as programativamente, direto em LaTeX.

Posts Relacionados:

Guia Latex - Parte IV: Estética (imagens e coloração)

Guia Latex - Parte II: O Básico

Séries

Guia Linux - Parte IV: Aplicativos

Guia Latex - Parte I: O que é e por que usar

Gentoo no Summer of Code

UTF-8 no Latex

Assine nosso RSS feed!

Continuando o tutorial, vamos começar agora o feijão-com-arroz da programação. Programação nada mais é do que controlar o fluxo de forma inteligente, para obter os resultados esperados. No próximo post vamos ver os dois controles mais simples, If e Else. Mas antes você precisa saber o que é

Condição Booleana e Operadores Booleanos

Uma condição booleana é uma expressão (lembram de expressões numéricas?) que resultam em um valor verdadeiro ou falso. Em C, como não existe um tipo booleano, a seguinte representação é usada:

1. Se um número é diferente de 0, ele é considerado um valor verdadeiro;
2. Se é igual a zero, é falso.

Isso significa que 3 + 2 é verdadeiro em C, mas 4 - 4 não.

Mas não é apenas dessa forma que fazemos operações booleanas. Existem outros operadores que servem para concatenar (ou modificar) condições booleanas. São os operadores booleanos.

Os operadores mais comuns são:

1. Operador “E” (&&): Apenas diz que a expressão é verdadeira se as duas condições ao lado dele forem verdadeiras;
2. Operador “Ou” inclusivo (||): Diz que uma expressão é verdadeira se uma das duas condições for verdadeira;
3. Operador “Não” (!): Diz que uma condição é verdadeira se a condição à qual ele é aplicado for falsa e vice-versa.

Chega de teoria. Basicamente o que acontece é o seguinte:

2+3 && 5 é verdadeiro
2+3 && 0 é falso
2+3 && 4 é verdadeiro
2+3 || 0 é verdadeiro
2+3 || 1 é verdadeiro
2-2 || 1-1 é falso
!0 é verdadeiro
!1234567 é falso
(0 && 0) || 1 é verdadeiro

Notem que se você ler o que está escrito (sabendo que 0 é falso e os outros números são verdadeiros) fica bem intuitivo:

verdadeiro E verdadeiro é verdadeiro
verdadeiro E falso é falso
(falso E falso) ou verdadeiro é verdadeiro
NÃO falso é verdadeiro

Certo… tirando o último exemplo não é tão intuitivo assim mas você se acostuma.

Se você fizer todas as comparações possíveis usando duas condições e um operador você chega as seguintes tabelas:

Operador E (&&)
&&	verdadeiro	falso
verdadeiro	verdadeiro	falso
falso	falso	falso

Operador Ou (||)
||	verdadeiro	falso
verdadeiro	verdadeiro	verdadeiro
falso	verdadeiro	falso

Operador Não (!)
!	verdadeiro	falso
	falso	verdadeiro

Existe um outro operador, chamado Ou Exclusivo. As expressões formadas por ele são verdadeiras se uma única condição (das duas em volta dele) for verdadeira. Se as duas forem verdadeiras ou falsas a expressão é falsa. Ele não costuma ser muito utilizado (só usei ele pra criptografia e mesmo assim era um operador um pouquinho diferente.

Posts Relacionados:

Dia C - Tuning

TRUE & TRUE == FALSE ?

YACP - Variáveis e Tipos Primitivos

YACP - Aprendendo a usar suas ferramentas

YACP (Yet Another C Primer)

YACP - Definindo seus próprios tipos

Assine nosso RSS feed!

C possui suporte a definição de novos tipos, o que torna o código muitas vezes mais legível e conciso. É possível criar esses novos tipos com typedef, struct, enum e union.

Typedef

Typedef serve para você mudar o nome de um tipo. Parece meio inútil mas na verdade ajuda muito com a semântica do código. Por exemplo, você decide que precisa de um tipo para guardar dinheiro. Float não serve, porque pode dar erros de precisão (faça o teste com R$0.30 . É uma dízima periódica em binário e pode gerar resultados estranhos). Então você percebe que se guardar o dinheiro contando os centavos (1 real = 100 centavos) você não vai ter problemas de precisão, pois você sabe que os postos de gasolina não podem colocar aquele terceiro digito depois da vírgula, pois não existe milésimo de real.

Então você vai lá e declara dinheiro como int. Pronto. Seu sistema funciona e você fica feliz, mas chamar seu dinheiro de int é meio feio e não faz muito sentido semanticamente. Como resolver isso? Você cria um novo tipo chamado dinheiro com o typedef:

typedef int dinheiro;/*cria o tipo dinheiro*/</code> dinheiro d; /*não tem a ver com a definição do tipo.*/ /*Coloquei só pra exemplificar*/

Agora você armazena seu dinheiro em um tipo dinheiro. Muito mais legível, certo?

Struct

Struct é uma forma de você agrupar diversos tipos dentro de um único, e acessá-los de forma individual. Na minha opinião é o recurso mais poderoso para definição de novos tipos. É muito bom para juntar informações relevantes e colocá-las em um único lugar de facil manipulação.

struct nome_struct { tipo1 nome1; tipo2 nome2; . . . tipoN nomeN; }

Para acessar qualquer tipo que esteja dentro da struct, use o operador “.”:

Minhastruct.nome1;

E você usa como uma variável qualquer. Simples, não? Nem tanto. A sintaxe de declaração de uma variavel do tipo struct é meio chata. Você precisa dizer que aquilo é uma struct:

struct nome_struct minhaStruct;

É aqui que entra a verdadeira mágica do typedef. Bem agora que você estava quase acreditando que a melhor utilidade do typedef é mudar o nome de um tipo primitivo.

Se você criar um tipo para representar “struct nome_struct”, fica bem mais fácil de declarar:

typedef struct nome_struct novo_nome;

Geralmente isso já é feito quando declaramos a struct:

typedef struct nome_meio_inutil { tipo1 nome1; . . . tipoN nomeN; } nome_real;

O resto é igual, mas você usa o nome real pra declarar.

typedef struct _retangulo { double lado; double altura; } retangulo;</code> retangulo r; double area; r.lado = 4.0; r.altura = 3.1415; area = r.lado * r.altura;

Enum

Enum cria um tipo que pode apenas receber valores específicados durante a sua criação. Por exemplo:

enum {janeiro, fevereiro, marco, abril, maio, junho, julho, agosto, setembro, outubro, novembro, dezembro };

Mas como isso funciona? Cada posição recebe um valor (a partir de 0 e incrementando para cada posição) e se você colocar um valor que seja diferente desses o compilador gera um erro (ou talvez um warning). O problema é que esse nosso tipo não tem nome e sempre que você for usar você precisa colocar toda essa linha de código para declarar uma variavel:

enum {janeiro, fevereiro, marco, abril, maio, junho, julho, agosto, setembro, outubro, novembro, dezembro } meses;

Novamente somos salvos pelo typedef:

typedef enum { janeiro, fevereiro, marco, abril, maio, junho, julho, agosto, setembro, outubro, novembro, dezembro } mes;</code> mes m = 8;/*setembro*/ m = m + 1;/*outubro*/ m = novembro;/*10*/

A parte mais legal é que aumenta a legibilidade do código, pois é muito mais elegante você verificar se o mês é janeiro do que verificar se ele é 0.

Também é possível mudar o valor inicial do enum, atribuindo para o primeiro elemento um valor inteiro:

typedef enum { algo=1800, sim, nao, sou, muito } criativo;</code> criativo c; c = algo; c = c + 1;/*sim*/ c = muito;/*1804*/

Union

Union é uma forma de você colocar diversos tipos em uma única variável. Um conceito interessante, mas que eu não vejo ser usado com muita frequência (Usei apenas uma vez e poderia ter feito de uma forma que evitasse isso). A sintaxe de declaração é bem semelhante à struct:

typedef union nome_meio_inutil { int i; float f; char c; }minha_union;</code> minha_union m;

Já declarei com o typedef, mas se não tivesse feito isso, teria que escrever union antes da declaração, como acontece com struct.

Para utilizar, é basicamente como o struct. Possui apenas uma diferença (fundamental). Ela guarda apenas um dos valores por vez. Portanto, se você armazenar algo em m.i e depois em m.f, o valor de m.i será sobrescrito.

minha_union m; m.i = 10; m.f = 9.0;/*O valor de m.i foi sobrescrito*/

E cuidado com a leitura dos valores. Se você gravar em m.f e ler com m.i, você receberá um valor que não apresenta sentido, pois o union não faz conversão entre os tipos que você coloca nele.

minha_union m; m.f = 11.5; printf("%d\n", m.i);/*vai imprimir algum valor estranho*/

A única vez que usei essa estrutura foi quando estava fazendo um leitor de arquivos .ini . Convencionei que poderiam existir apenas 3 tipos dentro do ini (string, inteiro e float) e criei um union para representar isso. Mesmo assim ainda precisava de 2 bits pra armazenar qual tipo eu tinha lido, porque o union não mantém essa informação.

Posts Relacionados:

YACP - Variáveis e Tipos Primitivos

Linguagens de programação - C++

YACP (Yet Another C Primer)

YACP - Condições Booleanas

Linguagens de programação - Smalltalk

Guia Latex - Parte II: O Básico

SNL - A Arte da Guerra

Assine nosso RSS feed!