Montar a seguinte interface gráfica
Fazer um programa para somar dois números reais, limpar os dados e sair.
Utilize a função FormatFloat que utiliza dois parâmetros, sendo o primeiro a máscara de formatação e o segundo o valor a ser formatado. O valor formatado é transformado em uma string.
A máscara de formatação que será utilizada é a seguinte ('#,##0.00'), onde
# (tralha) estabelece a supressão de valores zerados, quando eles existirem;
, (vírgula) estabelece a separação de milhares (notação norte-americana);
. (ponto) estabelece a separação do ponto para casas decimais (notação norte-americana).
Exemplos de exibição para o número 2.546,58 e o número 44,32:
0,000.00 exibirá 2,546.58 e 0,044.32
#,##0.00 exibirá 2,546.58 e 44.32
Observe que a utilização de máscaras de formatação possibilita a especificação de três formatos diferentes simultaneamente, separados por ponto-e-vírgula. Com isso é possível ter uma máscara para valores positivos, negativos e zeros. Verifique no código seguinte.
O código encontra-se abaixo:
=================================================
procedure TForm1.Button1Click(Sender: TObject);
var a,b,soma: real;
begin
if ((edit1.text='') or (edit2.text=''))
then showmessage('Favor preencher os dois números!')
else
begin
a := strtofloat(edit1.text);
b := strtofloat(edit2.text);
soma := a + b;
label1.caption := formatfloat('#,##0.00;(#,##0.00); zerado', Soma);
end;
end;
procedure TForm1.Button2Click(Sender: TObject);
begin
edit1.text := '';
edit2.text := '';
label1.caption := '';
edit1.setfocus;
end;
procedure TForm1.Button3Click(Sender: TObject);
begin
Close;
end;
=================================================
Faça o seguinte programa:
1 – obter o valor para a variável HT (horas de trabalho no mês);
2 – obter o valor para a variável VH (valor da hora trabalhada);
3 – obter o valor para a variável PD (percentual de desconto);
4 – Calcular o salário bruto (SB): SB = HT x VH;
5 – Calcular o total de desconto (TD): TD = (PD/100) x SB;
6 – Calcular o salário líquido (SL): SL = SB – tudo;
7 – Apresentar o valor do salário líquido: SL.
Referência
MANZANO, José Augusto Navarro Garcia; MENDES, Sandro Santa Vicca. Estudo dirigido de Delphi 7. São Paulo: Érica, 2003.
computação vou aprendendo GNU Linux Debian PostgreSQL pgAdmin QT Ubuntu C R Pascal Lazarus Solver . . .
sexta-feira, 14 de setembro de 2012
terça-feira, 4 de setembro de 2012
Lazarus - Entrada e saída de dados numéricos
Entrada e saída de dados numéricos
Dados numéricos são apresentados sob o tipo caracteres (string);
Antes de serem repassados ao programa, esses dados numéricos devem ser transformados de caracteres para numérico. E o contrário, quando forem apresentados no formulário;
As funções do FPL que fazem essas tarefas são:
StrToFloat e StrToInt – Transforma de caractere (string) para numérico (real e inteiro respectivamente).
FloatToStr e IntToStr - Transforma de numérico (real e inteiro respectivamente) para caractere (string).
Entrada e saída com tipo de dado inteiro
Monte a seguinte interface gráfica para somar dois números inteiros
Dê um duplo clique no botão Somar e digite o código
--------------------------------------------------------------------
procedure TForm1.Btn1Click(Sender: TObject);
Var a, b, r : integer;
begin
a := strtoint(Edt1.text);
b := strtoint(Edt2.text);
r := a + b;
Lbl4.caption := inttostr(r);
end;
--------------------------------------------------------------------
Basta executar (F9) e testar.
Referência
MANZANO, José Augusto Navarro Garcia; MENDES, Sandro Santa Vicca. Estudo dirigido de Delphi 7. São Paulo: Érica, 2003.
Dados numéricos são apresentados sob o tipo caracteres (string);
Antes de serem repassados ao programa, esses dados numéricos devem ser transformados de caracteres para numérico. E o contrário, quando forem apresentados no formulário;
As funções do FPL que fazem essas tarefas são:
StrToFloat e StrToInt – Transforma de caractere (string) para numérico (real e inteiro respectivamente).
FloatToStr e IntToStr - Transforma de numérico (real e inteiro respectivamente) para caractere (string).
Entrada e saída com tipo de dado inteiro
Monte a seguinte interface gráfica para somar dois números inteiros
Dê um duplo clique no botão Somar e digite o código
--------------------------------------------------------------------
procedure TForm1.Btn1Click(Sender: TObject);
Var a, b, r : integer;
begin
a := strtoint(Edt1.text);
b := strtoint(Edt2.text);
r := a + b;
Lbl4.caption := inttostr(r);
end;
--------------------------------------------------------------------
Basta executar (F9) e testar.
Referência
MANZANO, José Augusto Navarro Garcia; MENDES, Sandro Santa Vicca. Estudo dirigido de Delphi 7. São Paulo: Érica, 2003.
quarta-feira, 22 de agosto de 2012
Ordenação de vetores dançando (bubble, insertion, quick)
Criado em Sapientia, uma instituição de ensino superior húngaro na região histórica da Transilvânia, Romênia.
Método bubble-sort:
Método insertion-sort:
Método quick-sort:
domingo, 19 de agosto de 2012
Lazarus - Primeiros programas em FPL (Free Pascal Lazarus)
Primeiro programa em FPL em ambiente console
Para criar um programa em ambiente console basta clicar nos seguintes:
File / New... / Project / Program
Aparecerá uma janela:
Save changes new project ..............
Clique em No
Basta digitar o código
Para compilar basta digitar:
Ctrl + F9
Para executar basta digitar:
F9
Primeiro programa em FPL em ambiente de janela
Primeiramente é bom fechar os projetos que porventura estejam abertos:
File / Close all editor files
Criando uma nova aplicação em ambiente de janelas
File / New / Project / Application
Save changes to...
Clique em No
Faça o seguinte programa para o algoritmo:
– Ler um nome fornecido pelo teclado
– Preparar a apresentação do nome
– Apresentar o nome
Para isso utilize:
– um Form
– um Edit
– um Button
– um Label
Para inserir um determinado componente no formulário, basta dar um clique com o ponteiro do mouse sobre o componente escolhido, depois posicionar o ponteiro do mouse sobre o formulário Form1 e dar um outro clique
Observar que:
– os componentes inseridos (Form, Edit, Button e Label) ficam visíveis na janela Object Inspector
Form: é o formulário, a "base" para os outros componentes, ou seja, a janela onde o programa será criado
Edit: permite a entrada (e a exibição) de textos e valores
Label: permite a exibição de textos e valores
Button: é um botão que o usuário pode pressionar para iniciar uma ação no aplicativo. Para o programador criar o código referente aquele botão basta dar um duplo clique sobre o mesmo no ambiente de programação
Os componentes Button e Label possuem propriedade Caption
O componente Edit possui propriedade Text
As propriedades Caption e Text desses componentes são similares
Propriedade Name: faz referência ao nome físico da propriedade (“razão social”)
Propriedade Caption: faz referência ao nome virtual da propriedade (“nome fantasia”)
Propriedade Text: "similar" à propriedade caption, faz referência ao conteúdo do componente edit
Alterar a propriedade Name dos componentes
Name do Formulário = Frm1
Name do Edit = Edt1
Name do Button = Btn1
Name do Label = Lbl1
Alterar a propriedade Caption dos componentes
Caption do Formulário = Escrever
Caption do Button = Ok
Caption do Label =
Alterar a propriedade Text do componente
Text do Edit =
Programando o botão Ok:
– duplo clique no botão Ok
– inserir o código:
lbl1.caption := edt1.text;
Compilar: Ctrl + F9
Rodar: F9
Digite valores no edite do executável e clique no botão ok para testar
Salvar da seguinte forma:
– crie uma pasta
– salve nesta pasta criada
– primeiro arquivo: Nome.lpi
– segundo arquivo: u_nome.pas
Para abrir basta ir até a pasta onde foi salvo
– dê um duplo clique no arquivo: Nome.lpi (Lazarus Project Information)
Abrirá o projeto com a unit u_nome.pas
Faça o seguinte programa para o algoritmo:
– ler o nome
– ler o sobrenome
– concatenar o nome com o sobrenome
– um botão para apresentar o nome completo
– um botão para limpar o nome completo (edit e label)
Para isso construa o formulário como segue
O formulário ficará da seguinte forma:
Programando o botão Concatenar, basta dar um duplo clique sobre o botão concatenar e inserir o código abaixo:
---------------------------------------------------------------------
Procedure Tform1.Button1Click(sender: TObject);
Begin
Label3.Caption := Edit1.Text+' '+Edit2.Text;
End;
---------------------------------------------------------------------
Programando o botão Limpar, basta dar um duplo clique sobre o botão limpar e inserir o código abaixo:
---------------------------------------------------------------------
Procedure Tform1.Button2Click(Sender: TObject);
Begin
Edit1.Text := ' ';
Edit2.Text := ' ';
Label3.Caption := ' ';
Edit1.SetFocus;
End;
---------------------------------------------------------------------
Referências
MANZANO, José Augusto Navarro Garcia; MENDES, Sandro Santa Vicca. Estudo dirigido de Delphi 7. São Paulo: Érica, 2003.
MELO, Evandro de Castro. Free Pascal Lazarus, Ambiente Windows. Apostila da UFV. ENG 390 Prof. Evandro de Castro Melo, DS.
Para criar um programa em ambiente console basta clicar nos seguintes:
File / New... / Project / Program
Aparecerá uma janela:
Save changes new project ..............
Clique em No
Basta digitar o código
Para compilar basta digitar:
Ctrl + F9
Para executar basta digitar:
F9
Primeiro programa em FPL em ambiente de janela
Primeiramente é bom fechar os projetos que porventura estejam abertos:
File / Close all editor files
Criando uma nova aplicação em ambiente de janelas
File / New / Project / Application
Save changes to...
Clique em No
Faça o seguinte programa para o algoritmo:
– Ler um nome fornecido pelo teclado
– Preparar a apresentação do nome
– Apresentar o nome
Para isso utilize:
– um Form
– um Edit
– um Button
– um Label
Para inserir um determinado componente no formulário, basta dar um clique com o ponteiro do mouse sobre o componente escolhido, depois posicionar o ponteiro do mouse sobre o formulário Form1 e dar um outro clique
Observar que:
– os componentes inseridos (Form, Edit, Button e Label) ficam visíveis na janela Object Inspector
Form: é o formulário, a "base" para os outros componentes, ou seja, a janela onde o programa será criado
Edit: permite a entrada (e a exibição) de textos e valores
Label: permite a exibição de textos e valores
Button: é um botão que o usuário pode pressionar para iniciar uma ação no aplicativo. Para o programador criar o código referente aquele botão basta dar um duplo clique sobre o mesmo no ambiente de programação
Os componentes Button e Label possuem propriedade Caption
O componente Edit possui propriedade Text
As propriedades Caption e Text desses componentes são similares
Propriedade Name: faz referência ao nome físico da propriedade (“razão social”)
Propriedade Caption: faz referência ao nome virtual da propriedade (“nome fantasia”)
Propriedade Text: "similar" à propriedade caption, faz referência ao conteúdo do componente edit
Alterar a propriedade Name dos componentes
Name do Formulário = Frm1
Name do Edit = Edt1
Name do Button = Btn1
Name do Label = Lbl1
Alterar a propriedade Caption dos componentes
Caption do Formulário = Escrever
Caption do Button = Ok
Caption do Label =
Alterar a propriedade Text do componente
Text do Edit =
Programando o botão Ok:
– duplo clique no botão Ok
– inserir o código:
lbl1.caption := edt1.text;
Compilar: Ctrl + F9
Rodar: F9
Digite valores no edite do executável e clique no botão ok para testar
Salvar da seguinte forma:
– crie uma pasta
– salve nesta pasta criada
– primeiro arquivo: Nome.lpi
– segundo arquivo: u_nome.pas
Para abrir basta ir até a pasta onde foi salvo
– dê um duplo clique no arquivo: Nome.lpi (Lazarus Project Information)
Abrirá o projeto com a unit u_nome.pas
– ler o nome
– ler o sobrenome
– concatenar o nome com o sobrenome
– um botão para apresentar o nome completo
– um botão para limpar o nome completo (edit e label)
Para isso construa o formulário como segue
O formulário ficará da seguinte forma:
Programando o botão Concatenar, basta dar um duplo clique sobre o botão concatenar e inserir o código abaixo:
---------------------------------------------------------------------
Procedure Tform1.Button1Click(sender: TObject);
Begin
Label3.Caption := Edit1.Text+' '+Edit2.Text;
End;
---------------------------------------------------------------------
Programando o botão Limpar, basta dar um duplo clique sobre o botão limpar e inserir o código abaixo:
---------------------------------------------------------------------
Procedure Tform1.Button2Click(Sender: TObject);
Begin
Edit1.Text := ' ';
Edit2.Text := ' ';
Label3.Caption := ' ';
Edit1.SetFocus;
End;
---------------------------------------------------------------------
Referências
MANZANO, José Augusto Navarro Garcia; MENDES, Sandro Santa Vicca. Estudo dirigido de Delphi 7. São Paulo: Érica, 2003.
MELO, Evandro de Castro. Free Pascal Lazarus, Ambiente Windows. Apostila da UFV. ENG 390 Prof. Evandro de Castro Melo, DS.
quarta-feira, 8 de agosto de 2012
Lazarus - Iniciando no Lazarus
Lazarus foi iniciado em fevereiro de 1999. Foi fundada principalmente por três indivíduos: Cliff Baeseman, Shane Miller, Michael A. Hess.
Todos os três tinham tentado se envolver com o projeto de Megido que dissolveu. Na frustração que iniciou o projeto Lazarus. Ele teve um crescimento constante de apoiadores e desenvolvedores durante os anos seguintes.
Dos três fundadores, apenas Michael A. Hess ainda está envolvido com o projeto.
O membro mais antigo próximo da equipe é Marc Weustink. Ele se envolveu com o projeto em agosto de 1999.
Seguindo ele é Mattias Gaertner, que se envolveu em setembro de 2000.
Ambos foram os principais contribuintes para o núcleo do que faz Lazarus assinalar.
Lázarus é a bibliotecas de classes para Free Pascal que emulam Delphi.
O Lazarus é uma alternativa de código aberto (open source) ao Delphi®, com a grande vantagem de ser multiplataforma. Trata-se de um Ambiente Integrado de Desenvolvimento (IDE) com base na linguagem Pascal e no compilador Free Pascal, que há décadas são utilizados no meio acadêmico.
O Free Pascal é um compilador de código fonte aberto com duas notáveis características: um grau elevado de compatibilidade com Delphi e com capacidade para ser executado em Windows, Mac e Linux.
Tanto o Free Pascal como o Lazarus são escritos em Pascal. O código fonte completo está disponível para o compilador Free Pascal e Lazarus.
Lazarus é o nome do ambiente de programação que agrega uma IDE ( Integrated Development Environment – Ambiente de Desenvolvimento Integrado ) com o compilador Free Pascal.
O ambiente de programação Lazarus caracteriza-se por ser uma ferramenta de programação do tipo RAD ( Rapide Application Development – Desenvolvimento Rápido de Aplicações ), em que é possível por meio de interface gráfica, construir aplicações complexas.
O Lazarus pode ser obtido no endereço
http://www.lazarus.freepascal.org
na opção Downloads.
A tela principal do Lazarus é formada por cinco janelas.
Deixando na forma padrão:
File / New … / Project Application / OK
A primeira, localizada no alto do desktop, é chamada de Lazarus IDE v0.9.30.4 – project1.
Esta é a principal janela de controle de projetos e contém o Menu Principal, a Barra de Botões e a Paleta de Componentes.
A segunda, sob a janela do Editor do Lazarus irá aparecer, à esquerda, a janela do Object Inspector. Apresenta os objetos e suas propriedades.
A terceira, à direita da janela do Object Inspector, tem-se a janela Source Edition, na qual o código será montado.
A quarta é a janela Form1, apresenta o local em que a parte visual de uma aplicação será realizada e projetada.
A quinta é a janela Messages, que exibe as mensagens do compilador, erros ou relatórios de progresso no projeto.
Para alterar entre o Form e o Source Edition utiliza-se a tecla F12.
Quando se salva um projeto no ambiente Lazarus, dois arquivos básicos serão gravados no disco, cujas extensões são *.pas (arquivo da Unit) e *.lpi (arquivo do Project).
Mais arquivos serão gravados, mas apenas estes dois requerem que sejam nomeados pelo usuário.
É importante ressaltar que esses dois arquivos devem ter nomes diferentes: isto é uma exigência do compilador.
Salvar um projeto:
File / Save
Nome do primeiro arquivo: Teste.lpi
Nome do segundo arquivo: u_teste.pas
Depois de salvar são gerados mais arquivos
teste.exe – programa principal em formato binário executável.
teste.lpi – Arquivo principal do projeto Lazarus (Lazarus Project Information).
teste.lpr – Arquivo fonte do programa principal no formato Pascal.
testeu.lfm – Desenho do formulário. Este arquivo é utilizado para gerar um arquivo fonte, que está incluído na seção de inicio da Unit.
testeu.pas – Arquivo da Unit que contém o código-fonte do formulário.
Para se declarar variáveis, constantes, procedures e functions de maneira correta em qualquer linguagem, são necessários o conhecimento de sua estrutura e a identificação dos pontos onde elas podem ser declaradas.
Uma Unit é, na maioria das vezes, associada a um formulário (Form) que contém seu código, ou seja, as declarações de variáveis, os componentes utilizados e as rotinas definidas.
É possível verificar que, à medida que componentes são inseridos, são também adicionados automaticamente linhas de código na Unit relacionada. A Unit tem áreas predefinidas e que devem ser respeitadas para que a programação tenha êxito.
unit xxxx – Representa o nome físico do arquivo onde está o código da referida unidade.
Por meio desse nome, units podem usar outras units.
interface – A seção interface começa com a palavra reservada interface e termina no inicio da seção implementation. Nessa seção, são declarados constantes (const), tipos (types), variáveis (var), procedures e functions, que estão disponíveis para outras units ou outros programas. Essas declarações são chamadas de públicas (public), indicando que as mesmas podem ser usadas por quaisquer outras unidades dentro do mesmo programa. A declaração de procedure e function, na seção interface, refere-se apenas ao cabeçalho das mesmas.
Estrutura Básica de uma Unit do Lazarus
uses – É a lista de outras units que estão ligadas ao programa atual.
type – Esta declaração especifica um identificador que denotará um novo tipo que, normalmente, não é oferecido.
var - Nessa área, são declaradas todas as variáveis que podem ser acessadas em qualquer
lugar do programa, portanto, consideradas públicas.
implementation - Esta seção começa com a palavra reservada implementation e termina em initialization. Neste local estão descritas todas as procedures e functions do programa.
{$mode objfpc}{$H+} e {$R *.lfm} – estes códigos são diretivas de compilação, que têm a função de passar informações ao compilador no instante de se criar o arquivo executável do aplicativo.
Estrutura Básica de um Arquivo de Projeto do Lazarus
O arquivo de projeto também é conhecido como Lazarus Project (LPR).
Para visualizar este arquivo:
View / Units... / project1.lpr
begin/end. – estas duas palavras reservadas indicam inicio e fim do projeto.
Application.Initialize; – Inicitialize é o primeiro método chamado pelo arquivo-fonte do projeto que, por padrão, simplesmente inicializa a aplicação.
Application.CreateForm(TForm1, Form1); – cria um objeto formulário da classe TForm1. Aqui são listados todos os formulários criados pela aplicação.
Application.Run; - quando um projeto é criado, o IDE insere automaticamente a linha de código com o método Application.Run, responsável pela execução da aplicação.
Funções (Functions) e Procedimentos (Procedures)
Funções são rotinas que recebem valores, passados como parâmetros, a partir da unidade ou fora dela, e retornam apenas um valor como resultado.
Procedimentos são semelhantes às funções, porém não retornam um valor como parte
de sua definição.
Sintaxe das funções:
Function NomeDaFunção (Parâmetro1: Tipo; ParâmetroN: Tipo): Tipo do valor de retorno;
var {declaração de variáveis locais á função quando necessárias}
begin
{bloco de instruções}
end;
Sintaxe dos procedimentos:
Procedure NomeDoProcedimento (Parâmetro1: Tipo; ParâmetroN : Tipo);
var {declaração de variáveis locais á função quando necessárias}
begin
{bloco de instruções}
end;
Referências
http://www.lazarus.freepascal.org
http://www.lazarus.freepascal.org/index.php/page,7.html
MELO, Evandro de Castro. Free Pascal Lazarus, Ambiente Windows. Apostila da UFV. ENG 390 Prof. Evandro de Castro Melo, DS.
Todos os três tinham tentado se envolver com o projeto de Megido que dissolveu. Na frustração que iniciou o projeto Lazarus. Ele teve um crescimento constante de apoiadores e desenvolvedores durante os anos seguintes.
Dos três fundadores, apenas Michael A. Hess ainda está envolvido com o projeto.
O membro mais antigo próximo da equipe é Marc Weustink. Ele se envolveu com o projeto em agosto de 1999.
Seguindo ele é Mattias Gaertner, que se envolveu em setembro de 2000.
Ambos foram os principais contribuintes para o núcleo do que faz Lazarus assinalar.
Lázarus é a bibliotecas de classes para Free Pascal que emulam Delphi.
O Lazarus é uma alternativa de código aberto (open source) ao Delphi®, com a grande vantagem de ser multiplataforma. Trata-se de um Ambiente Integrado de Desenvolvimento (IDE) com base na linguagem Pascal e no compilador Free Pascal, que há décadas são utilizados no meio acadêmico.
O Free Pascal é um compilador de código fonte aberto com duas notáveis características: um grau elevado de compatibilidade com Delphi e com capacidade para ser executado em Windows, Mac e Linux.
Tanto o Free Pascal como o Lazarus são escritos em Pascal. O código fonte completo está disponível para o compilador Free Pascal e Lazarus.
Lazarus é o nome do ambiente de programação que agrega uma IDE ( Integrated Development Environment – Ambiente de Desenvolvimento Integrado ) com o compilador Free Pascal.
O ambiente de programação Lazarus caracteriza-se por ser uma ferramenta de programação do tipo RAD ( Rapide Application Development – Desenvolvimento Rápido de Aplicações ), em que é possível por meio de interface gráfica, construir aplicações complexas.
O Lazarus pode ser obtido no endereço
http://www.lazarus.freepascal.org
na opção Downloads.
A tela principal do Lazarus é formada por cinco janelas.
Deixando na forma padrão:
File / New … / Project Application / OK
A primeira, localizada no alto do desktop, é chamada de Lazarus IDE v0.9.30.4 – project1.
Esta é a principal janela de controle de projetos e contém o Menu Principal, a Barra de Botões e a Paleta de Componentes.
A segunda, sob a janela do Editor do Lazarus irá aparecer, à esquerda, a janela do Object Inspector. Apresenta os objetos e suas propriedades.
A terceira, à direita da janela do Object Inspector, tem-se a janela Source Edition, na qual o código será montado.
A quarta é a janela Form1, apresenta o local em que a parte visual de uma aplicação será realizada e projetada.
A quinta é a janela Messages, que exibe as mensagens do compilador, erros ou relatórios de progresso no projeto.
Para alterar entre o Form e o Source Edition utiliza-se a tecla F12.
Quando se salva um projeto no ambiente Lazarus, dois arquivos básicos serão gravados no disco, cujas extensões são *.pas (arquivo da Unit) e *.lpi (arquivo do Project).
Mais arquivos serão gravados, mas apenas estes dois requerem que sejam nomeados pelo usuário.
É importante ressaltar que esses dois arquivos devem ter nomes diferentes: isto é uma exigência do compilador.
Salvar um projeto:
File / Save
Nome do primeiro arquivo: Teste.lpi
Nome do segundo arquivo: u_teste.pas
Depois de salvar são gerados mais arquivos
teste.exe – programa principal em formato binário executável.
teste.lpi – Arquivo principal do projeto Lazarus (Lazarus Project Information).
teste.lpr – Arquivo fonte do programa principal no formato Pascal.
testeu.lfm – Desenho do formulário. Este arquivo é utilizado para gerar um arquivo fonte, que está incluído na seção de inicio da Unit.
testeu.pas – Arquivo da Unit que contém o código-fonte do formulário.
Para se declarar variáveis, constantes, procedures e functions de maneira correta em qualquer linguagem, são necessários o conhecimento de sua estrutura e a identificação dos pontos onde elas podem ser declaradas.
Uma Unit é, na maioria das vezes, associada a um formulário (Form) que contém seu código, ou seja, as declarações de variáveis, os componentes utilizados e as rotinas definidas.
É possível verificar que, à medida que componentes são inseridos, são também adicionados automaticamente linhas de código na Unit relacionada. A Unit tem áreas predefinidas e que devem ser respeitadas para que a programação tenha êxito.
unit xxxx – Representa o nome físico do arquivo onde está o código da referida unidade.
Por meio desse nome, units podem usar outras units.
interface – A seção interface começa com a palavra reservada interface e termina no inicio da seção implementation. Nessa seção, são declarados constantes (const), tipos (types), variáveis (var), procedures e functions, que estão disponíveis para outras units ou outros programas. Essas declarações são chamadas de públicas (public), indicando que as mesmas podem ser usadas por quaisquer outras unidades dentro do mesmo programa. A declaração de procedure e function, na seção interface, refere-se apenas ao cabeçalho das mesmas.
Estrutura Básica de uma Unit do Lazarus
uses – É a lista de outras units que estão ligadas ao programa atual.
type – Esta declaração especifica um identificador que denotará um novo tipo que, normalmente, não é oferecido.
var - Nessa área, são declaradas todas as variáveis que podem ser acessadas em qualquer
lugar do programa, portanto, consideradas públicas.
implementation - Esta seção começa com a palavra reservada implementation e termina em initialization. Neste local estão descritas todas as procedures e functions do programa.
{$mode objfpc}{$H+} e {$R *.lfm} – estes códigos são diretivas de compilação, que têm a função de passar informações ao compilador no instante de se criar o arquivo executável do aplicativo.
Estrutura Básica de um Arquivo de Projeto do Lazarus
O arquivo de projeto também é conhecido como Lazarus Project (LPR).
Para visualizar este arquivo:
View / Units... / project1.lpr
begin/end. – estas duas palavras reservadas indicam inicio e fim do projeto.
Application.Initialize; – Inicitialize é o primeiro método chamado pelo arquivo-fonte do projeto que, por padrão, simplesmente inicializa a aplicação.
Application.CreateForm(TForm1, Form1); – cria um objeto formulário da classe TForm1. Aqui são listados todos os formulários criados pela aplicação.
Application.Run; - quando um projeto é criado, o IDE insere automaticamente a linha de código com o método Application.Run, responsável pela execução da aplicação.
Funções (Functions) e Procedimentos (Procedures)
Funções são rotinas que recebem valores, passados como parâmetros, a partir da unidade ou fora dela, e retornam apenas um valor como resultado.
Procedimentos são semelhantes às funções, porém não retornam um valor como parte
de sua definição.
Sintaxe das funções:
Function NomeDaFunção (Parâmetro1: Tipo; ParâmetroN: Tipo): Tipo do valor de retorno;
var {declaração de variáveis locais á função quando necessárias}
begin
{bloco de instruções}
end;
Sintaxe dos procedimentos:
Procedure NomeDoProcedimento (Parâmetro1: Tipo; ParâmetroN : Tipo);
var {declaração de variáveis locais á função quando necessárias}
begin
{bloco de instruções}
end;
Referências
http://www.lazarus.freepascal.org
http://www.lazarus.freepascal.org/index.php/page,7.html
MELO, Evandro de Castro. Free Pascal Lazarus, Ambiente Windows. Apostila da UFV. ENG 390 Prof. Evandro de Castro Melo, DS.
sexta-feira, 3 de agosto de 2012
Lazarus - Resolvido problema instalar Lazarus no Linux - Debian (lgdk_pixbuf-2.0, gtk, libgtk)
Para instalar o Lazarus do Debian 6.0.6 basta fazer da seguinte forma: entrar como superusuário e instalar normalmente:
:~$ su
Senha
# apt-get install lazarus
Pronto, normalmente irá funcionar.
Pode acontecer o seguinte problema:
Após instalar o Lazarus no Linux - Debian (através do Synaptic), ao tentar compilar (ou executar), pode aparecer um erro que não está encontrando "lgdk_pixbuf-2.0", ou algo semelhante.
Para resolver esse problema deve-se instalar o gtk (libgtk2.0-dev).
Entre no terminal como superusuário:
$ su
Senha:
A seguir edite o sources.list adicionando a linha:
deb http://www.hu.freepascal.org/lazarus/ lazarus-stable universe
Para isso digite:
# gedit /etc/apt/sources.list
Adicionar a linha abaixo no sources.list:
deb http://www.hu.freepascal.org/lazarus/ lazarus-stable universe
Salvar e fechar o sources.list
Em seguida execute a atualização:
# apt-get update
Instalando o liggtk2.0-dev (gtk, lgdk_pixbuf-2.0)
# apt-get install -t squeeze-backports libgtk2.0-dev
Se ocorrer algum erro digite o comando abaixo e repita o comando de instalação:
# apt-get -f install
# apt-get install -t squeeze-backports libgtk2.0-dev
Estou supondo que já tenha instalado o "pkg-config" e o "gcc", caso não tenha instalado esses dois, instale.
Referâncias:
http://crunchbanglinux.org/forums/topic/18322/solved-cannot-install-libgtk20dev/
http://celde.wordpress.com/2007/10/05/roda-roda-roda-que-a-ide-e-um-sonho-que-vai-compilaaaarrr/#comment-392
:~$ su
Senha
# apt-get install lazarus
Pronto, normalmente irá funcionar.
Pode acontecer o seguinte problema:
Após instalar o Lazarus no Linux - Debian (através do Synaptic), ao tentar compilar (ou executar), pode aparecer um erro que não está encontrando "lgdk_pixbuf-2.0", ou algo semelhante.
Para resolver esse problema deve-se instalar o gtk (libgtk2.0-dev).
Entre no terminal como superusuário:
$ su
Senha:
A seguir edite o sources.list adicionando a linha:
deb http://www.hu.freepascal.org/lazarus/ lazarus-stable universe
Para isso digite:
# gedit /etc/apt/sources.list
Adicionar a linha abaixo no sources.list:
deb http://www.hu.freepascal.org/lazarus/ lazarus-stable universe
Salvar e fechar o sources.list
Em seguida execute a atualização:
# apt-get update
Instalando o liggtk2.0-dev (gtk, lgdk_pixbuf-2.0)
# apt-get install -t squeeze-backports libgtk2.0-dev
Se ocorrer algum erro digite o comando abaixo e repita o comando de instalação:
# apt-get -f install
# apt-get install -t squeeze-backports libgtk2.0-dev
Estou supondo que já tenha instalado o "pkg-config" e o "gcc", caso não tenha instalado esses dois, instale.
Referâncias:
http://crunchbanglinux.org/forums/topic/18322/solved-cannot-install-libgtk20dev/
http://celde.wordpress.com/2007/10/05/roda-roda-roda-que-a-ide-e-um-sonho-que-vai-compilaaaarrr/#comment-392
sábado, 7 de abril de 2012
R - Iniciando no R com Linux Ubuntu
Estou iniciando no R.
Para quem está iniciando, vou começar a colocar o que estou aprendendo, serei bem objetivo (prático).
Utilizando o Linux Ubuntu.
Instalando o R:
1 : Abrir o terminal: Ctrl + Alt + t
2 : Digitar: sudo apt-get install r-base
Utilizando o Nautilus
1 : Abra o Nautilus Ctrl+o (ou outro gerenciador de arquivos)
2 : Vá até o local onde estão os arquivos com os dados que serão trabalhados (arquivos com números, no meu caso cada número está em uma linha, o arquivo possui somente números, arquivo do tipo .txt)
3 : Digite: Ctrl+l, para aparecer o "caminho"
4 : Digite: Ctrl+c, copiar esse "caminho"
5 : Vá para o terminal
A partir de agora, trabalhando dentro do terminal.
1 : Digite: cd Ctrl+Shift+v, irá para o endereço onde estão os arquivos com os dados (isso serve para quando entrar no R já estar dentro da pasta)
2 : Entrar no R, digite: R
A partir de agora, trabalhando dentro do R.
O prompt de comando do R é um sinal de maior (>).
Crie um arquivo de texto com alguns números, cada um em cada linha, com o nome teste.txt.
Criando e armazenando os dados desse arquivo em um objeto chamado teste:
> teste <- scan("teste.txt")
Read 15 items
Resposta: 15 dados lidos.
Imprimir o conteúdo de um objeto, digite:
> teste
[1] 5 5 5 3 3 3 4 4 7 7 7 7 7 2 8
Resposta: elementos do objeto teste.
Verificando se os dados são numéricos, digite:
> is.numeric(teste)
[1] TRUE
Resposta: TRUE, siginifando que os dados são numéricos.
Verificar a quantidade de itens no objeto, digite:
> length(teste)
[1] 15
Resposta: 15 dados em um "vetor".
Criando uma tabela de valores absolutos acumulados
> teste.tb <- table(teste)
> teste.tb
teste
2 3 4 5 7 8
1 3 2 3 5 1
Resposta: quantidade de cada elemento.
Saber quantidade de elementos em cada objeto.
> length(teste)
[1] 15
> length(teste.tb)
[1] 6
Criando uma tabela de valores relativos acumulados
> teste.tbr <-prop.table(teste)
Verificando média (cria-se um objeto teste.me que armazena a média dos dados):
> teste.me <- mean(teste)
> teste.me
Assim como a média, segue-se para variância, desvio padrão, coeficiente de variabilidade, máximo, mínimo e moda.
Variância:
> teste.var <- var(teste)
> teste.var
Desvio padrão:
> teste.sd <- sd(teste)
> teste.sd
Coeficiente de variabilidade:
> teste.cv <- 100*teste.sd/teste.me
> teste.cv
Mediana:
> teste.md <- median(teste)
> teste.md
Máximo:
> teste.max <- max(teste)
> teste.max
Mínimo:
> teste.min <- min(teste)
> teste.min
Moda:
> teste.mo <- (teste.tb)[which.max(teste.tb)]
> teste.mo
Quartil:
> quantile(teste)
Percentil de 5%, 20% e 80%:
> quantile(teste,c(0.05,0.20,0.8))
Para sair do R basta digitar
> q()
Poderá salvar os dados.
Para quem está iniciando, vou começar a colocar o que estou aprendendo, serei bem objetivo (prático).
Utilizando o Linux Ubuntu.
Instalando o R:
1 : Abrir o terminal: Ctrl + Alt + t
2 : Digitar: sudo apt-get install r-base
Utilizando o Nautilus
1 : Abra o Nautilus Ctrl+o (ou outro gerenciador de arquivos)
2 : Vá até o local onde estão os arquivos com os dados que serão trabalhados (arquivos com números, no meu caso cada número está em uma linha, o arquivo possui somente números, arquivo do tipo .txt)
3 : Digite: Ctrl+l, para aparecer o "caminho"
4 : Digite: Ctrl+c, copiar esse "caminho"
5 : Vá para o terminal
A partir de agora, trabalhando dentro do terminal.
1 : Digite: cd Ctrl+Shift+v, irá para o endereço onde estão os arquivos com os dados (isso serve para quando entrar no R já estar dentro da pasta)
2 : Entrar no R, digite: R
A partir de agora, trabalhando dentro do R.
O prompt de comando do R é um sinal de maior (>).
Crie um arquivo de texto com alguns números, cada um em cada linha, com o nome teste.txt.
Criando e armazenando os dados desse arquivo em um objeto chamado teste:
> teste <- scan("teste.txt")
Read 15 items
Resposta: 15 dados lidos.
Imprimir o conteúdo de um objeto, digite:
> teste
[1] 5 5 5 3 3 3 4 4 7 7 7 7 7 2 8
Resposta: elementos do objeto teste.
Verificando se os dados são numéricos, digite:
> is.numeric(teste)
[1] TRUE
Resposta: TRUE, siginifando que os dados são numéricos.
Verificar a quantidade de itens no objeto, digite:
> length(teste)
[1] 15
Resposta: 15 dados em um "vetor".
Criando uma tabela de valores absolutos acumulados
> teste.tb <- table(teste)
> teste.tb
teste
2 3 4 5 7 8
1 3 2 3 5 1
Resposta: quantidade de cada elemento.
Saber quantidade de elementos em cada objeto.
> length(teste)
[1] 15
> length(teste.tb)
[1] 6
Criando uma tabela de valores relativos acumulados
> teste.tbr <-prop.table(teste)
Verificando média (cria-se um objeto teste.me que armazena a média dos dados):
> teste.me <- mean(teste)
> teste.me
Assim como a média, segue-se para variância, desvio padrão, coeficiente de variabilidade, máximo, mínimo e moda.
Variância:
> teste.var <- var(teste)
> teste.var
Desvio padrão:
> teste.sd <- sd(teste)
> teste.sd
Coeficiente de variabilidade:
> teste.cv <- 100*teste.sd/teste.me
> teste.cv
Mediana:
> teste.md <- median(teste)
> teste.md
Máximo:
> teste.max <- max(teste)
> teste.max
Mínimo:
> teste.min <- min(teste)
> teste.min
Moda:
> teste.mo <- (teste.tb)[which.max(teste.tb)]
> teste.mo
Quartil:
> quantile(teste)
Percentil de 5%, 20% e 80%:
> quantile(teste,c(0.05,0.20,0.8))
Para sair do R basta digitar
> q()
Poderá salvar os dados.
Assinar:
Postagens (Atom)