sexta-feira, 15 de dezembro de 2017

Aproximação de uma função por soma de senos e cossenos

Exemplos de sinais periódicos.

Algumas vezes, desejamos aproximar um sinal periódico (possivelmente ruidoso) por uma soma de senos e cossenos. Sabemos que (quase) qualquer sinal periódico, por exemplo uma onda quadrada, pode ser decomposto em uma soma infinita de senos e cossenos cujas frequências são múltiplas da frequência fundamental do sinal periódico. Essa é a famosa Série de Fourier (ver aqui).

Nesta postagem, usando o Scilab e o comando fft, vamos ver como encontrar as principais componentes de seno e cosseno de um sinal periódico arbitrário. A ideia básica é calcular o espectro do sinal periódico com o comando fft e, em seguida, "montar" um sinal com as componentes de maior amplitude. Essa estratégia, se o sinal tiver vários períodos, acaba por filtrar algum ruído existente na função.

Seja o sinal indicado abaixo, quais suas componentes em termos de seno e cosseno?

Na figura acima, temos 10 períodos de um sinal periódico ruidoso, seu período vale 100 unidades de tempo (= 1 segundo). A análise é feita com o comando fft:

Com essas componentes, chegamos ao seguinte sinal: $$s(t) = 1.009\cos(2\pi t) + 0.495\sin(4\pi t) - 0.3013\cos(6\pi t) + 0.046\sin(8\pi t) + 0.0831\cos(8\pi t) + 0.052\cos(10\pi t)$$.
Para comparação, o sinal "exato" é:
$$s(t) = \cos(2\pi t) + 0.5\sin(4\pi t) - 0.3\cos(6\pi t) + + 0.1\cos(8\pi t + 0.5) + 0.05\cos(10\pi t)$$. Graficamente:
Código Scilab:

close; close;
t=0:0.01:(10-0.01);
p2=2*%pi;
s = cos(p2*t) + 0.5*sin(2*p2*t) - 0.3*cos(3*p2*t) +...
 0.1*cos(4*p2*t + 0.5) + 0.05*cos(5*p2*t);
sp = s;
s = s + 0.1*rand(s,'n');
plot(s); xgrid;

f = 1:max(size(s));
f = f - 1;
f = f/max(f); f = f*100;
sf = fft(s);
sfr = real(sf);
sfc = imag(sf);
// subplot(2,1,2);
figure;
plot(f(1:200), sfr(1:200),'m');
plot(f(1:200), sfc(1:200),'r');
legend('Componentes em fase','Componentes em quadratura');
//pega picos:
tt = 1:max(size(s));
tt=tt-1; tt=tt*0.01;
p = zeros(1,5);
fp = p;
ss = 0*tt;
tam2 = round(max(size(sfr))/2);
sfr = sfr(1:tam2); sfr(1) = 0;
sfc = sfc(1:tam2); sfc(1) = 0;
m = mean(s);
picoc = 0
picos = 0;
kf = 500; //fator de escala - 10 períodos e dt = 0,01;
for k=1:6
    [a,b] = max(abs(sfr));
    fq = round(f(b));
    if abs(sfr(b))>picoc then picoc = abs(sfr(b)); end;
    if abs(sfr(b))>(picoc/30) then
        ss = ss + sfr(b)*cos(fq*p2*tt)/kf;
        disp([fq,sfr(b)/kf,0]);
    end;
    sfr(b) = 0;
    [a,b] = max(abs(sfc));
    fq = round(f(b));
    if abs(sfc(b))>picos then picos = abs(sfc(b)); end;  
    if abs(sfc(b))>(picoc/30) then
        ss = ss - sfc(b)*sin(fq*p2*tt)/kf;
        disp([fq,sfc(b)/kf,1]);
    end;
    sfc(b) = 0;
end
ss = m + ss;
figure; plot(tt,sp,'m',tt,ss,'b',tt,s,'r');
legend('Sinal puro','Sinal calculado','Sinal com ruído');

sábado, 9 de dezembro de 2017

Palestra: Uma Abordagem para Detecção de Pessoas em Imagens de Veículos Aéreos Não-Tripulados


O PPGCC-IFCE promove, na próxima quarta-feira (13), palestra sobre pesquisa em Computação Embarcada e VANT. 

Título: 
Uma Abordagem para Detecção de Pessoas em Imagens de Veículos Aéreos Não-Tripulados

Palestrante:
  • Marco Aurélio Wehrmeister, Dr. (Lattes aqui).
  • Prof da UTFPR e pesquisador no CPGEI (Programa de pós-graduação em Eng Elétrica e Informática Industrial).
  • Sua área de interesse é Sistemas Embarcados e de Tempo-Real, desde a especificação e projeto até a implementação. 
  • Coordenador do Laboratório de Engenharia de Sistemas Computacionais (LESC) e pesquisador do Laboratório Avançado de Sistemas Embarcados e Robótica (LASER) da UTFPR.

O que: Palestra - Uma Abordagem para Detecção de Pessoas em Imagens de Veículos Aéreos Não-Tripulados
Quando: 13.12.17 (quarta-feira). 18:30h
Onde: Auditório Iran Ralpp, IFCE, Campus Fortaleza, av 13 de Maio 2081.

quinta-feira, 7 de dezembro de 2017

Nova dica de leitura: TED Talks - O guia oficial do TED para falar em público



Quem nunca precisou falar em público e ficou ligeiramente nervoso, sem saber direito o que falar ou como falar ou como se mover? Às vezes, nós metemos em situações em que temos que falar para um grande público e não temos a opção de "desistir". Temos que ir em frente e apresentar alguma coisa a público que não conhecemos bem. Como resolver um problema desse tipo? Ou pelo menos como não piorar as coisas com uma apresentação cheia de falhas? Uma dica básica: planejamento.

No livro de Chris Anderson (ANDERSON, Chris. TED Talks: o guia oficial do TED para falar em público. Rio de Janeiro: Intrínseca, 2016. 239 p. ISBN 9788580579352) temos muito mais que isso. São várias histórias e dicas de como impressionar positivamente o seu público e, claro, transmitir aquilo que você quer de forma que cause um bom impacto. O livro, naturalmente, tem uma leitura fácil e prazerosa. Fica aí, em poucas linhas, mais uma dica de leitura.

sábado, 2 de dezembro de 2017

Dica de leitura: Oppenheimer


Sem dúvida, Oppenheimer (Julius Robert Oppenheimer - Nova Iorque, 22 de abril de 1904 - Princeton, 18 de fevereiro de 1967) foi um dos maiores físicos do século XX, mas que não ganhou o prêmio Nobel de Física. Um pequeno livro, formato de bolso, tenta mostrar os aspectos humanos e as contribuições desse personagem complexo em mundo que se tornava cada vez mais bélico e louco. O livro é de autoria de José Maria Filardo Bassalo (Lattes aqui) e Francisco Caruso Neto (Lattes aqui), dois caras que entendem muito de física. Ao londo do texto são apresentadas várias referências acadêmicas sobre os trabalhos científicos citados. No posfácio do livro lemos (Alfredo Marques - Centro Brasileiro de Pesquisas Físicas):
A vida intelectual e efetiva de John Robert Oppenheimer, minuciosamente trabalhada neste livro, evoca a figura do mito histórico, tão imensa foi sua atuação em grandes temas político-científicos que marcaram o turbulento século XX. Com extensa faixa de interesses culturais e científico, seu pensamento parecia acomodar temas contraditórios, a espera de melhores provas para selecioná-los, alterativas extravagantes, beirando mesmo o impossível. Encantavam-no grandes desafios. 
A forte personalidade, exuberante cultura e impulso desassombrado que o levou algumas vezes à brutal agressão, inspiraram também manifestações de poetas, músicos, romancistas, teatrólogos, alunos e colegas de trabalho. Ninguém teve dele uma opinião rigorosamente neutra, balançando entre extremos, do profano ao sagrado, segundo sua atuação. 
Atuou nos desenvolvimentos científicos mais significativos do século XX, dos fundamentos da Mecânica Quântica à Radiação Cósmica e à Cosmologia. Suas contribuições, muitas vezes incompletas, mas suficientes para indicar caminhos, lhe valeram a acusação de displicente. Teve algumas indicações mal sucedidas ao Prêmio Nobel de Física. Alguns dos que perseveraram ao longo das linhas que abriu, mas não concluiu, se contam, entretanto, entre detentores daquela premiação. 
Como Diretor Científico do Laboratório de Los Alamos foi figura do maior destaque no desenvolvimento da bomba atômica. A despeito de seus numerosos relacionamentos com membros do partido comunista americano, seu irmão Frank e sua cunhada, para não falar da mulher com quem casou, a chefia do Projeto Manhattan decidiu ignorá-los, e assim fez enquanto os Estados Unidos e a USSR combatiam do mesmo lado da segunda guerra. Considerou também que o desenvolvimento da bomba incorporava desafios sem precedentes, distribuídos por uma extensa faixa de problemas novos cuja solução demandaria não apenas ideias e conhecimentos inovadores, mas atuação ousada e pronta. Estas condições fizeram de Oppenheimer a escolha ideal. O apelido que nasceu no auditório de uma conferência que fez na Holanda logo se generalizou. 
Dado o clima de afeto e familiaridade emanado do uso de apelidos, entendo que representa o acato dos contemporâneos à importância de sua controvertida figura.

quarta-feira, 29 de novembro de 2017

Divulgando: SBRC 2018 - XXXVI Simpósio Brasileiro de Redes de Computadores e Sistemas Distribuídos


----------------------------------------------------------------------------------------------------------------------------
CHAMADA DE TRABALHOS


SBRC 2018: XXXVI Simpósio Brasileiro de Redes de Computadores e Sistemas
Distribuídos
Campos dos Jordão  – São Paulo, 06 a 10 de maio de 2018
----------------------------------------------------------------------------------------------------------------------------
O EVENTO

O Simpósio Brasileiro de Redes de Computadores e Sistemas Distribuídos (SBRC) é um evento anual promovido pela Sociedade Brasileira de Computação (SBC) e pelo Laboratório de Redes de Computadores (LARC). Ao longo de mais de três décadas de realização, o SBRCfirmou-se como o mais importante evento científico nacional em redes de computadores e sistemas distribuídos, e um dos mais concorridos em informática. A importância do SBRC pode ser observada pelo número de submissões de trabalhos e de participantes nas suas diversas edições.

A 36a edição do Simpósio será realizada de 06 a 10 de maio de 2018 no Centro de Convenções de  Campos dos Jordão, São Paulo. A coordenação do evento está sob a responsabilidade conjunta do Departamento de Computação (DComp) da Universidade Federal de São Carlos (UFSCar) e do Instituto de Ciências Matemáticas e de Computação (ICMC) da USP (Universidade de São Paulo). Tradicionalmente, o evento é  composto de sessões técnicas, minicursos, painéis e debates, workshops, salão de ferramentas, palestras e tutoriais proferidos por convidados de renome internacional. Este ano, pela primeira vez, o SBRC contará com um hackaton na área de Redes de Computadores e Sistemas Distribuídos e também com um Concurso de Teses e Dissertações.

-----------------------------------------------------------------------------------
TÓPICOS DE INTERESSE:

Autores são convidados a submeter artigos completos contendo resultados de suas pesquisas científicas ou tecnológicas. Cada artigo será avaliado por pelo menos três especialistas.

A lista não exaustiva de tópicos de interesse inclui:

• Algoritmos distribuídos (projetos e aplicações)
• Aplicações em redes
• Arquitetura e caracterização de redes e serviços
• Cidades inteligentes
• Computação intensiva de dados (Big Data), e análise e mineração de dados
• Computação na nuvem, na névoa e orientada a serviços
• Computação móvel
• Computação ubíqua, pervasiva e sensível ao contexto
• Crowdsourcing
• Detecção e prevenção de anomalias e ataques
• Desempenho, escalabilidade e confiabilidade
• Engenharia e controle de tráfego
• Especificação, validação e verificação de protocolos
• Gerenciamento, operação, projeto e análise de redes
• Gerenciamento de identidades, endereços e localização
• Internet das coisas e sistemas ciberfísicos
• Internet do futuro
• Internet tátil
• Medição e monitoração de redes
• Middleware
• Otimização cross-layer
• Qualidade de serviços (QoS) e de experiência (QoE)
• Redes autonômicas e auto-organizáveis
• Redes centradas na informação
• Redes de centros de dados (Data Center Networking)
• Redes definidas por software
• Redes de rádios cognitivos
• Redes de sensores
• Redes móveis
• Redes ópticas
• Redes e sistemas P2P
• Redes sem fio infraestruturadas
• Redes sociais (online, móveis e pervasivas)
• Redes tolerantes a atrasos/interrupções
• Redes veiculares tripuladas e não tripuladas
• Redes verdes (green networking)
• Roteamento, comutação e endereçamento
• Segurança em redes e sistemas distribuídos
• Serviços web
• Simulação e emulação de redes
• Sistemas distribuídos (autonômicos, multimídia, de tempo real)
• Sistemas operacionais distribuídos
• Smart Grids
• Redes e aplicações de TV Digital e Interativa
• Tolerância a falhas e resiliência
• Virtualização de funções de rede
• Virtualização de redes

-----------------------------------------------------------------------------------
DATAS IMPORTANTES:

Registro de artigos: 05/12/2017
Submissão de artigos: 12/12/2017
Comunicação de resultados: 15/03/2018
Envio da versão final: 03/04/2018

sábado, 25 de novembro de 2017

Resolvendo um sistema de equações lineares iterativamente


Em algumas situações, é mais interessante resolver um sistema de equações lineares Ax = b usando algum método iterativo do que um método direto, especialmente para o caso de sistemas de grande porte e com muitos elementos nulos. O método iterativo mais usual é Gauss-Seidel que pode ser expresso por:
\[ x_i = \frac{b_i - \sum_{j=1,j\neq i}^{N}a_{ij}x_{j}}{a_{ii}} \]
com $i = 1, 2, ..., N$. Em geral, a solução inicial é o vetor nulo: x = 0.

Como é um método iterativo, devemos adotar algum critério de parada. Os critérios de parada mais comuns são: número máximo de iterações e o erro menor que uma certa tolerância. O erro pode ser calculado como a menor diferença entre $x_i^k$ e $x_i^{k-1}$, onde $k$ significa o número da iteração.

Um outro ponto que devemos considerar é que a ordem das equações no sistema é importante. Podemo trocar linhas ou colunas (sem afetar o resultado efetivo do sistema) de tal forma que a diagonal principal se torne mais dominante, isto é, os elementos da diagonal principal devem ser, em termos absolutos, maiores que os coeficientes da mesma linha.

Usaremos o sistema $8 \times 8$ abaixo para ilustrar esses conceitos:

Esse sistema é não singular nem mesmo mal condicionado, mas está longe de ser o tipo de sistema ideal para resolvermos de forma iterativa. O código abaixo calcula a sua solução:

clc; close; // Limpando o console e fechando janelas

M = [2.4 2.2 1.3 1.2 1.2 1.1 0.5 0.3
     -1 3.3 -1 1 1 0.5 0.25 0.2
     -1 -1 2.5 -1.4 -1.7 -1  0.1 0.2
      1  0.5 2.0  2.6 1  0.5 0.2 0.1 
     0.5 0.5 -1.2 -1 2.1 1 -0.2 0.1
     0.5 1.5 -1 1 -1 2 -0.1 -0.2
     0.25 -0.5 1.5 -1.3 1 -1 2.1 -0.5
     -0.3 0.6 0.5 1.5 -1.2 1 -1.3 -2]
b = M*[1;2;3;4;5;6;-0.5;-2]; // vetor 
N = 8; // ordem da matriz

Mi = M;
xk = 0*b;  // solução inicial
bi = b;
for k=1:N 
    Mi(k,k) = 0;  Mi(k,:) = Mi(k,:)/M(k,k);
    bi(k) = bi(k)/M(k,k);
end

nmax = 90; // número máximo de iterações
erro = 1; // erro inicial
nk = 2;  // número da iteração
mvx = zeros(N,nmax); // guardando os valores de xk
mvx(:,1) = xk;
while erro>0.005
    erro = xk;
    for n=1:N
        s = Mi(n,:)*xk;
        xk(n) = bi(n) - s; 
    end    
    mvx(:,nk) = xk;
    erro = max(abs(erro - xk));
    printf('%d & %1.4f & %1.4f & %1.4f & %1.4f & %1.4f %1.4f \n',...
    nk,xk(1),xk(2),xk(3),xk(4),xk(5),erro);
    nk = nk + 1;
    if nk > nmax then 
        erro =0; 
    end; // número máximo de iterações
end
figure;
plot(1:nk-1,mvx(:,1:nk-1),'-o'); xgrid;
xlabel('Iteração k'); ylabel('$ x_i \$');
legend('x1','x2','x3','x4','x5','x6','x7','x8');

O resultado podemos ver no gráfico abaixo:

A convergência só ocorre com quase 90 iterações. Muito demorado!
Percebemos que o total de iterações para ocorrer a convergência é muito longo, pois são necessárias quase 90 iterações. O que podemos fazer para melhorar isso? Trocar linhas/colunas e iniciar com um ponto de partida melhor. Um ponto de partida possivelmente melhor é fazer $x_i = b_i/a_{ii}$, aplicando esse ganho obtemos uma redução de algumas iterações, é um ganho pequeno. Um ganho mais significativo é se trocarmos as incógnitas $x_1$ com $x_2$, isso implica em trocar a 2a. com a 3a. linha e, depois, a segunda coluna com a primeira coluna. Nesse caso, o ganho é muito significativo, o número de iterações cai para apenas 19, mantendo o mesmo critério de erro. Se, adicionalmente, somarmos a 3a com a 4a. coluna, fazemos com a diagonal fique mais dominante, acelerando ainda mais a convergência. O código com essas alterações é:

clc; close; // Limpando o console e fechando janelas

M = [2.4 2.2 1.3 1.2 1.2 1.1 0.5 0.3
     -1 3.3 -1 1 1 0.5 0.25 0.2
     -1 -1 2.5 -1.4 -1.7 -1  0.1 0.2
      1  0.5 2.0  2.6 1  0.5 0.2 0.1 
     0.5 0.5 -1.2 -1 2.1 1 -0.2 0.1
     0.5 1.5 -1 1 -1 2 -0.1 -0.2
     0.25 -0.5 1.5 -1.3 1 -1 2.1 -0.5
     -0.3 0.6 0.5 1.5 -1.2 1 -1.3 -2]
b = M*[1;2;3;4;5;6;-0.5;-2]; // vetor 
N = 8; // ordem da matriz

// troca ...
aux = M(1,:); ba = b(1);
M(1,:) = M(2,:); b(1) = b(2);
M(2,:) = aux; b(2) = ba;
aux = M(:,1); M(:,1) = M(:,2); M(:,2) = aux;

//Soma 3a. linha com 4a. linha, resultado na 3a. linha:
M(3,:) = M(3,:) + M(4,:); b(3) = b(3) + b(4);
 
Mi = M;
xk = 0*b;  // solução inicial
bi = b;
for k=1:N 
  xk(k) = sign((b(k)/M(k,k))); //*sqrt(abs((b(k)/M(k,k))));
end
for k=1:N 
    Mi(k,k) = 0;  Mi(k,:) = Mi(k,:)/M(k,k);
    bi(k) = bi(k)/M(k,k);
end

nmax = 90; // número máximo de iterações
erro = 1; // erro inicial
nk = 2;  // número da iteração
mvx = zeros(N,nmax); // guardando os valores de xk
mvx(:,1) = xk;
while erro>0.005
    erro = xk;
    for n=1:N
        s = Mi(n,:)*xk;
        xk(n) = bi(n) - s; 
    end    
    mvx(:,nk) = xk;
    erro = max(abs(erro - xk));
    printf('%d & %1.4f & %1.4f & %1.4f & %1.4f & %1.4f %1.4f \n',...
    nk,xk(1),xk(2),xk(3),xk(4),xk(5),erro);
    nk = nk + 1;
    if nk > nmax then 
        erro =0; 
    end; // número máximo de iterações
end
figure;
plot(1:nk-1,mvx(:,1:nk-1),'-o'); xgrid;
xlabel('Iteração k'); ylabel('$ x_i \$');
legend('x1','x2','x3','x4','x5','x6','x7','x8');

O resultado é:
O mesmo sistema, mas com alguns ajustes "técnicos" - redução significativa no número de iterações.

segunda-feira, 20 de novembro de 2017

Divulgando: 12º CocoaHeads Fortaleza e PyLadies - Aracati


12º CocoaHeads Fortaleza
Capítulo: CocoaHeads Fortaleza
Data do evento: 23/11/2017
Horário: 13h30min
Local: Uni7 (Antiga Fa7)
Endereço: Av. Alm. Maximiano da Fonseca, 1395 Eng. Luciano Cavalcante - CEP 60811-020 Fortaleza - CE - Brasil.

Mais informações aqui!



O campus de Aracati vai promover mais uma ação para incentivar a participação de meninas na área de tecnologia e computação. Isso vai ser possível graças ao início das atividades, aqui no campus, do PyLadies, uma comunidade mundial que já existe em vários estados brasileiros justamente com o propósito de atrair mais mulheres para a área tecnológica.

O primeiro encontro do grupo acontece no dia 24 de novembro, das 13h30 às 17h, no auditório do novo campus do IFCE, com uma programação aberta ao público. Em Aracati, o Pyladies vai reunir atividades que vinham sendo realizadas em dois projetos que já funcionam no campus: o Divas, voltado para a promoção da presença de mulheres na computação; e o Propython, que atua na divulgação da linguagem de programação Python.