+
+* **Horário das aulas**:
+ * TER - 9:45
+ * SEX - 13:30
+ * Atendimento TER - 15:30
+
+
+## Avaliação
+
+A avaliação da disciplina será composta por provas, projetos e atividades de acompanhamentos:
+
+* Provas Intermediária (PI) e Final (PF) serão compostas por exercícios práticos a serem feitos durante o tempo de prova;
+* O projeto da disciplina será composto por múltiplas partes. [Mais detalhes na página de projetos](projetos)
+
+A média final é dada por
+
+* 55% Projeto
+* 45% média de Provas
+
+!!! warning "Condições de barreira"
+ * Média de provas >= 4,5
+ * PI, PF >= 4,0
+ * Projeto >= 5 (não serão aceitos projetos atrasados)
+
+ Caso estas condições não sejam cumpridas ver detalhes na [aula 01](aulas/01-introducao/slides.pdf)
+
+!!! failure "Mesmo que todas as condições acima sejam satisfeitas é possível reprovar. Um desempenho abaixo do esperado em uma atividade precisa ser compensado com um desempenho melhor em outra atividade."
diff --git a/material/js/counter.js b/material/js/counter.js
new file mode 100644
index 000000000..793605a49
--- /dev/null
+++ b/material/js/counter.js
@@ -0,0 +1,13 @@
+{
+ let admonitions_for_counting = ["question", "example"];
+
+ for (const admonition_type of admonitions_for_counting) {
+ let elements = document.querySelectorAll(".admonition." + admonition_type);
+ let count = 1;
+ for (const element of elements) {
+ let title = element.querySelector(".admonition-title");
+ title.innerHTML += " " + count;
+ count++;
+ }
+ }
+}
\ No newline at end of file
diff --git a/material/js/markdown-enhancer.js b/material/js/markdown-enhancer.js
new file mode 100644
index 000000000..cbfccad98
--- /dev/null
+++ b/material/js/markdown-enhancer.js
@@ -0,0 +1,21 @@
+{
+ // HACK: depends on mkdocs-material
+ let home_link = document.querySelector(".md-header a.md-header-nav__button.md-logo");
+ window.site_url = home_link.href;
+ console.log(window.site_url + "config.yml");
+ fetch(window.site_url + "config.yml").then((resp) => {
+ return resp.text();
+ }).then((text) => {
+ let obj = jsyaml.load(text);
+ obj.extensions.forEach((ext) => {
+ let scr = document.createElement("script");
+ scr.type = "text/javascript";
+ scr.src = window.site_url + "js/" + ext + ".js";
+
+ document.body.appendChild(scr);
+ });
+
+ window.ihandout_config = obj.config;
+ });
+
+}
\ No newline at end of file
diff --git a/material/js/progress-check.js b/material/js/progress-check.js
new file mode 100644
index 000000000..e6900016b
--- /dev/null
+++ b/material/js/progress-check.js
@@ -0,0 +1,72 @@
+{
+ // HACK: depends on mkdocs-material styles
+ let style_progress = document.head.appendChild(document.createElement("style"));
+ style_progress.innerText = `
+ article input[type=button].checkpoint {
+ margin-left: auto;
+ margin-right: auto;
+ display: block;
+
+ background-color: var(--md-primary-fg-color);
+ color: var(--md-primary-bg-color);
+ font-size: 0.8rem;
+ padding: 10px;
+ border-radius: 3px;
+ }
+ `;
+
+ let document_addr = document.location.pathname;
+
+ let all_checkpoints = document.querySelectorAll(".admonition.progress");
+ if (all_checkpoints.length > 0) {
+ let next = all_checkpoints[0].nextElementSibling;
+ while (next != null) {
+ next.style.display = "none";
+ next = next.nextElementSibling;
+ }
+ }
+
+ all_checkpoints.forEach((item, k) => {
+ let text = item.querySelector('p:not(.admonition-title)').innerText;
+ let but = document.createElement("input");
+ but.type = "button";
+ but.value = text;
+ but.classList.add("checkpoint");
+ but.style.display = item.style.display;
+ let storage_key = document_addr + "/checkpoint-" + k;
+
+ item.parentElement.replaceChild(but, item);
+ but.addEventListener("click", (evt) => {
+ let prev = but.previousElementSibling;
+ while (prev != null) {
+ if (prev.dataset.answered !== undefined &&
+ prev.dataset.answered === "false") {
+ return;
+ }
+ prev = prev.previousElementSibling;
+ }
+
+ localStorage[storage_key] = true;
+
+ let next = but.nextElementSibling;
+ while (next != null) {
+ next.style.display = "";
+ if (next.classList.contains("checkpoint")) {
+ break;
+ }
+ next = next.nextElementSibling;
+ }
+
+ but.remove();
+ });
+ });
+
+ let all_checkpoint_buttons = document.querySelectorAll(".checkpoint");
+ all_checkpoint_buttons.forEach((item, k) => {
+ let storage_key = document_addr + "/checkpoint-" + k;
+ if (localStorage[storage_key] == "true") {
+ item.click();
+ }
+ });
+
+}
\ No newline at end of file
diff --git a/material/js/quiz.js b/material/js/quiz.js
new file mode 100644
index 000000000..8de17ddeb
--- /dev/null
+++ b/material/js/quiz.js
@@ -0,0 +1,103 @@
+{
+ function toggle_disabled(form_quiz_choices, disable=false, uncheck=false) {
+ form_quiz_choices.forEach((item) => {
+ let checkbox = item.querySelector("input[type=checkbox]");
+ if (uncheck) checkbox.checked = false;
+ checkbox.disabled = disable;
+ });
+ }
+
+ // HACK: depends on pymdownx.tasklist and mkdocs-material (custom checkbox)
+ let style_quiz = document.head.appendChild(document.createElement("style"));
+ style_quiz.innerHTML = `
+ input[type=checkbox].wrong-answer + .task-list-indicator::before {
+ background-color: #DD1111 !important;
+ }
+ `;
+
+ let document_addr = document.location.pathname;
+ let multiple_choice_questions = document.querySelectorAll(".admonition.question.choice");
+
+ multiple_choice_questions.forEach((item, k) => {
+ item.dataset.answered = false;
+ let storage_key = document_addr + "/choice-" + k;
+ let previous_answer = localStorage.getItem(storage_key);
+
+ let choices_ul = item.querySelector(".task-list");
+ let choices_original = item.querySelectorAll(".task-list-item");
+ let correct_choice = null;
+
+ choices_ul.remove();
+
+ let form_quiz = document.createElement("form");
+ let form_quiz_ul = choices_ul.cloneNode(true);
+ let form_quiz_choices = form_quiz_ul.querySelectorAll(".task-list-item");
+ form_quiz.appendChild(form_quiz_ul);
+
+ let answer = item.querySelector(".admonition.details");
+ if (answer) {
+ answer.remove();
+ answer.style.display = "none";
+ form_quiz.appendChild(answer);
+ }
+
+ toggle_disabled(form_quiz_choices, false, false);
+
+ for (let i = 0; i < choices_original.length; i++) {
+ let check_original = choices_original[i].querySelector("input[type=checkbox]");
+ let check_quiz = form_quiz_choices[i].querySelector("input[type=checkbox]");
+
+ if (check_original.checked) {
+ correct_choice = form_quiz_choices[i];
+ check_quiz.checked = false;
+ }
+
+
+ if (previous_answer === null) {
+ form_quiz_choices[i].addEventListener("click", (evt) => {
+ if (check_quiz.disabled) return false;
+ evt.preventDefault();
+ check_quiz.checked = true;
+ let choice = form_quiz_choices[i];
+
+ correct_choice.querySelector("input[type=checkbox]").checked = true;
+ if (choice != correct_choice) {
+ check_quiz.classList.add("wrong-answer");
+ }
+
+ localStorage[storage_key] = i;
+
+ toggle_disabled(form_quiz_choices, true);
+
+ if (answer) {
+ answer.style.display = "";
+ }
+
+ item.dataset.answered = true;
+
+ return true;
+ });
+ } else {
+ check_quiz.disabled = true;
+ }
+ }
+
+ if (previous_answer !== null) {
+ correct_choice.querySelector("input[type=checkbox]").checked = true;
+ let idx = parseInt(previous_answer);
+ if (form_quiz_choices[idx] != correct_choice) {
+ let checkbox = form_quiz_choices[idx].querySelector("input[type=checkbox]")
+ checkbox.checked = true;
+ checkbox.classList.add("wrong-answer");
+ }
+
+ if (answer) {
+ answer.style.display = "";
+ }
+
+ item.dataset.answered = true;
+ }
+
+ item.appendChild(form_quiz);
+ });
+}
\ No newline at end of file
diff --git a/material/js/short-questions.js b/material/js/short-questions.js
new file mode 100644
index 000000000..35626a3d2
--- /dev/null
+++ b/material/js/short-questions.js
@@ -0,0 +1,85 @@
+{
+ // HACK: depends on mkdocs-material
+ let style_short_questions = document.head.appendChild(document.createElement("style"));
+ style_short_questions.innerText = `
+ .admonition.question.short input[type=text] {
+ border: 1px solid #555555;
+ border-radius: 3px;
+ }
+
+ .admonition.question.short input[type=button] {
+ background-color: var(--md-primary-fg-color);
+ color: var(--md-primary-bg-color);
+
+ margin-left: 10px;
+ margin-right: 10px;
+ padding: 5px;
+ border-radius: 3px;
+ }
+
+ .admonition.question.short > .answer-line {
+ display: flex;
+ flex-direction: row;
+ width: 100%;
+ }
+
+ .answer-line > input[type=text] {
+ flex-grow: 4;
+ }
+ `;
+
+
+ let document_addr = document.location.pathname;
+
+ let button_text = "Validate";
+ if (window.ihandout_config["short-questions"]) {
+ button_text = window.ihandout_config["short-questions"]["text"];
+ }
+
+ let short_questions = document.querySelectorAll(".admonition.question.short");
+
+ short_questions.forEach((item, k) => {
+ let answer = item.querySelector(".details");
+ if (!answer) return;
+ answer.remove();
+ item.dataset.answered = false;
+
+ let storage_key = document_addr + "/short-question-" + k;
+ let previous_answer = localStorage.getItem(storage_key);
+
+ let answer_line = document.createElement("div");
+ answer_line.classList.add("answer-line");
+ item.appendChild(answer_line);
+
+ let text = document.createElement("input");
+ text.type = "text";
+
+ if (previous_answer) {
+ text.value = previous_answer;
+ text.disabled = true;
+ answer_line.appendChild(text);
+ item.appendChild(answer);
+ item.dataset.answered = true;
+ } else {
+ let validate_button = document.createElement("input");
+ validate_button.type = "button";
+ validate_button.value = button_text;
+
+ answer_line.appendChild(text);
+ answer_line.appendChild(validate_button);
+
+ validate_button.addEventListener("click", (evt) => {
+ let student_answer = text.value.trim();
+ if (student_answer != "") {
+ item.appendChild(answer);
+ localStorage[storage_key] = student_answer;
+ text.disabled = true;
+ validate_button.remove();
+ item.dataset.answered = true;
+ }
+
+ });
+ }
+
+ });
+}
\ No newline at end of file
diff --git a/material/js/slides.js b/material/js/slides.js
new file mode 100644
index 000000000..b38f37b13
--- /dev/null
+++ b/material/js/slides.js
@@ -0,0 +1,32 @@
+{
+ let current_document = window.location.href;
+ let last_slash = current_document.lastIndexOf("/");
+
+ let slide_path = "";
+ if (last_slash == current_document.length-1) {
+ slide_path = current_document + "slides.pdf";
+ } else {
+ slide_path = current_document.substring(0, last_slash) + "/slides.pdf";
+ }
+
+ let xhr = new XMLHttpRequest();
+ xhr.addEventListener("load", function(ev) {
+ if (xhr.status == 200) {
+ let emb = document.createElement("embed");
+ emb.src = slide_path;
+ emb.width = 500;
+ emb.height = 375;
+ emb.type = "application/pdf";
+
+ let div_center = document.createElement("div");
+ div_center.style = "text-align: center";
+ div_center.className = "no-print";
+ div_center.appendChild(emb);
+
+ document.querySelector("h1").insertAdjacentElement("afterend", div_center);
+ }
+ });
+ xhr.open("head", slide_path);
+ xhr.send();
+
+}
\ No newline at end of file
diff --git a/material/projetos/2021-2/bb.png b/material/projetos/2021-2/bb.png
new file mode 100644
index 000000000..47d642d56
Binary files /dev/null and b/material/projetos/2021-2/bb.png differ
diff --git a/material/projetos/2021-2/busca-exaustiva.md b/material/projetos/2021-2/busca-exaustiva.md
new file mode 100644
index 000000000..8fa937b3b
--- /dev/null
+++ b/material/projetos/2021-2/busca-exaustiva.md
@@ -0,0 +1,10 @@
+# Solução Busca exaustiva - Branch and Bound
+
+
+Faça agora uma implementação de busca exaustiva para o problema do min-set-cover. Assuma inicialmente que todos os subconjuntos são necessários. Para cada subconjunto da solução, remova ele a solução em questão e verifique se a propriedade de cobertura é mantida. Faça isso para todos os elementos na ordem do vetor de soluções, enquanto a propriedade for válida. Se a propriedade ficar inválida, você deve interromper essa linha de processamento, executando então uma nova estrutura de possibilidades em que considera esse conjunto vital para a continuidade do problema.
+
+Para auxiliar na sua implementação, você pode se basear no pseudocódigo abaixo. Assuma que custos é um vetor unitário de cardinalidade igual ao vetor que armazena os subconjuntos. Há um programa Python disponibilizado neste [link](https://colab.research.google.com/drive/1PdJo7henY_P4BnDBKGm9b0himbm8MPMd?usp=sharing) para que você possa simular a implementação desse pseudocódigo.
+
+Avalie: Há garantia de que o resultado ótimo é obtido? Justifique.
+
+
\ No newline at end of file
diff --git a/material/projetos/2021-2/busca-local.md b/material/projetos/2021-2/busca-local.md
new file mode 100644
index 000000000..3dcc71f64
--- /dev/null
+++ b/material/projetos/2021-2/busca-local.md
@@ -0,0 +1,75 @@
+# Solução Busca local
+
+
+
+
+A busca local consiste em uma metaheurística usada para resolver problemas de otimização computacionalmente difíceis. Esse tipo de algoritmo percorre o espaço de busca movendo-se iterativamente de uma solução candidata para outra, seguindo um caminho através da relação de vizinhança, até que uma solução considerada boa o suficiente seja encontrada ou um limite de tempo decorrido. Normalmente todo candidato possui mais de uma solução de vizinho e a escolha entre elas é feita com o auxílio de informações locais e experiência anterior.
+
+A solução por busca local tenta maximizar o número de elementos com o mínimo de subconjuntos possível. Precisamos capturar esse critério por meio de uma função de *fitness*. Uma maneira possível de fazer isso é construir uma função de *fitness* calculando o número de elementos capturados pelos subconjuntos de uma solução candidata e, em seguida, dividindo-o pelo número de subconjuntos que contém. Essa função de pontuação favorecerá as soluções que acumulam a maioria dos elementos do universo U com o mínimo de subconjuntos.
+
+
+Para isso, implemente as seguintes alterações em seu projeto:
+
+1. Gerar uma solução aleatória para o problema do min-set-cover;
+2. Percorra novamente os conjuntos os elementos da sua solução e, de maneira randômica, troque até r (r entre 1 e 3) elementos da sua solução por subconjuntos que ficaram de fora da solução.
+3. Se a solução tiver melhor escore, mantenha ela.
+
+Para verificar o desempenho, construa um cenário com ao menos 200 elementos e 80 subconjuntos, de até 40 elementos cada. Faça três variações desse cenário (elementos, subconjuntos, número de elementos em subconjuntos) e avalie o desempenho e a efetividade em encontrar uma solução ótima.
+
+
+Para a entrega, usaremos o site **codePost**, você recebeu na sala de aula o link para criar sua conta. A submissão será feita unicamente por ele. Caso tenha alguma dúvida, entre em contato.
diff --git a/material/projetos/2021-2/heuristico.md b/material/projetos/2021-2/heuristico.md
new file mode 100644
index 000000000..f09ac4692
--- /dev/null
+++ b/material/projetos/2021-2/heuristico.md
@@ -0,0 +1,18 @@
+# Solução heurística
+
+Um dos melhores estratégias para resolução do problema min-set-cover é a estratégia gulosa. O algoritmo guloso encontra uma solução para o problema de cobertura de conjunto escolhendo iterativamente um conjunto que cobre o maior número possível de variáveis descobertas restantes.
+
+Sua tarefa: implemente a estratégia gulosa para o problema do min-set-cover. A cada iteração, **o algoritmo deve selecionar o subconjunto de F que irá cobrir o maior número de elementos de U que estavam descobertos**.
+
+
+Veja abaixo um pseudo-código da estratégia gulosa que você deve implementar.
+
+
+
+
+
+ Faça testes para diversos tipos de entradas, e foque principalmente em uma grande quantidade de elementos e subconjuntos (n > 250).
+
+Você deve entregar, além de código-fonte e todas as entradas e saídas geradas para o seu programa, um arquivo contendo o resultado do programa `verify` ( que você implementou ) e comentar sobre o número de vezes em que você conseguiu encontrar uma solução para o problema. Comente também sobre o tempo de execução de sua implementação.
+
+Para a entrega, usaremos o site **codePost**, você recebeu na sala de aula o link para criar sua conta. A submissão será feita unicamente por ele. Caso tenha alguma dúvida, entre em contato.
diff --git a/material/projetos/2021-2/index.md b/material/projetos/2021-2/index.md
new file mode 100644
index 000000000..670534c0a
--- /dev/null
+++ b/material/projetos/2021-2/index.md
@@ -0,0 +1,145 @@
+# Alinhamento de Sequencias de DNA
+
+Em Bioinformática, o problema de **alinhamento de sequências de DNA** consiste no processo de comparar duas ou mais sequências de bases de forma a se observar seu nível de similaridade. Trata-se de um problema extremamente importante no contexto atual, pois permite comparar sequencias virais de SARS-COV2 em bancos de dados genômicos para detecção de novas mutações.
+
+O nível de similaridade pode ser calculado com base em **acertos (match)** e **erros (gap e mismatch)**. Os acertos contribuem com sinal positivo (+) para o nível de similaridade e, os erros, com sinal negativo (-). Abaixo temos um exemplo de cálculo do nível similaridade:
+
+
+
+Vamos associar a pontuação **+1 (match)** e as penalidades **-1 (gap)** e **-4 (mismatch)**. Assim, teremos o seguinte nível de similaridade:
+
+23 matches x (+1) + 4 gaps x (-1) + 3 mismatches x (-4) = 23-4-12 = 7
+
+Neste contexto, o problema de alinhamento de sequencias de DNA pode ser colocado da seguinte forma:
+
+```
+Dadas duas sequencias de DNA, com as bases A,T,G,C e - para indicar gap,
+encontrar o alinhamento que maximize o nível de similaridade.
+```
+
+
+Neste projeto, seu objetivo será construir programas para encontrar este alinhamento de nível máximo de similaridade, utilizando várias estratégias.
+
+Cada um dos seus programas tomará como entrada a seguinte estrutura: a primeira linha contém dois números `n` e `m`, onde `n` é o tamanho da primeira sequencia e, `m`, o tamanho da segunda. Assuma `n ≤ 200` e `m ≤ 200`. A segunda linha contém as bases da primeira sequencia e, a terceira linha, as bases da segunda.
+
+```
+5 7
+AT-CC
+TTTCCAA
+```
+
+A saída deve ser uma linha com um número inteiro indicando o nível máximo de similaridade.
+
+```
+2
+```
+Neste caso, este nível máximo de similaridade pode ser associado ao alinhamento T-CC/TTCC (1-1+1+1=2) ou a CC/CC(1+1=2). Você pode usar o código python abaixo para gerar instâncias aleatórias para seus testes.
+
+```python
+import random
+n = 10 # tamanho da primeira sequência
+m = 40 # tamanho da segunda sequência
+file = 'dna.seq' # nome do arquivo a ser gerado
+f = open(file, 'w')
+seq=[str(n)+'\n',
+ str(m)+'\n',
+ ''.join(random.choices(['A','T','C','G','-'],k=n))+'\n',
+ ''.join(random.choices(['A','T','C','G','-'],k=m))]
+f.writelines(seq)
+f.close()
+print(''.join(seq))
+
+```
+
+Um possível output para este código acima é:
+
+```
+10
+40
+TGGCGAT--C
+AGC-TCTCTTC--ATT--CAC-TACACCGACA-CGC-G-A
+```
+
+
+
+## Estratégias a serem estudadas e correção automática
+
+Para cada estratégia que vamos estudar, implementaremos um programa correspondente no projeto. Veja abaixo as datas de entrega e descrições de cada estratégia a ser implementada. Em geral, o enunciado de uma parte é liberado após a data de entrega da parte anterior.
+
+1. Solução Heurística (18/03)
+2. Busca Local (01/04)
+3. Busca Exaustiva (15/04)
+4. Relatório Preliminar (29/04)
+5. Paralelismo Multicore (13/05)
+6. Paralelismo GPU (27/05)
+7. Relatório Final (03/06)
+
+
+
+
+## Avaliação
+
+O projeto será avaliado usando rubricas para as entregas básicas. As rubricas de avaliação dos relatórios estarão descritas em suas páginas de entrega.
+
+### Conceito D
+
+Algum dos seguintes itens não foi entregue corretamente ou possui problemas sérios (no caso do relatório final).
+
+1. Solução heurística
+2. Busca local
+3. Busca exaustiva
+4. Busca local paralela (CPU)
+5. Busca local paralela (GPU)
+6. Relatório preliminar
+7. Relatório final
+
+
+### Conceito C
+
+Todas as atividades abaixo foram validadas pelo corretor e (no caso do relatório final) alcançaram qualidade mínima exigida.
+
+1. Solução heurística
+2. Busca local
+3. Busca exaustiva
+4. Busca local paralela (CPU)
+5. Busca local paralela (GPU)
+6. Relatório preliminar
+7. Relatório final
+
+### Conceito C+
+
+Além do já validado no conceito **C**, os relatórios entregues não tinham nenhum ponto **em desenvolvimento** ou **insatisfatório** na rubrica do relatório.
+
+### Conceitos avançados
+
+A partir do conceito **C+** cada atividade avançada vale meio conceito. Elas serão listadas aqui conforme o semestre avança e serão testadas pela checagem de resultados disponível no repositório de entregas.
\ No newline at end of file
diff --git a/material/projetos/2021-2/paralelismo-gpu.md b/material/projetos/2021-2/paralelismo-gpu.md
new file mode 100644
index 000000000..751069a8d
--- /dev/null
+++ b/material/projetos/2021-2/paralelismo-gpu.md
@@ -0,0 +1,20 @@
+# Paralelismo em GPU
+
+Seu trabalho nesta atividade será criar uma implementação paralela em GPU do algoritmo de busca local.
+
+## Compilação do programa
+
+Você deverá colocar o código de seu programa em um arquivo com extensão *.cu* na pasta da busca local. Este programa será compilado com `nvcc -O3`.
+
+Para a entrega, usaremos o site **codePost**.
+
+
+
+
+
+ -->
diff --git a/material/projetos/2021-2/paralelismo-multicore.md b/material/projetos/2021-2/paralelismo-multicore.md
new file mode 100644
index 000000000..b38b73255
--- /dev/null
+++ b/material/projetos/2021-2/paralelismo-multicore.md
@@ -0,0 +1,26 @@
+# Paralelismo multi-core
+
+Seu trabalho nesta atividade será criar uma implementação paralela do algoritmo de busca local.
+
+## Compilação do programa
+
+Seu programa multi-core deverá ser gerado a partir do mesmo código fonte do sequencial. Ou seja, compilar com `-fopenmp` habilita o programa paralelo. Compilar sem essa flag obtem os resultados sequenciais. Caso seu programa use as chamadas do OpenMP para códigos auxiliares (alocação de memória, etc), você pode checar se seu programa foi compilado com esta flag seguindo o exemplo abaixo.
+
+```cpp
+#ifdef _OPENMP
+ // código específico para multi-core aqui
+#else
+ // código específico para sequencia aqui
+#endif
+```
+
+Para a entrega, usaremos o site **codePost**.
+
diff --git a/material/projetos/2021-2/relatorio-1.md b/material/projetos/2021-2/relatorio-1.md
new file mode 100644
index 000000000..8a5d7c67f
--- /dev/null
+++ b/material/projetos/2021-2/relatorio-1.md
@@ -0,0 +1,15 @@
+# Relatório - v1
+
+Nesta primeira parte do relatório iremos analisar as implementações já criadas com relação a sua velocidade e qualidade da solução. Os objetivos deste relatório são
+
+* criar entradas de tamanho adequado para os propósitos dos testes
+* estudar o efeito do número de pessoas e do número de objetos nas medidas de interesse (tempo e qualidade da solução)
+* comparar o desempenho dos algoritmos implementados até o momento em relação a essas duas medidas.
+
+Seu trabalhou deverá ser entregue como um arquivo *PDF* chamado *relatorio-intermediario.pdf* na pasta *relatorios* do repositório. Ele poderá ser gerado a partir de um Jupyter notebook (como feito na [aula 01](/aulas/01-introducao)) ou usando a ferramenta [pweave](https://mpastell.com/pweave/) (**recomendado**). A rubrica de avaliação está disponível abaixo e [também neste link](rubrica-relatorio.pdf).
+
+Data de entrega: 31/10/2021, pelo blackboard.
+
+
+
+
diff --git a/material/projetos/2021-2/rubrica-relatorio.pdf b/material/projetos/2021-2/rubrica-relatorio.pdf
new file mode 100644
index 000000000..c754ec25a
Binary files /dev/null and b/material/projetos/2021-2/rubrica-relatorio.pdf differ
diff --git a/material/projetos/2021-2/rubrica.ods b/material/projetos/2021-2/rubrica.ods
new file mode 100644
index 000000000..0012b82e5
Binary files /dev/null and b/material/projetos/2021-2/rubrica.ods differ
diff --git a/material/projetos/2022-1/README.md b/material/projetos/2022-1/README.md
new file mode 100644
index 000000000..faa56036a
--- /dev/null
+++ b/material/projetos/2022-1/README.md
@@ -0,0 +1 @@
+# Enunciados dos projetos de Supercomputação do 1o. Semestre/2022
diff --git a/material/projetos/2022-1/SequenceGenerator.ipynb b/material/projetos/2022-1/SequenceGenerator.ipynb
new file mode 100644
index 000000000..9c981c515
--- /dev/null
+++ b/material/projetos/2022-1/SequenceGenerator.ipynb
@@ -0,0 +1,74 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "SequenceGenerator.ipynb",
+ "provenance": [],
+ "collapsed_sections": []
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "**GERADOR DE INSTÂNCIAS PARA COMPARAÇÃO DE SEQUENCIAS DE DNA**\n",
+ "\n",
+ "Para usar este gerador, você deve fornecer três parâmetros:\n",
+ "\n",
+ "n = tamanho da primeira sequencia \n",
+ "\n",
+ "m = tamanho da segunda instância \n",
+ "\n",
+ "file = nome do arquivo da instância a ser gerada"
+ ],
+ "metadata": {
+ "id": "L2gAYBjX_MBM"
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "_s7Cbahf_LId",
+ "outputId": "1ac73e4b-1f04-4170-d159-bb3a861bc4d6"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "10\n",
+ "40\n",
+ "TGGCGAT--C\n",
+ "AGC-TCTCTTC--ATT--CAC-TACACCGACA-CGC-G-A\n"
+ ]
+ }
+ ],
+ "source": [
+ "import random\n",
+ "n = 10\n",
+ "m = 40\n",
+ "file = 'dna.seq'\n",
+ "f = open(file, 'w')\n",
+ "seq=[str(n)+'\\n',\n",
+ " str(m)+'\\n',\n",
+ " ''.join(random.choices(['A','T','C','G','-'],k=n))+'\\n',\n",
+ " ''.join(random.choices(['A','T','C','G','-'],k=m))]\n",
+ "f.writelines(seq)\n",
+ "f.close()\n",
+ "print(''.join(seq))"
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/material/projetos/2022-1/alignment.png b/material/projetos/2022-1/alignment.png
new file mode 100644
index 000000000..8d047cd14
Binary files /dev/null and b/material/projetos/2022-1/alignment.png differ
diff --git a/material/projetos/2022-1/heuristico.md b/material/projetos/2022-1/heuristico.md
new file mode 100644
index 000000000..27191eec9
--- /dev/null
+++ b/material/projetos/2022-1/heuristico.md
@@ -0,0 +1,64 @@
+
+# Heurística de Alinhamento Local de Smith-Waterman
+
+Um algoritmo ingênuo para fazer o alinhamento local de duas sequencias de DNA poderia ser:
+
+1. Gere todas as subsequências, de tamanho 1 até o tamanho total de cada sequência
+2. Compare todos os pares de subsequencias, sempre escolhendo uma subsequencia de um DNA e do outro DNA, calculado seus scores
+3. Escolha uma que produza o score máximo
+
+Nao é difícil ver que este algoritmo ingênuo pode demorar muito tempo para executar quando aumentamos o tamanho das sequencias de DNA.
+
+Uma heurística sequencial bastante interessante para reduzir o tempo de obtenção dos alinhamentos foi proposta por Smith e Waterman (1981), utilizando programação dinâmica.
+Abaixo, temos a descrição do algoritmo desta estratégia:
+
+ALGORITMO SMITH-WATERMAN
+Entrada: Duas sequencias de DNA a[i] e b[j], de tamanhos n e m respectivamente
+Saída: score máximo de alinhamento
+
+1. Inicializar H[i,0]=0, 0≤i≤n
+2. Inicializar H[0,j]=0, 0≤j≤m
+3. Para cada 1≤i≤n e 1≤j≤m:
+4. Calcular diagonal = H[i-1,j-1] + w(a[i],b[j]), onde w(a[i],b[j])=2 se houve match,
+ w(a[i],b[j])= -1 se houve mismatch e
+ w(a[i],b[j])= -1 se houve gap
+5. Calcular deleção = H[i-1,j] - 1
+6. Calcular inserção = H[i,j-1] - 1
+7. Calcular H[i,j]=máximo (0, diagonal, deleção, inserção)
+9. Retornar o máximo de H[_,_]
+
+
+Os passos diagonal, deleção e inserção são chamados, respectivamente, de salto em diagonal, salto de cima para baixo e salto da esquerda para a direita, e representam movimentações para obtenção do alinhamento local ótimo.
+
+No link abaixo, é possível simular este algoritmo para diversos valores de pesos:
+
+http://rna.informatik.uni-freiburg.de/Teaching/index.jsp?toolName=Smith-Waterman
+
+
+Abaixo temos um exemplo da matriz H calculada para as sequências AGCACACA e ACACACTA:
+
+
+
+Para obter o alinhamento local ótimo, começamos com o maior valor na matriz (i,j). Então, nós vamos para trás para uma das posições (i-1,j), (i,j-1) ou (i-1,j-1), dependendo da direção de movimento usado para construir a matriz. Mantemos o processo até chegar a um célula da matriz com valor zero, ou o valor na posição (0,0).
+
+No exemplo, o valor mais alto corresponde à célula na posição (8,8). A caminhada de volta corresponde a (8,8), (7,7), (7,6), (6,5), (5,4), (4,3), (3,2), (2,1), (1,1), e (0,0),
+
+Uma vez que tenhamos terminado, reconstruimos o alinhamento da seguinte forma: Começando com o último valor, chegamos a (i,j) usando o caminho previamente calculado. Um salto na diagonal implica que há um alinhamento (ou uma correspondência ou uma não correspondência). Um salto de cima para baixo implica que há uma deleção. Um salto da esquerda para a direita implica que há uma inserção. *Assim, para a reconstrução, é importante guardar durante a montagem da tabela H qual o tipo de salto foi utilizado.*
+
+Para o exemplo das sequencias acima, obtemos o seguinte alinhamento local ótimo (em relação aos pesos dados para match, mismatch e gap):
+
+
+Sequência 1 = A-CACACTA
+Sequência 2 = AGCACAC-A
+
+
+A partir desta descrição, nosso primeiro projeto terá duas tarefas:
+
+
+ - Implementar um programa C++ para ler um arquivo contendo os tamanhos de duas sequencias de DNA, seguidos das duas sequencias, uma por linha. Calcular o score máximo de alinhamento local usando a heurística de Smith-Waterman. As informações para reconstrução deverão ser armazenadas no formato de struct.
+
- a partir do score máximo, reconstruir e exibir o alinhamento local ótimo das duas sequencias.
+
+
+No diretório do projeto, há um gerador de entradas disponibilizado como um notebook Python.
+
+Para quem estiver interessado no artigo original da heurística de Smith-Waterman, basta consultar o link http://arep.med.harvard.edu/pdf/Smith81.pdf.
diff --git a/material/projetos/2022-1/index.md b/material/projetos/2022-1/index.md
new file mode 100644
index 000000000..107361bbe
--- /dev/null
+++ b/material/projetos/2022-1/index.md
@@ -0,0 +1,120 @@
+# Alinhamento de Sequencias de DNA
+
+Em Bioinformática, o problema de **alinhamento de sequências de DNA** consiste no processo de comparar duas ou mais sequências de bases de forma a se observar seu nível de similaridade. Trata-se de um problema extremamente importante no contexto atual, pois permite comparar sequencias virais de SARS-COV2 em bancos de dados genômicos para detecção de novas mutações.
+
+O nível de similaridade pode ser calculado com base em **acertos (match)** e **erros (gap e mismatch)**. Os acertos contribuem com sinal positivo (+) para o nível de similaridade e, os erros, com sinal negativo (-). Abaixo temos um exemplo de cálculo do nível similaridade:
+
+
+
+Vamos associar a pontuação **+1 (match)** e as penalidades **-1 (gap)** e **-4 (mismatch)**. Assim, teremos o seguinte nível de similaridade:
+
+23 matches x (+1) + 4 gaps x (-1) + 3 mismatches x (-4) = 23-4-12 = 7
+
+Neste contexto, o problema de alinhamento de sequencias de DNA pode ser colocado da seguinte forma:
+
+```
+Dadas duas sequencias de DNA, com as bases A,T,G,C e - para indicar gap,
+encontrar o alinhamento que maximize o nível de similaridade.
+```
+
+
+Neste projeto, seu objetivo será construir programas para encontrar este alinhamento de nível máximo de similaridade, utilizando várias estratégias.
+
+Cada um dos seus programas tomará como entrada a seguinte estrutura: a primeira linha contém dois números `n` e `m`, onde `n` é o tamanho da primeira sequencia e, `m`, o tamanho da segunda. Assuma `n ≤ 200` e `m ≤ 200`. A segunda linha contém as bases da primeira sequencia e, a terceira linha, as bases da segunda.
+
+```
+5 7
+AT-CC
+TTTCCAA
+```
+
+A saída deve ser uma linha com um número inteiro indicando o nível máximo de similaridade.
+
+```
+2
+```
+Neste caso, este nível máximo de similaridade pode ser associado ao alinhamento T-CC/TTCC (1-1+1+1=2) ou a CC/CC(1+1=2). Você pode usar o notebook SequenceGenerator.ipynb para gerar instâncias aleatórias para seus testes.
+
+
+
+## Estratégias a serem estudadas e correção automática
+
+Para cada estratégia que vamos estudar, implementaremos um programa correspondente no projeto. Veja abaixo as datas de entrega e descrições de cada estratégia a ser implementada. Em geral, o enunciado de uma parte é liberado após a data de entrega da parte anterior.
+
+1. [Solução Heurística](heuristico.md) (18/03)
+2. [Busca Local](busca-local)(01/04)
+3. [Busca Exaustiva](busca-exaustiva)(15/04)
+4. [Relatório Preliminar](relatorio-1) (29/04)
+5. [Paralelismo Multicore](paralelismo-multicore) (13/05)
+6. [Paralelismo GPU](paralelismo-gpu) (27/05)
+7. [Relatório Final](relatorio-2) (03/06)
+
+
+
+
+## Avaliação
+
+O projeto será avaliado usando rubricas para as entregas básicas. As rubricas de avaliação dos relatórios estarão descritas em suas páginas de entrega.
+
+### Conceito D
+
+Algum dos seguintes itens não foi entregue corretamente ou possui problemas sérios (no caso do relatório final).
+
+1. Solução heurística
+2. Busca local
+3. Busca exaustiva
+4. Busca local paralela (CPU)
+5. Busca local paralela (GPU)
+6. Relatório preliminar
+7. Relatório final
+
+
+### Conceito C
+
+Todas as atividades abaixo foram validadas pelo corretor e (no caso do relatório final) alcançaram qualidade mínima exigida.
+
+1. Solução heurística
+2. Busca local
+3. Busca exaustiva
+4. Busca local paralela (CPU)
+5. Busca local paralela (GPU)
+6. Relatório preliminar
+7. Relatório final
+
+### Conceito C+
+
+Além do já validado no conceito **C**, os relatórios entregues não tinham nenhum ponto **em desenvolvimento** ou **insatisfatório** na rubrica do relatório.
+
+### Conceitos avançados
+
+A partir do conceito **C+** cada atividade avançada vale meio conceito. Elas serão listadas aqui conforme o semestre avança e serão testadas pela checagem de resultados disponível no repositório de entregas.
diff --git a/material/projetos/2022-1/smith.png b/material/projetos/2022-1/smith.png
new file mode 100644
index 000000000..181d30458
Binary files /dev/null and b/material/projetos/2022-1/smith.png differ
diff --git a/material/projetos/alignment.png b/material/projetos/alignment.png
new file mode 100644
index 000000000..8d047cd14
Binary files /dev/null and b/material/projetos/alignment.png differ
diff --git a/material/projetos/exaustiva.md b/material/projetos/exaustiva.md
new file mode 100644
index 000000000..8d8074f29
--- /dev/null
+++ b/material/projetos/exaustiva.md
@@ -0,0 +1,34 @@
+# Busca Exaustiva para Alinhamento de Sequencias
+
+A busca exaustiva, conforme vista aula, gera todas as soluções viáveis para um problema e, de acordo com um critério de otimalidade, elege uma
+solução ótima para o problema. Especificamente para o problema de alinhamento de sequencias, ele pode ser especificado da seguinte forma:
+
+
+ ALGORITMO BUSCA EXAUSTIVA
+ Entrada: Duas sequencias de DNA a e b
+ Pesos wmat, wmis e wgap para match, mismatch e gap respectivamente
+ Saída: Score de um alinhamento das sequencias
+ Subsequencias alinhadas
+
+ 1. Gerar todas as subsequencias a´ e b´ não-nulas de a e b, respectivamente.
+ 2. Calcular os alinhamentos de cada par de subsequencias (a´, b´) com os pesos wmat, wmis e wgap
+ 3. Devolver o score máximo m entre os scores do passo (2) e as subsequencias associadas a ele
+
+
+Observe que, no passo (2), as subsequencias podem não ter o mesmo tamanho. Assim, não será possível calcular diretamente um score simples. Podemos usar, por exemplo:
+
+
+ - a estratégia vista no primeiro projeto (Alinhamento Local de Smith-Waterman) para comparar duas subsequencias
+
- um truncamento da subsequencia maior pelo tamanho da subsequencia menor e calcular o score simples entre as duas subsequencias resultantes
+
- o Alinhamento Local de Smith-Waterman quando as subsequencias forem de tamanhos diferentes e, quando forem de tamanho igual, a estratégia aleatória do Projeto II.
+
+
+
+A partir desta descrição, nosso terceiro projeto terá duas tarefas:
+
+
+ - Implementar um programa C++ para ler um arquivo contendo os tamanhos de duas sequencias de DNA, seguidos das duas sequencias, uma por linha. Calcular o score máximo utilizando o algoritmo acima, assim como as subsequencias associadas a ele.
+
- Implementar duas estratégias diferentes para calcular os alinhamentos entre os pares de subsequencias do passo (2).
+
+No diretório do projeto, há um gerador de entradas disponibilizado como um notebook Python. Como se trata de uma busca exaustiva, recomenda-se começar a testar com tamanhos pequenos e
+ ir aumentando gradativamente até atingir o tamanho máximo que a sua plataforma ainda consiga executar.
diff --git a/material/projetos/gpu.md b/material/projetos/gpu.md
new file mode 100644
index 000000000..17796f9c6
--- /dev/null
+++ b/material/projetos/gpu.md
@@ -0,0 +1,69 @@
+# Paralelismo com GPU
+
+Neste último projeto, vamos explorar os mecanismos de paralelismo multicore com GPU. Para tanto, vamos considerar a implementação da busca exaustiva que vimos, na análise realizada
+no relatório parcial, ter o desempenho bastante comprometido quando trabalhamos com tamanhos de sequencias de DNA muito grandes.
+
+Na busca exaustiva, existe um procedimento básico que é realizado para cada par de subsequencias que estão sendo analisadas: cálculo do score. Relembrando o algoritmo de Smith-Waterman, nós temos que o score de alinhamento entre duas sequências S1 e S2 é dado por:
+
+$$
+S_{i,j} = max\begin{Bmatrix}
+S_{i-1, j-1} + 2, & a_i = b_j \\
+S_{i-1, j-1} - 1, & a_i \neq b_j\\
+S_{i-1, j} - 1 & b_j = -\\
+S_{i, j-1} - 1 & a_i = -\\
+0 &
+\end{Bmatrix}
+$$
+
+A operação `max` é associativa e comutativa, o que indica que nós podemos calcula de maneira paralelizada. Na prática, observe que o cálculo do score só depende da linha anterior, de modo que não é preciso ter toda a matriz carregada na memória, quando nosso objetivo é obter o melhor score.
+
+Podemos dividir esse cálculo de score em duas fases, a partir da linha anterior. Para isso, precisamos de duas estrututas de armazenamento, uma estrutura para armazenar o resultado do cálculo da linha anterior, e uma estrutura para receber temporariamente o resultado (primeira fase), e posteriormente ser atualizada (segunda fase).
+
+
+A primeira fase poderia ser chamada de $S_{temp}$ e poderia ser calculada da seguinte maneira:
+
+$$
+S_{temp}(i,j) = max\begin{Bmatrix}
+S_{i-1, j-1} + 2, & a_i = b_j \\
+S_{i-1, j-1} - 1, & a_i \neq b_j\\
+S_{i, j-1} - 1 & b_j = -\\
+0 &
+\end{Bmatrix}
+$$
+
+Você pode implementar essa primeira fase como uma transformação. A segunda fase seria então fazer calcular o máximo entre $S_{temp}$ e a lateral direita:
+
+$$
+S_{i,j} = max\begin{Bmatrix}
+S_{temp}(i,j) & \\
+S_{temp}(i-1, j) - 1 & \\
+0 &
+\end{Bmatrix}
+$$
+
+Dessa forma, podemos:
+
+
+
+ 
+
+