<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Codingpedia</title><link>http://docs.codingferpa.org/</link><description>Recent content on Codingpedia</description><generator>Hugo</generator><language>pt-br</language><lastBuildDate>Wed, 16 Apr 2025 00:00:00 +0000</lastBuildDate><atom:link href="http://docs.codingferpa.org/index.xml" rel="self" type="application/rss+xml"/><item><title>.3. TCP</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/8.3.-tcp/</link><pubDate>Wed, 16 Apr 2025 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/8.3.-tcp/</guid><description>&lt;h1 id="visao-geral">Visao Geral &lt;a href="#visao-geral" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>Processo a processo.&lt;/li>
&lt;li>entrega fluxo de bytes de forma ordenada e confiável&lt;/li>
&lt;li>dutado (pipelined)&lt;/li>
&lt;li>buffers de envio e recepção, e statefull.&lt;/li>
&lt;li>O trafego eh Full Duplex (bi-direcional na mesma conexão)&lt;/li>
&lt;li>orientado a conexão
&lt;ul>
&lt;li>Handshaking de 3 vias e verifica estados do emissor/receptor antes de trocar dados.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>fluxo controlado: receptor nao eh afogado.&lt;/li>
&lt;li>cliente: inicia conexão -&amp;gt; active open&lt;/li>
&lt;li>servidor -&amp;gt; passive open&lt;/li>
&lt;/ul>
&lt;h1 id="estrutura-do-header">Estrutura do Header &lt;a href="#estrutura-do-header" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>No. Porta orig/dest (16 bits cada)&lt;/li>
&lt;li>Nro de Sequencia (32 bits) -&amp;gt; receptor indica no ack o próximo nro de seq.&lt;/li>
&lt;li>Nro de Confirmacao (32 bits)&lt;/li>
&lt;li>tamanho do header (5 bits usualmente)&lt;/li>
&lt;li>bits unicos
&lt;ul>
&lt;li>U(rgent)&lt;/li>
&lt;li>A(ck)&lt;/li>
&lt;li>P(ush) -&amp;gt; nao bufferiza pacote&lt;/li>
&lt;li>R(eset), S(ync) e F(inal) -&amp;gt; focados em conexão&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>janela receptor (16 bits) -&amp;gt; controle de fluxo e congestionamento&lt;/li>
&lt;li>checksum (16 bits)&lt;/li>
&lt;li>ptr dados urgentes (16 bits)&lt;/li>
&lt;/ul>
&lt;h1 id="mss-maximum-segment-size-e-numeração-de-segmentos">MSS (Maximum Segment Size) e numeração de segmentos &lt;a href="#mss-maximum-segment-size-e-numera%c3%a7%c3%a3o-de-segmentos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Representa o tamanho de maior bloco de dados que o TCP permite enviar num unico segmento (definido pelo maximo transporte da camada de enlace).&lt;/p></description></item><item><title>.2. Protocolos Dutados</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/8.2.-protocolos-dutados/</link><pubDate>Tue, 15 Apr 2025 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/8.2.-protocolos-dutados/</guid><description>&lt;h1 id="problemas-com-stop-e-wait">Problemas com stop e wait &lt;a href="#problemas-com-stop-e-wait" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;blockquote>
&lt;p>[!attention] Problemas com o protocolo stop and wait.&lt;/p>
&lt;p>atraso fim a fim eh grande
pacotes podem estar em transito e sem o ACK&lt;/p>&lt;/blockquote>
&lt;h4 id="desempenho-do-rdt-30">Desempenho do RDT 3.0 &lt;a href="#desempenho-do-rdt-30" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h4>&lt;ul>
&lt;li>desempenho do Emissor ($U_{sender}$)&lt;/li>
&lt;li>relacao entre o tempo para transmitir o pacote e o tempo para receber o ACK.&lt;/li>
&lt;/ul>
&lt;p>$$U_{sender}= \frac{L/R}{RTT+L/R}$$
tempo de transição do pacote emitido / (Rounded time + tempo de transicao do pacote de acknowledge)&lt;/p></description></item><item><title>.1 Reliable Data Transfer</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/8.1-reliable-data-transfer/</link><pubDate>Wed, 09 Apr 2025 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/8.1-reliable-data-transfer/</guid><description>&lt;h1 id="reliable-data-transfer">Reliable Data Transfer &lt;a href="#reliable-data-transfer" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Objetivo: criar uma conexão totalmente confiável entre 2 processos.&lt;/p>
&lt;p>O RDT funciona através de fazer a saída de dados de um processo de maneira confiável, em um canal não confiável de dados.&lt;/p>
&lt;p>Suposição: o canal de comunicação é perfeitamente confiável.&lt;/p>
&lt;ul>
&lt;li>Sem erros de bits.&lt;/li>
&lt;li>Sem perda de pacotes.&lt;/li>
&lt;/ul>
&lt;p>Funcionamento:&lt;/p>
&lt;ul>
&lt;li>O remetente simplesmente envia os dados pelo canal.&lt;/li>
&lt;li>O receptor apenas recebe os dados e os entrega para a camada superior.&lt;/li>
&lt;/ul>
&lt;p>Eventos:&lt;/p></description></item><item><title>. Camada-de-Transporte</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/8.-camada-de-transporte/</link><pubDate>Tue, 08 Apr 2025 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/8.-camada-de-transporte/</guid><description>&lt;p>Eh papel da camada de Transporte fazer a ligação entre processos (sockets). Ela permite a aplicação enxergar os sistemas como se eles estivessem fisicamente conectados.&lt;/p>
&lt;p>Em contraponto a camada de redes (sera vista no próximo capitulo), que interliga hosts, esta camada interliga &lt;strong>processos&lt;/strong>.&lt;/p>
&lt;h2 id="multiplexação">Multiplexação &lt;a href="#multiplexa%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;blockquote>
&lt;p>[!done]&lt;/p>
&lt;p>Multiplexacao: MUX - DEMUX -&amp;gt; afunilar canais de transmissao em um grande &amp;ldquo;tubo&amp;rdquo; e conseguir identificar cada um deles na saida deste &amp;ldquo;tubo&amp;rdquo;.&lt;/p></description></item><item><title>. Gramatica</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/2.-gramatica/</link><pubDate>Sat, 05 Apr 2025 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/2.-gramatica/</guid><description>&lt;h3 id="gramatica">Gramatica &lt;a href="#gramatica" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;p>$G = (V, \Sigma, P, S)$&lt;/p>
&lt;ul>
&lt;li>Onde V eh um conjunto finito de variaveis..&lt;/li>
&lt;li>$\Sigma$ eh um conjunto finito de objetos chamados simbolos terminais.&lt;/li>
&lt;li>$S \in V$ eh um simbolo especial chamado de variavel inicial.&lt;/li>
&lt;li>P eh um conjunto finito de producoes.&lt;/li>
&lt;/ul>
&lt;h4 id="producao">producao &lt;a href="#producao" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h4>&lt;p>As regra de produção são o coração da gramatica, pois especificam maneiras de transformar uma cadeia em outra, associando uma linguagem a gramatica.&lt;/p>
&lt;p>Uma producao altera uma string ou substring, portanto, se a producao eh:&lt;/p></description></item><item><title>. header</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/teoria-dos-grafos/0.-header/</link><pubDate>Sat, 05 Apr 2025 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/teoria-dos-grafos/0.-header/</guid><description>&lt;p>Muito provavelmente nao utilizarei as notas de Teoria dos grafos digitalmente, como de costume, prefiro anotar matematica no caderno.&lt;/p>
&lt;ol>
&lt;li>Elementos da Teoria dos Grafos: Formulação de problemas em grafos; Alguns tipos de grafos: simples, completos, bipartidos; Isomorfismo.&lt;/li>
&lt;li>Caminhos e Circuitos: Subgrafos; Trajetos, caminhos e circuitos; Grafos conexos.&lt;/li>
&lt;li>Grafos Orientados: Conceitos básicos; Torneios.&lt;/li>
&lt;li>Grafos e Algoritmos: Representação de grafos; Introdução à complexidade computacional.&lt;/li>
&lt;li>Problema do Caminho Mínimo: Algoritmo de Dijkstra.&lt;/li>
&lt;li>Grafos Eulerianos.&lt;/li>
&lt;li>Grafos Hamiltonianos.&lt;/li>
&lt;li>Árvores: Propriedades; Árvores geradoras; Árvores binárias.&lt;/li>
&lt;li>Conjunto de Cortes: Corte-vértice; Corte-aresta; Corte fundamental.&lt;/li>
&lt;li>Conectividade: Conectividade de vértices; Conectividade de arestas.&lt;/li>
&lt;li>Fluxo Máximo em Redes: Conceitos básicos; O Algoritmo de Ford-Fulkerson.&lt;/li>
&lt;li>Grafos Planares: Teorema de Kuratowski; Fórmula de Euler.&lt;/li>
&lt;li>Coloração, Cobertura e Partição: Coloração pelo vértice; Coloração pela aresta; Casamento e cobertura.&lt;/li>
&lt;/ol>
&lt;hr>
&lt;h1 id="bibliografia">BIBLIOGRAFIA &lt;a href="#bibliografia" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;blockquote>
&lt;p>basicamente so essa aqui importa 1. Boaventura, P.O.: Grafos: Teoria, Modelos, Algoritmos. São Paulo: Edgard Blücher, 2006.&lt;/p></description></item><item><title>. Header</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/0.-header/</link><pubDate>Sat, 05 Apr 2025 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/0.-header/</guid><description/></item><item><title>. Header</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/0.-header/</link><pubDate>Sat, 05 Apr 2025 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/0.-header/</guid><description>&lt;h1 id="bibliografia">Bibliografia &lt;a href="#bibliografia" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ol>
&lt;li>Introducao a teoria de automatos e linguagem e computacao.&lt;/li>
&lt;li>An introduction to formal languagens and automata.&lt;/li>
&lt;/ol></description></item><item><title>. Tipos de Gramaticas</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/3.-tipos-de-gramaticas/</link><pubDate>Sat, 05 Apr 2025 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/3.-tipos-de-gramaticas/</guid><description>&lt;h2 id="0-gramatica-irrestrita">0. Gramatica Irrestrita &lt;a href="#0-gramatica-irrestrita" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Uma gramática é dita irrestrita (Tipo 0) quando suas produções seguem a forma:&lt;/p>
&lt;p>$$P = \lbrace \alpha \rightarrow \beta \ \Big| \ \alpha, \beta \in (V \cup \Sigma)^{*} \rbrace$$&lt;/p>
&lt;p>onde:&lt;/p>
&lt;ul>
&lt;li>$\alpha$ deve conter pelo menos um símbolo pertencente a $V$ (um símbolo não terminal).&lt;/li>
&lt;li>$\beta$ pertence ao conjunto $(V \cup \Sigma)^{*}$, ou seja, pode ser qualquer sequência de símbolos terminais e não terminais.&lt;/li>
&lt;/ul>
&lt;hr>
&lt;h3 id="1-gramática-sensível-ao-contexto-tipo-1">&lt;strong>1. Gramática Sensível ao Contexto (Tipo 1)&lt;/strong> &lt;a href="#1-gram%c3%a1tica-sens%c3%advel-ao-contexto-tipo-1" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;p>Uma gramática é dita &lt;strong>sensível ao contexto&lt;/strong> quando suas produções seguem a forma:&lt;/p></description></item><item><title>.Introducao</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/1.introducao/</link><pubDate>Sat, 05 Apr 2025 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/1.introducao/</guid><description>&lt;p>Esta aula se baseia no livro de Peter Linz - Introdution to Formal Languages and Automata&lt;/p>
&lt;h2 id="conceitos-basicos">Conceitos Basicos &lt;a href="#conceitos-basicos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>
&lt;p>&lt;em>simbolos&lt;/em>: sao utilizados na composicao de palavras/cadeias.&lt;/p>
&lt;/li>
&lt;li>
&lt;p>&lt;em>alfabetos&lt;/em>: um conjunto finito de simbolos.
-&amp;gt; podemos denotar um &lt;em>alfabeto&lt;/em> pelo simbolo grego $\Sigma$&lt;/p>
&lt;/li>
&lt;li>
&lt;p>&lt;em>cadeias/strings&lt;/em>: uma sequencia de tamanho determinada de simbolos justapostos.
-&amp;gt; podemos denotar uma cadeia por um simbolo contido no final do alfabeto greco-romano, como x, w, ou z, por exemplo.&lt;/p></description></item><item><title>.</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/1./</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/1./</guid><description/></item><item><title>.</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/2./</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/2./</guid><description/></item><item><title>. Arquitetura-de-um-Gerenciador</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/2.-arquitetura-de-um-gerenciador/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/2.-arquitetura-de-um-gerenciador/</guid><description>&lt;h2 id="i-linguagens">i. Linguagens &lt;a href="#i-linguagens" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>&lt;strong>Linguagem de definicao de dados (LDD)&lt;/strong>: eh a linguagem do sgbd que permite a especificacao dos esquemas. (altera o Nivel conceitual) Altera propriedades dos dados.&lt;/p>
&lt;p>&lt;strong>Linguagem de manipulacao de dados (LMD)&lt;/strong>: permite a manipulacao das instancias de dados. Ela permite:&lt;/p>
&lt;ul>
&lt;li>Consultas para resgatar informacao no DB.&lt;/li>
&lt;li>Permite a insercao de nova informacao no DB.&lt;/li>
&lt;li>Permite deletar informacao do DB.&lt;/li>
&lt;li>Permite modificacao de informacao.&lt;/li>
&lt;/ul>
&lt;h2 id="j-arquitetura-de-um-sgbd">j. Arquitetura de um sgbd &lt;a href="#j-arquitetura-de-um-sgbd" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>





 



 
 
 &lt;img src="http://docs.codingferpa.org/images/Cs/1742334509_grim.png" alt="sgbd arquitechture" width="784" height="953" loading="lazy">
 
 
&lt;/p></description></item><item><title>. Atrasos-e-Protocolos</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/4.-atrasos-e-protocolos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/4.-atrasos-e-protocolos/</guid><description>&lt;p>Este documento representa meus estudos acerca do livro Redes de Computadores e a Internet - uma abordagem top down&lt;/p>
&lt;hr>
&lt;h1 id="atrasos-e-protocolos">Atrasos e Protocolos &lt;a href="#atrasos-e-protocolos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;h2 id="atrasosdelays">Atrasos/Delays &lt;a href="#atrasosdelays" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Existem 4 causas para atrasos na entrega de um pacote, a qual pode ser mensurada por todos os enlaces.&lt;/p>
&lt;h3 id="processamento-d_proc">Processamento (d_proc) &lt;a href="#processamento-d_proc" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;p>Representa o tempo que o switch leva para examinar o &lt;em>header&lt;/em> do pacote e determinar o que fazer em seguida.&lt;/p>
&lt;ul>
&lt;li>todo roteador eh um dispositivo Store Foreward (batata quente kkk, pega e passa pro proximo).&lt;/li>
&lt;/ul>
&lt;h3 id="fila-d_queue">Fila (d_queue) &lt;a href="#fila-d_queue" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;p>Depende da quantidade de outros pacotes que chegam e que estavam, previamente, na fila.&lt;/p></description></item><item><title>. Auth</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/14.-auth/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/14.-auth/</guid><description>&lt;p>Nos referimos ao requerente ou usuário no contexto da autenticação como &lt;code>agente&lt;/code>, sendo este o responsável pelas ações em nome de um &lt;code>principal&lt;/code>, que é de fato quem interage com o sistema, seja humano ou não. Toda estrutura de dados usada para o gerenciamento de permissões e decisões como esta são chamados de &lt;code>credenciais&lt;/code>, que dão informações importantes para que o SO decida se o agente pode ou não acessar um &lt;code>objeto&lt;/code> da requisição.&lt;/p></description></item><item><title>. Automato-finito-nao-deterministico</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/5.-automato-finito-nao-deterministico/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/5.-automato-finito-nao-deterministico/</guid><description>&lt;h2 id="m--q-sigma-delta-q_0-f">Um Automato Finito Nao-deterministico N eh uma tupla:
$$M = (Q, \Sigma, \delta, q_{0}, F)$$ &lt;a href="#m--q-sigma-delta-q_0-f" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>$Q =$ Conjunto de estados&lt;/li>
&lt;li>$\Sigma =$ Alfabeto de entrada&lt;/li>
&lt;li>$\delta=$ função programa/função de transição&lt;/li>
&lt;li>$q_{0}=$ Estado Inicial ($q_{0}\in Q$)&lt;/li>
&lt;li>$F =$ Estados finais ($F \subset Q\times{\epsilon }$) // conjunto das partes de $Q$&lt;/li>
&lt;/ul>
&lt;p>diferencas:&lt;/p>
&lt;ul>
&lt;li>transicao pode ter a cadeia vazia.&lt;/li>
&lt;li>pode-se haver 2 transicoes com o mesmo simbolo do alfabeto e estados como entrada.&lt;/li>
&lt;li>definicao formal:
&lt;ul>
&lt;li>$\delta (q_{i}, a) = {q_j}$&lt;/li>
&lt;li>$\delta (q_{i}, \epsilon) = {q_j}$&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>tabela de transicao:&lt;/li>
&lt;/ul>
&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>&lt;/th>
 &lt;th>$v_0$&lt;/th>
 &lt;th>$v_1$&lt;/th>
 &lt;th>$\dots$&lt;/th>
 &lt;th>$v_n$&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>-&amp;gt; $q_0$&lt;/td>
 &lt;td>${q_4}$&lt;/td>
 &lt;td>${q_4}$&lt;/td>
 &lt;td>$\vdots$&lt;/td>
 &lt;td>$\vdots$&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>$\underline{q_1}$&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>${q_4}$&lt;/td>
 &lt;td>$\vdots$&lt;/td>
 &lt;td>$\vdots$&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>$\vdots$&lt;/td>
 &lt;td>$\vdots$&lt;/td>
 &lt;td>$\vdots$&lt;/td>
 &lt;td>$\vdots$&lt;/td>
 &lt;td>$\vdots$&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>$q_n$&lt;/td>
 &lt;td>$\dots$&lt;/td>
 &lt;td>$\dots$&lt;/td>
 &lt;td>$\dots$&lt;/td>
 &lt;td>$\vdots$&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table></description></item><item><title>. Automatos-finitos-deterministicos</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/4.-automatos-finitos-deterministicos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/4.-automatos-finitos-deterministicos/</guid><description>&lt;p>Um automato finito deterministico M é uma tupla:&lt;/p>
&lt;h2 id="m--q-sigma-delta-q_0-f">$$M = (Q, \Sigma, \delta, q_{0}, F)$$ &lt;a href="#m--q-sigma-delta-q_0-f" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>$Q =$ Conjunto de estados&lt;/li>
&lt;li>$\Sigma =$ Alfabeto de entrada&lt;/li>
&lt;li>$\delta=$ funcao programa/funcao de transicao&lt;/li>
&lt;li>$q_{0}=$ Estado Inicial ($q_{0}\in Q$)&lt;/li>
&lt;li>$F =$ Estados finais ($F \subset Q$)&lt;/li>
&lt;/ul>
&lt;p>Um Automato Finito tem 3 componentes essenciais:&lt;/p>
&lt;ul>
&lt;li>a) fita: unidade de entrada da cadeia, contem a informacao a ser processada pelo automato&lt;/li>
&lt;li>b) unidade de controle: reflete o estado corrente da maquina, possui uma unidade de leitura (cabeca de fita, a qual percorre serialmente a fita supracitada e interage com cada simbolo contido na cadeia)&lt;/li>
&lt;li>c) funcao programa: funcao que comanda a cabeca de leitura e os estados, ou seja, eh executado $n$ vezes pela unidade de controle.&lt;/li>
&lt;/ul>
&lt;h2 id="iteracoes-do-automato-finito-deterministico">Iteracoes do Automato Finito Deterministico &lt;a href="#iteracoes-do-automato-finito-deterministico" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ol>
&lt;li>cadeia eh escrita na fita&lt;/li>
&lt;li>nao se escreve na fita apos o inicio da execucao da funcao programa&lt;/li>
&lt;li>a cadeia ocupa a fita por inteiro&lt;/li>
&lt;li>nao ha memoria auxiliar, toda iteracao da um &amp;ldquo;flush&amp;rdquo; logico em toda informacao previamente carregada (e.g, o estado anterior se torna o atual, o simbolo anterior eh perdido e a cabeca, serialmente, avanca)&lt;/li>
&lt;/ol>
&lt;hr>
&lt;h1 id="representacoes-do-automato-finito">Representacoes do automato finito &lt;a href="#representacoes-do-automato-finito" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Ha tres tipos de representacao:&lt;/p></description></item><item><title>. Backbones-IXs-e-ISPs</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/6.-backbones-ixs-e-isps/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/6.-backbones-ixs-e-isps/</guid><description>&lt;p>Este documento representa meus estudos acerca do livro Redes de Computadores e a Internet - uma abordagem top down&lt;/p>
&lt;hr>
&lt;p>Os dispositivos são conectados aos provedores de internet (internet service providers - isp). Ests &lt;strong>ISP&amp;rsquo;s&lt;/strong> são interconectados.&lt;/p>
&lt;h1 id="sistemas-autônomos">Sistemas Autônomos &lt;a href="#sistemas-aut%c3%b4nomos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Coleção de redes separadas independentes mas interconectadas, cada uma delas gerenciadas como um único &lt;strong>domínio administrativo&lt;/strong>. Atualmente existem mais de 700K AS&amp;rsquo;s ativos no mundo.&lt;/p>
&lt;p>Esses &lt;em>AS&amp;rsquo;s&lt;/em> formam o transporte primário da internet. Cada uma dessas redes pode funcionar independentemente aos outros, entretanto, para se comunicarem, precisam seguir os protocolos que mencionamos previamente.&lt;/p></description></item><item><title>. Camada de Rede</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/9.-camada-de-rede/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/9.-camada-de-rede/</guid><description/></item><item><title>. Camada-de-Protocolos</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/5.-camada-de-protocolos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/5.-camada-de-protocolos/</guid><description>&lt;p>Este documento representa meus estudos acerca do livro Redes de Computadores e a Internet - uma abordagem top down&lt;/p>
&lt;hr>
&lt;p>A rede de computadores trabalha em conjunto com camadas, seja no cliente, ou no servidor, em que cada uma tem uma funcao especifica, que atua, para no final, a mensagem enviada possa ser recebida e enviada de maneira confiavel (a depender do protocolo).&lt;/p>
&lt;p>Utilizar camadas modulariza os components de forma a manter a atualizar os sistemas em caso de falhas ou necessidade de melhora. Alterar qualquer camada so altera a camada atual, desde q concentido por ambas as partes.&lt;/p></description></item><item><title>. Camadas-de-aplicacao</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/7.-camadas-de-aplicacao/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/7.-camadas-de-aplicacao/</guid><description>&lt;p>Este documento representa meus estudos acerca do livro Redes de Computadores e a Internet - uma abordagem top down&lt;/p>
&lt;hr>
&lt;h1 id="conceitos-fundamentais">Conceitos Fundamentais &lt;a href="#conceitos-fundamentais" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Aplicações são processos distribuídos que se comunicam.&lt;/p>
&lt;ul>
&lt;li>trocam mensagens&lt;/li>
&lt;li>rodam nos sistemas finais (endpoints ou sistemas na borda/edge)&lt;/li>
&lt;/ul>
&lt;h2 id="protocolo">Protocolo &lt;a href="#protocolo" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>protocolo da camada:&lt;/p>
&lt;ul>
&lt;li>não eh a aplicação.
&lt;ul>
&lt;li>eh apenas uma parte dela, o qual a aplicacao implementa.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>emissor: cria e emite msgs&lt;/li>
&lt;li>receptor: recebe msgs -&amp;gt; se alternam constantemente&lt;/li>
&lt;/ul>
&lt;p>ele define:&lt;/p></description></item><item><title>. Comutacao-de-pacotes</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/2.-comutacao-de-pacotes/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/2.-comutacao-de-pacotes/</guid><description>&lt;p>Este documento representa meus estudos acerca do livro Redes de Computadores e a Internet - uma abordagem top down&lt;/p>
&lt;blockquote>
&lt;p>neste documento, pularei a Comutacao de circuitos, dada em aula, pois nao julgo necessaria para os fins deste repo&lt;/p>&lt;/blockquote>
&lt;h1 id="comutacao-de-pacotes">Comutacao de Pacotes &lt;a href="#comutacao-de-pacotes" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Para entendermos a rede, precisamos focar, agora, no &lt;em>core&lt;/em> dela, seu nucleo.&lt;/p>
&lt;p>Multiplexacao: MUX - DEMUX -&amp;gt; afunilar canais de transmissao em um grande &amp;ldquo;tubo&amp;rdquo; e conseguir identificar cada um deles na saida deste &amp;ldquo;tubo&amp;rdquo;.&lt;/p></description></item><item><title>. Conceitos-Basicos</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/teoria-dos-grafos/1.-conceitos-basicos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/teoria-dos-grafos/1.-conceitos-basicos/</guid><description>&lt;h1 id="1-definicoes">1. Definicoes &lt;a href="#1-definicoes" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Um grafo G eh constituído por um conjunto V não vazia de vértices (ou nos), e uma família A de pares nao ordenados dos elementos de V, chamados de arestas. Denotamos um grafo por G(V, A) ou G.&lt;/p>
&lt;p>ex: a) V = ${v_1, v_2, v_3, v_4, v_5}$ e $A = {(v_{1}v_{2}), (v_{1}v_{2})}$.&lt;/p>
&lt;p>Podem ser representados por pontos e linhas (pares ordenados) entre eles.&lt;/p>
&lt;hr>
&lt;h1 id="2-conceitos-iniciais">2. Conceitos Iniciais &lt;a href="#2-conceitos-iniciais" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Propriedades em G(V, A), a = $(v_{i}, v_{j})$.&lt;/p></description></item><item><title>. Desenvolvimento-agil</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/3.-desenvolvimento-agil/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/3.-desenvolvimento-agil/</guid><description>&lt;h1 id="desenvolimento-agil-x-dirigido-a-planos">Desenvolimento Agil x Dirigido a planos &lt;a href="#desenvolimento-agil-x-dirigido-a-planos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>agil: considera o projeto e impl como atividades centrais no software.&lt;/li>
&lt;li>planos: identifica estagios distintos do processo de software com saidas de cada estagio, usadas no pŕoximo&lt;/li>
&lt;/ul>
&lt;p>qual escolher?&lt;/p>
&lt;blockquote>
&lt;p>planos: se o projeto for grande e se for preciso documentar tudo antes, sem feedback rapido do cliente ou sem a capacitacao completa e adequada da equipe de desenvolvimento.&lt;/p>
&lt;p>agil: caso contrario&lt;/p>&lt;/blockquote>
&lt;h1 id="desenvolimento-agil">Desenvolimento Agil &lt;a href="#desenvolimento-agil" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>filosofia do manifesto:&lt;/p></description></item><item><title>. Espacos-de-Memoria</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/4.-espacos-de-memoria/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/4.-espacos-de-memoria/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;h1 id="address-space">Address space &lt;a href="#address-space" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Para poder compartilhar memoria de forma eficiente e permitir distintos programas rodarem simultaneamente precisamos gerar a virtualizacao de memoria para cada programa de forma eficiente. Este espaco abstrato de memoria gerado eh chamado de &lt;strong>address space&lt;/strong> (espaco de enderecos).&lt;/p>
&lt;p>O &lt;strong>address space&lt;/strong> contem todo o estado de memoria do programa executado. O &lt;em>codigo&lt;/em> do programa esta no address space, assim como uma pilha que contem as chamadas de funcao, recursoes, variaveis locais e parametros. Ha tambem o heap que eh utilizado por padrao para alocacao dinamica de memoria.&lt;/p></description></item><item><title>. Evolução-de-Software</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/8.-evolu%C3%A7%C3%A3o-de-software/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/8.-evolu%C3%A7%C3%A3o-de-software/</guid><description>&lt;p>devemos fazer manutenção do software.&lt;/p>
&lt;p>solicitação de mudança -&amp;gt; análise de impacto -&amp;gt; planejamento de versões -&amp;gt; impl de mudanças -&amp;gt; liberação do sistema.&lt;/p>
&lt;ul>
&lt;li>correção de emergência&lt;/li>
&lt;/ul>
&lt;p>Leis de Lehman&lt;/p>
&lt;ol>
&lt;li>Mudança continua: mudar&lt;/li>
&lt;li>aumento de complexidade: deve-se sempre manter a estrutura atual o máximo possível&lt;/li>
&lt;li>&lt;/li>
&lt;li>Estabilidade organizacional&lt;/li>
&lt;li>Conservação de familiaridade&lt;/li>
&lt;/ol></description></item><item><title>. Expressoes-Regulares</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/8.-expressoes-regulares/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/8.-expressoes-regulares/</guid><description>&lt;p>Dizemos que $R$ é uma expressão regular se $R$ é:&lt;/p>
&lt;ol>
&lt;li>$a \in \Sigma$&lt;/li>
&lt;li>$\varepsilon$&lt;/li>
&lt;li>$\emptyset$&lt;/li>
&lt;li>$(R_1 \cup R_2), R_1 \text{ e } R_2 \text{ expressões regulares}$&lt;/li>
&lt;li>$R_1 R_2$&lt;/li>
&lt;li>$R_1*$&lt;/li>
&lt;/ol>
&lt;p>Se $R=a$ é uma ER então $L(R)={a}$.&lt;/p>
&lt;p>Se $R=\varepsilon$ é uma ER então $L(R)={ \varepsilon }$.&lt;/p>
&lt;p>Se $R=\emptyset$ é uma ER então $L(R)={\emptyset}$.&lt;/p>
&lt;p>E se quiser escrever a expressão regular que denota $L={a,b}$?&lt;/p>
&lt;p>$R=a|b$&lt;/p>
&lt;p>Se $R_1$ e $R_2$ são ERs, $L(R_1/R_2)=L(R_1)\cup L(R_2)$.&lt;/p></description></item><item><title>. Gerencia-de-Projeto</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/4.-gerencia-de-projeto/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/4.-gerencia-de-projeto/</guid><description>&lt;h1 id="gerência-de-projeto-de-software">Gerência de Projeto de Software &lt;a href="#ger%c3%aancia-de-projeto-de-software" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;h2 id="importância">Importância &lt;a href="#import%c3%a2ncia" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>bom gerenciamento &lt;strong>não garante sucesso&lt;/strong>, mas &lt;strong>mau gerenciamento quase sempre leva ao fracasso&lt;/strong>.&lt;/li>
&lt;li>objetivos principais:
&lt;ul>
&lt;li>entregar &lt;strong>no prazo&lt;/strong>&lt;/li>
&lt;li>manter &lt;strong>dentro do orçamento&lt;/strong>&lt;/li>
&lt;li>&lt;strong>atender expectativas do cliente&lt;/strong>&lt;/li>
&lt;li>&lt;strong>manter equipe motivada e funcional&lt;/strong>&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;h2 id="desafios">Desafios &lt;a href="#desafios" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>produto é &lt;strong>intangível&lt;/strong>&lt;/li>
&lt;li>&lt;strong>ausência de processos padrão&lt;/strong>&lt;/li>
&lt;li>projetos de software são &lt;strong>únicos e influenciados por mudanças tecnológicas&lt;/strong>&lt;/li>
&lt;/ul>
&lt;hr>
&lt;h2 id="os-4-ps-da-gerência">Os 4 P’s da Gerência &lt;a href="#os-4-ps-da-ger%c3%aancia" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ol>
&lt;li>
&lt;p>&lt;strong>Pessoas&lt;/strong>&lt;/p>
&lt;ul>
&lt;li>qualificação, motivação, trabalho em equipe&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>
&lt;p>&lt;strong>Produto&lt;/strong>&lt;/p></description></item><item><title>. header</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/0.-header/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/0.-header/</guid><description>&lt;h1 id="aulas">Aulas &lt;a href="#aulas" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>Número&lt;/th>
 &lt;th>Tópico&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>1&lt;/td>
 &lt;td>Processos&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>2&lt;/td>
 &lt;td>Escalonamento&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>3&lt;/td>
 &lt;td>Um pouco mais sobre escalonamento&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>4&lt;/td>
 &lt;td>Hierarquia de memória, modos de enderecamento&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>5&lt;/td>
 &lt;td>Alocação de espaços, espaços contíguos&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>6&lt;/td>
 &lt;td>Memoria paginada&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>7&lt;/td>
 &lt;td>Memória virtual&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>8&lt;/td>
 &lt;td>Aspectos de desempenho&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>9&lt;/td>
 &lt;td>Concorrência, exclusão mutua&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>10&lt;/td>
 &lt;td>Semáforos&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>11&lt;/td>
 &lt;td>Sincronismo&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>12&lt;/td>
 &lt;td>Problemas Classicos&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>13&lt;/td>
 &lt;td>Deadlocks&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>14&lt;/td>
 &lt;td>Gerenciamento de entrada/saída&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>15&lt;/td>
 &lt;td>Entrada/saída para disco&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>16&lt;/td>
 &lt;td>Entrada/saída para SSD&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>17&lt;/td>
 &lt;td>Discos RAID&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>18&lt;/td>
 &lt;td>Sistema de arquivos&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>19&lt;/td>
 &lt;td>Autenticação e privacidade&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>20&lt;/td>
 &lt;td>Proteção de dados&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>21&lt;/td>
 &lt;td>Arquivos e diretórios&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>22&lt;/td>
 &lt;td>Implementação de sistemas de arquivos&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>23&lt;/td>
 &lt;td>Sistemas de arquivos distribuídos&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;h2 id="bibliografia">Bibliografia &lt;a href="#bibliografia" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Operating Systems: Three Easy Pieces, Renzi H. Arpaci-Dusseau, Andrea C. Arpaci-Dusseau and Peter Reiher&lt;/p></description></item><item><title>. Header</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/0.-header/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/0.-header/</guid><description>&lt;p>Neste curso, utilizei-me do livro Sistemas de Banco de dados - Abraham SILBERSCHATZ, Abraham SILBERSCHATZ S. KORTH Henry F. SUDARSHAN.&lt;/p>
&lt;p>Em suma, tratareos dos seguintes temas:&lt;/p>
&lt;ul>
&lt;li>Introducao&lt;/li>
&lt;li>Arquitetura de um Sistema Gerenciador de banco de dados.&lt;/li>
&lt;li>Modelo Entidade Relacionamento e Modelo Entidade Relacionamento Estendido&lt;/li>
&lt;li>Modelo Relacional&lt;/li>
&lt;/ul>
&lt;h1 id="bibliografia">bibliografia &lt;a href="#bibliografia" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>&lt;a href="https://github.com/Felipe-gsilva/cs-common-private-files/tree/main/Books/DatabaseSystemConcepts.pdf" rel="external" target="_blank">korth - Sistemas de banco de dados&lt;svg width="16" height="16" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">&lt;path fill="currentColor" d="M14 5c-.552 0-1-.448-1-1s.448-1 1-1h6c.552 0 1 .448 1 1v6c0 .552-.448 1-1 1s-1-.448-1-1v-3.586l-7.293 7.293c-.391.39-1.024.39-1.414 0-.391-.391-.391-1.024 0-1.414l7.293-7.293h-3.586zm-9 2c-.552 0-1 .448-1 1v11c0 .552.448 1 1 1h11c.552 0 1-.448 1-1v-4.563c0-.552.448-1 1-1s1 .448 1 1v4.563c0 1.657-1.343 3-3 3h-11c-1.657 0-3-1.343-3-3v-11c0-1.657 1.343-3 3-3h4.563c.552 0 1 .448 1 1s-.448 1-1 1h-4.563z"/>&lt;/svg>&lt;/a>&lt;/p></description></item><item><title>. Header</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/0.-header/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/0.-header/</guid><description>&lt;p>Este documento representa meus estudos acerca do livro Redes de Computadores e a Internet - uma abordagem top down&lt;/p>
&lt;p>Cap 1:&lt;/p>
&lt;ul>
&lt;li>Fundamentos da Rede de Computadores.&lt;/li>
&lt;li>RFC&lt;/li>
&lt;li>comutação de pacotes&lt;/li>
&lt;li>meios de transmissão&lt;/li>
&lt;li>atrasos&lt;/li>
&lt;li>protocolos&lt;/li>
&lt;li>backbones, IX&amp;rsquo;s e ISP&amp;rsquo;s
Cap 2:&lt;/li>
&lt;li>Fundamentos da Camada de aplicação.&lt;/li>
&lt;li>HTTP, HTTP 1.1, HTTP/2&lt;/li>
&lt;li>Portas WKS públicas e efêmeras.&lt;/li>
&lt;li>E-mail e SMTP&lt;/li>
&lt;li>DNS&lt;/li>
&lt;li>P2P
&lt;ul>
&lt;li>BitTorrent
Cap 3:&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>Fundamentos da Camada de transporte.&lt;/li>
&lt;li>UDP&lt;/li>
&lt;li>multiplexacao&lt;/li>
&lt;li>checksum&lt;/li>
&lt;li>Princípios de Transferência Confiável de Dados (RDT - Reliable Data Transfer ).&lt;/li>
&lt;li>RDT 1, 2 e 3.&lt;/li>
&lt;li>Protocolos Dutados.&lt;/li>
&lt;li>GBN - Go back N.&lt;/li>
&lt;li>SR - Seletive Repeater.&lt;/li>
&lt;li>O TCP.&lt;/li>
&lt;li>MSS e numeração de segmentos.&lt;/li>
&lt;li>TCP - Gerenciamento de conexões.&lt;/li>
&lt;li>Timers, RTT e Timeout.&lt;/li>
&lt;li>Controle de fluxo no TCP.&lt;/li>
&lt;li>Controle de congestionamento no TCP.&lt;/li>
&lt;li>Justeza do TCP.&lt;/li>
&lt;/ul>
&lt;p>&lt;a href="https://github.com/Felipe-gsilva/cs-common-private-files/blob/main/Books/RedesdeComputadoreseaInternet%208a.pdf" rel="external" target="_blank">Internet - uma abordagem top down&lt;svg width="16" height="16" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">&lt;path fill="currentColor" d="M14 5c-.552 0-1-.448-1-1s.448-1 1-1h6c.552 0 1 .448 1 1v6c0 .552-.448 1-1 1s-1-.448-1-1v-3.586l-7.293 7.293c-.391.39-1.024.39-1.414 0-.391-.391-.391-1.024 0-1.414l7.293-7.293h-3.586zm-9 2c-.552 0-1 .448-1 1v11c0 .552.448 1 1 1h11c.552 0 1-.448 1-1v-4.563c0-.552.448-1 1-1s1 .448 1 1v4.563c0 1.657-1.343 3-3 3h-11c-1.657 0-3-1.343-3-3v-11c0-1.657 1.343-3 3-3h4.563c.552 0 1 .448 1 1s-.448 1-1 1h-4.563z"/>&lt;/svg>&lt;/a>&lt;/p></description></item><item><title>. Interface-do-usuario</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/6.-interface-do-usuario/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/6.-interface-do-usuario/</guid><description>&lt;p>tem que ser focada no usuario que utilizara o produto.&lt;/p>
&lt;h1 id="regras-de-ouro">Regras de Ouro &lt;a href="#regras-de-ouro" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>deixar o usuario no comando: possibilitar que o usuario interrompa ou desfaca interacoes, apoiar o dev baseado no nivel de exp esperada do usuario final.&lt;/li>
&lt;li>reduzir a carga de memoria do USUARIO (lembrar de teclas/ter conhecimenteo previo)&lt;/li>
&lt;li>interface consistente&lt;/li>
&lt;/ul>
&lt;h1 id="projeto-iterativo">Projeto iterativo &lt;a href="#projeto-iterativo" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>analise: perfil do usuario&lt;/li>
&lt;li>projeto: definir as funcionalidades necessarias&lt;/li>
&lt;li>construcao: prototipo&lt;/li>
&lt;li>validacao: ver se tudo ta implementado corretamente&lt;/li>
&lt;/ul>
&lt;h2 id="analise">Analise &lt;a href="#analise" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>analisar o publico alvo&lt;/li>
&lt;li>analisar e modelar tarefas para o usuario&lt;/li>
&lt;li>analise do conteudo a ser exibido&lt;/li>
&lt;li>analise do ambiente de trabalho (dependendo de qm for utilizar)&lt;/li>
&lt;/ul>
&lt;h2 id="projeto">Projeto &lt;a href="#projeto" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>definir os objetivos de interface e as acoes aplicadas a elas.&lt;/li>
&lt;li>usar padroes&lt;/li>
&lt;li>considerar variabilidade no tempo de resposta, ajuda, erros, attr. de nomes, comandos e menus.&lt;/li>
&lt;/ul></description></item><item><title>. Introducao</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/1.-introducao/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/1.-introducao/</guid><description>&lt;h1 id="introducao">Introducao &lt;a href="#introducao" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;h2 id="a-sgbd">a. SGBD &lt;a href="#a-sgbd" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Sistema gerenciador de banco de dados eh uma coleção de programas com proposito sistemático e eficiente nas tarefas de armazenamento e recuperação de dados.&lt;/li>
&lt;li>Banco de Dados -&amp;gt; seção logica (arquivos) onde os dados são armazenados, normalmente, associado a um SGBD com repositório dos respectivos dados e estruturas de controle.&lt;/li>
&lt;/ul>
&lt;h2 id="b-historia">b. historia &lt;a href="#b-historia" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Em 1968, o IMS (Informational Management System) da IBM foi lancado, utilizando-se do modelo hierarquico.&lt;/li>
&lt;li>Em 1970, o matematico Edgar Frank &lt;em>Codd&lt;/em>, baseado na Teoria dos Conjuntos. Seu foco estava na representacao do mundo real em Tuplas (chamadas de tabelas - sera melhor estudado futuramente).&lt;/li>
&lt;li>Em 1979, Larry Ellison cofundou a Oracle.&lt;/li>
&lt;li>Em 1980, a IBM criou o SQL/DS e o DB2.&lt;/li>
&lt;/ul>
&lt;h2 id="c-dificuldades-das-aplica-coes">c. dificuldades das aplica coes &lt;a href="#c-dificuldades-das-aplica-coes" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>isolamento de dados&lt;/li>
&lt;li>redundancia das informacoes (ou demais, ou nenhuma)&lt;/li>
&lt;li>multiplos usuarios&lt;/li>
&lt;li>acesso dos dados:
&lt;ul>
&lt;li>protecao (escopo)&lt;/li>
&lt;li>consultas&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;h2 id="d-aplicações">d. aplicações &lt;a href="#d-aplica%c3%a7%c3%b5es" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ol>
&lt;li>sistemas web, bancários e financeiros.&lt;/li>
&lt;li>sistemas específicos.&lt;/li>
&lt;li>CAD/CAM -&amp;gt; Computer Aid Desging/Manufacturing&lt;/li>
&lt;li>EAD&lt;/li>
&lt;li>SGBOO / SGBRO&lt;/li>
&lt;li>NoSQL:
&lt;ul>
&lt;li>nao relacional&lt;/li>
&lt;li>grafos&lt;/li>
&lt;li>colulas&lt;/li>
&lt;li>hashmaps&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ol>
&lt;h2 id="e-niveis-de-abstração">e. Niveis de abstração &lt;a href="#e-niveis-de-abstra%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>&lt;strong>Físico&lt;/strong>: o nivel mais baixo de abstracao, descreve como o dado eh de fato armazenado, ou seja, as estruturas de dados que armazenam os dados.&lt;/p></description></item><item><title>. Introducao</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/1.-introducao/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/1.-introducao/</guid><description>&lt;p>Este documento representa meus estudos acerca do livro Redes de Computadores e a Internet - uma abordagem top down&lt;/p>
&lt;h1 id="conceitos-fundamentais">Conceitos Fundamentais &lt;a href="#conceitos-fundamentais" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>A internet representa uma rede de computadores (ou outros dispositivos) interconectados atraves de diversas formas e tecnicas distintas e com protocolos definidos. De maneira geral (alem das camadas, que veremos com mais detalhes em sequencia), a internet pode ser dividida em dispositivos (os quais acessam esta conexao - computadores, algumas geladeiras, ou seja, que utiliza-se dos protocolos de rede e suas aplicacoes) e componentes (que a garantem - links, routers e etc). Esta definicao eh simplista, evidentemente, mas agrupa logicamente o que compoe a internet.&lt;/p></description></item><item><title>. Introducao-a-Concorrencia</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/11.-introducao-a-concorrencia/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/11.-introducao-a-concorrencia/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;p>Neste capitulo, introduzimos uma nova abstração para cada processo em execução: as &lt;code>threads&lt;/code>. Um programa &lt;code>multi-threaded&lt;/code> tem mais que um ponto de execução, ou seja, tem mais de um Program Counter, cada um deles sendo executado paralelamente.&lt;/p>
&lt;p>O estado de uma &lt;strong>thread&lt;/strong> eh bem similar a um processo. Cada thread tem seu &lt;strong>conjunto de regs&lt;/strong>, ou seja, se 2 threads estão rodando no mesmo núcleo da CPU, urge a necessidade de usarmos novamente o context switch. .&lt;/p></description></item><item><title>. Introducao-a-Processos</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/1.-introducao-a-processos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/1.-introducao-a-processos/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;p>Um processo representa um programa em execucao e seus respectivos componentes. O programa armazenado em si, nao representa nada alem de instrucoes e algum tipo de dado estatico, ele so passa a ter algum valor de fato quando executado pelo SO.
Neste contexto, cria-se uma problematica. Se um programa so pode ser validado ao ser executado, como podemos executar varios programas em apenas uma maquina fisica, a qual tem apenas uma unidade de processamento?&lt;/p></description></item><item><title>. Introducao-ao-Escalonamento</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/3.-introducao-ao-escalonamento/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/3.-introducao-ao-escalonamento/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;h1 id="30-escalonamento">3.0 Escalonamento &lt;a href="#30-escalonamento" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;h1 id="31-metricas-de-escalonamento">3.1 Metricas de escalonamento &lt;a href="#31-metricas-de-escalonamento" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Existem diversas metricas para qualificarmos politicas de escalonamento ou apenas medir por prazer o que um metodo de escalonamento faz. Neste momento, usaremos apenas o &lt;strong>turnaround time&lt;/strong>, o qual eh definido pela diferenca entre o tempo de completude do processo e o tempo de chegada.
$$T_{turnaround} = T_{completion} - T_{arrival} $$&lt;/p></description></item><item><title>. Limited-Direct-Execution</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/2.-limited-direct-execution/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/2.-limited-direct-execution/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;p>De maneira geral, ao compartilhar tempo da CPU com 2 ou mais processos, encontramos com diversos problemas. Entre eles: como podemos manter o controle da CPU, mesmo apos ele ter sido passado para o processo . Podemos ter um problema de performance, visto que determinados processos podem precisar ou nao de mais tempo de CPU tendo outros em vista. (por exemplo, um loop infinito dentro em alguma &lt;em>rotina&lt;/em> do processo?)&lt;/p></description></item><item><title>. Modelagem-de-sistema</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/5.-modelagem-de-sistema/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/5.-modelagem-de-sistema/</guid><description>&lt;p>Modelos de sistema sao Modelos abstratos em que cada um apresenta uma visao ou perspectiva diferente do sistema.&lt;/p>
&lt;p>Representacoes graficas sao importantes.&lt;/p>
&lt;h2 id="contexto-de-desenvolvimento-dos-modelos">Contexto de desenvolvimento dos modelos &lt;a href="#contexto-de-desenvolvimento-dos-modelos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>sistemas novos: explicam necessidades do sistema e documenta-se&lt;/li>
&lt;li>sistemas existentes: durante a engenharia de requisitos&lt;/li>
&lt;/ul>
&lt;p>exemplos:&lt;/p>
&lt;ul>
&lt;li>Booch&lt;/li>
&lt;li>OMT&lt;/li>
&lt;li>OOSE&lt;/li>
&lt;/ul>
&lt;h2 id="unified-modeling-language">Unified Modeling Language &lt;a href="#unified-modeling-language" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>ha 14 tipos de diagramas.&lt;/p>
&lt;p>diagramas de:&lt;/p>
&lt;ol>
&lt;li>
&lt;p>estrutura: demonstra a estrutura estatica do sistema. (classe, obj, pacotes, components..)&lt;/p></description></item><item><title>. Modelo Relacional</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/4.-modelo-relacional/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/4.-modelo-relacional/</guid><description>&lt;p>Foi publicado pelo matemático Edgar Frank Codd em 1970, sendo contratado para trabalhar na IBM nos Sistemas R e Normalização. Ja em 1979, L. Ellison oferece a primeira versão da Oracle. Em 1980, o SQL/DS foi criado pela IBM, assim como o DB2.&lt;/p>
&lt;h2 id="sgdbs-relacionais">SGDB&amp;rsquo;s Relacionais &lt;a href="#sgdbs-relacionais" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>oracle&lt;/li>
&lt;li>db2&lt;/li>
&lt;li>mysql (mariadb)&lt;/li>
&lt;li>sql server&lt;/li>
&lt;li>postgreSQL&lt;/li>
&lt;li>sqlite&lt;/li>
&lt;li>sybase&lt;/li>
&lt;/ul>
&lt;h1 id="modelo-relacional">Modelo Relacional &lt;a href="#modelo-relacional" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Esse modelo eh o mais utilizado hoje pelos gerenciadores, justamente pela sua simplicidade, juntamente a sua capacidade semântica ampla (mesmo que simples).&lt;/p></description></item><item><title>. Modelo-entidade-relacionamento</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/3.-modelo-entidade-relacionamento/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/3.-modelo-entidade-relacionamento/</guid><description>&lt;p>O modelo de dados representa uma colecao de ferramentas concentuais que servem para descrever dados, relacoes, semanticas e constraints. Define uma forma de descrever o &lt;em>design&lt;/em> de um banco de dados em qualquer nivel, partindo do mundo real.&lt;/p>
&lt;blockquote>
&lt;p>&lt;em>ex&lt;/em>: hierarquico, relacional, orientado a objeto, a grafos&amp;hellip; cada geracao ou amplia o restringe o objeto de estudo dos modelos, grafos eh restrito, objeto eh amplo (em representacao semantica).&lt;/p>&lt;/blockquote>
&lt;p>Modelagem de dados representa uma parte essencial do nível de abstração do sistema, permitindo uma melhor compreensão e organização dos dados. Para isso, durante anos vários cientistas e pesquisadores propuseram diversos modelos que deveriam ser capazes de representar o mundo real, intangível e, digamos, nebuloso, em uma amalgama de dados capaz de efetivamente demonstrar-lo em um contexto computacional.&lt;/p></description></item><item><title>. Operacoes-de-linguagens-regulares</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/7.-operacoes-de-linguagens-regulares/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/7.-operacoes-de-linguagens-regulares/</guid><description>&lt;blockquote>
&lt;p>A classe das linguagens regulares é fechada para a operação de união, concatenação e estrela.&lt;/p>&lt;/blockquote>
&lt;p>&lt;strong>Demonstração para União:&lt;/strong>&lt;/p>
&lt;p>Sejam $L_1$ e $L_2$ linguagens regulares. Então existem $N_1=(Q_1,\Sigma_1, \delta_1, q_1, F_1)$ e $N_2=(Q_2,\Sigma_2, \delta_2, q_2, F_2)$ que aceitam $L_1$ e $L_2$, respectivamente. Queremos construir o AFN $N_3$ que aceita a linguagem $L_3=L_1+L_2$.&lt;/p>
&lt;p>





 



 
&lt;/p>
&lt;p>$Q_3 = Q_1 \cup Q_2 \cup {q_3}$&lt;/p>
&lt;p>$\Sigma_3 = \Sigma_1 \cup \Sigma_2$&lt;/p>
&lt;p>$F_3=F_1 \cup F_2$&lt;/p>
&lt;p>$\delta_3(q,a) = \begin{cases} \text{se } q=q+3\text{ e }a= \varepsilon,\text{ } \delta_3(q,a)={q_1,q_2} \ \text{se } q\in Q_1,\text{ } \delta_3(q,a)=\delta_1(q,a) \ \text{se } q\in Q_2,\text{ } \delta_3(q,a)=\delta_2(q,a) \ \end{cases}$&lt;/p></description></item><item><title>. Paginacao</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/8.-paginacao/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/8.-paginacao/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;p>Segmentacao, apesar de ser quase sempre necessaria no sistema que estamos construindo, causa alguns problemas que sao dificeis de ser mantidos. Como criamos espacos segmentados, nao contiguos como em outros tipos de alocacao, podemos gerar uma fragmentacao, com blocos de tamanhos diferentes.&lt;/p>
&lt;p>Para garantir o tamanho dos espacos na memoria, podemos usar uma tecnica chamada paginacao, que ja foi vista nas aulas sobre arvores B.&lt;/p></description></item><item><title>. Projeto-de-arquitetura</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/7.-projeto-de-arquitetura/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/7.-projeto-de-arquitetura/</guid><description>&lt;p>Como um sistema deve ser organizado e a sua estrutura geral.
-&amp;gt; projeto criativo que busca satisfazer os requisitos funcionais.&lt;/p>
&lt;h1 id="modelos-estruturais">Modelos Estruturais &lt;a href="#modelos-estruturais" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;h2 id="1-arquitetura-em-camadas">1. Arquitetura em Camadas &lt;a href="#1-arquitetura-em-camadas" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Divide o sistema em camadas permitindo que alteracoes sejam localizadas.&lt;/p>
&lt;p>Trata o nivel conceitual do sistema:
-&amp;gt; interface de usuario
-&amp;gt; auth
-&amp;gt; logica de negocio/funcionalidade do sistemas
-&amp;gt; apoio do sistema (BD, SO&amp;hellip;)&lt;/p>
&lt;p>eh uma arquitetura portavel, porem pode ter desempenho limitado.&lt;/p></description></item><item><title>. Redes-de-acesso-e-meio-físico</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/3.-redes-de-acesso-e-meio-f%C3%ADsico/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/3.-redes-de-acesso-e-meio-f%C3%ADsico/</guid><description>&lt;p>Este documento representa meus estudos acerca do livro Redes de Computadores e a Internet - uma abordagem top down&lt;/p>
&lt;hr>
&lt;p>Ligar dispositivos (hosts) ao primeiro roteador (gateway).&lt;/p>
&lt;ul>
&lt;li>“hop” (salto) numa rede local, ou seja, do host ate o gateway.&lt;/li>
&lt;/ul>
&lt;h2 id="rede-locallan---rede-previa-ao-primeiro-hop">Rede local(LAN) - rede previa ao primeiro hop. &lt;a href="#rede-locallan---rede-previa-ao-primeiro-hop" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>exemplo: ethernet, wifi&lt;/p>
&lt;blockquote>
&lt;p>uma placa de rede tem o endereco MAC_Address (nao eh hierarquico, eh unico a maquina);
o IP Address, em contraponto, eh hierarquico, ou seja, depende da rede que o sucede.&lt;/p></description></item><item><title>. Segmentacao</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/6.-segmentacao/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/6.-segmentacao/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;h1 id="91-introdução-à-segmentação">9.1 Introdução à Segmentação &lt;a href="#91-introdu%c3%a7%c3%a3o-%c3%a0-segmenta%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>A segmentação foi desenvolvida para resolver os problemas de eficiência e flexibilidade no gerenciamento de memória, que surgiram com a técnica de Base e Limite. No modelo Base e Limite, todo o espaço de endereçamento de um processo é alocado de maneira contígua, o que gera desperdício de memória, especialmente quando há grandes regiões não utilizadas entre a pilha (stack) e o heap.&lt;/p></description></item><item><title>. Sistema-Distribuidos</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/16.-sistema-distribuidos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/16.-sistema-distribuidos/</guid><description>&lt;h1 id="sistemas-distribuidos">Sistemas Distribuidos &lt;a href="#sistemas-distribuidos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>A maior problemática se dá na incumbência do projetista em manter o funcionamento do sistema mesmo com os possíveis erros.&lt;/p>
&lt;ul>
&lt;li>Perfomance: faz-se necessário diminuir o tamanho e quantidade de mensagens.&lt;/li>
&lt;li>Securança: autenticação do usuário.&lt;/li>
&lt;/ul>
&lt;p>Tipos de sistemas distribuidos (alguns):&lt;/p>
&lt;p>DSM - Distributed Shared Memory: um sistema distribuido cujo &lt;em>address space virtual&lt;/em> é inteiramente compartilhada externamente à maquina do cliente. Não é mais muito usado, visto que compartilhar tudo é desgastante para a rede e tem desempenho terrível.&lt;/p></description></item><item><title>. sistemas-de-arquivos</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/13.-sistemas-de-arquivos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/13.-sistemas-de-arquivos/</guid><description>&lt;p>Uma introdução a arquivos e sistemas de arquivos.&lt;/p>
&lt;ul>
&lt;li>arquivos: vetor de bytes, identificado por um inode (ou apenas um ponteiro em alguns casos).&lt;/li>
&lt;li>diretório: lista de tuplas referenciando arquivos ou links (hard ou soft), divididos hierarquicamente formando uma árvore (com root &amp;ldquo;/&amp;rdquo;) e separadores (Posix &amp;ldquo;/&amp;rdquo; ou Win &amp;ldquo;&amp;quot;).
&lt;ul>
&lt;li>pathname: /root/dir/file.txt&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;h1 id="api-do-fs">API do FS &lt;a href="#api-do-fs" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Open file table: uma tabela com as referencias aos arquivos ja abertos, gerenciados pelo processo requerente (agent)&lt;/p></description></item><item><title>. Sistemas-de-arquivos-distribuidos</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/17.-sistemas-de-arquivos-distribuidos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/17.-sistemas-de-arquivos-distribuidos/</guid><description/></item><item><title>. SQL</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/5.-sql/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/5.-sql/</guid><description>&lt;p>SQL (Structured Query Language) é o padrão adotado para linguagens de consultas em Sistemas Gerenciadores de Banco de Dados Relacionais (SGBDR).&lt;/p>
&lt;p>A linguagem oficial do modelo Relacional. Permite a definição de esquemas, restrições e definições além da manipulação de instâncias.&lt;/p>
&lt;p>Considere as relações:&lt;/p>
&lt;ul>
&lt;li>Cliente($\underline{RG}$, nome_cli, ano_nasc, cidade_cli, sexo)&lt;/li>
&lt;li>Agencia($\underline{cod_ag}$, nome_ag, cidade_ag, ativo)&lt;/li>
&lt;li>Deposito($\underline{num_dep}$, RG, saldo, cod_ag)&lt;/li>
&lt;li>Empréstimo($\underline{num_empr}$, RG, valor, cod_ag)&lt;/li>
&lt;/ul>
&lt;h1 id="dml">DML &lt;a href="#dml" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>parte de modelagem&lt;/p>


 
 &lt;div class="highlight">&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">&lt;code class="language-sql" data-lang="sql">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#66d9ef">select&lt;/span> lista_de_atributos (ou &lt;span style="color:#f92672">*&lt;/span>)
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#66d9ef">from&lt;/span> lista_de_relações
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#66d9ef">where&lt;/span> predicado&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;p>exemplos:&lt;/p></description></item><item><title>. Swapping</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/10.-swapping/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/10.-swapping/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;p>Ate o momento, tratamos de &lt;strong>address spaces&lt;/strong> de tamanho pequeno que cabiam na memoria inteiramente. Agora, falaremos de alguns maiores.&lt;/p>
&lt;h1 id="swapping">Swapping &lt;a href="#swapping" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Utilizamos uma regiao de memoria secundaria (HDDs e SSDs) como um stash de memoria nao frequentemente utilizada. Uma especie de cache invertido. A presenca do &lt;strong>swap space&lt;/strong> permite ao OS que gere uma ilusao de uma memoria virtual maor para melhor gerir concorrencia de processos.&lt;/p></description></item><item><title>. testes</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/9.-testes/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/engenharia-de-software/9.-testes/</guid><description/></item><item><title>. Traducoes-rapidas(TLBs)</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/9.-traducoes-rapidastlbs/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/9.-traducoes-rapidastlbs/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;p>Ha um problema em separar o &lt;strong>address space&lt;/strong> em espacos pequenos de memoria. Existe um overhead grande por conta da quantidade de informacao necessaria para mapear os enderecos reais e virtuais. Isso desacelera tambem a traducao, visto que ha acesso continuo a Memoria Principal, ao inves de deixar tudo em cache no processador.&lt;/p></description></item><item><title>. Virtualizacao-de-Memoria</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/5.-virtualizacao-de-memoria/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/5.-virtualizacao-de-memoria/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;h1 id="hipóteses-iniciais">Hipóteses Iniciais &lt;a href="#hip%c3%b3teses-iniciais" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ol>
&lt;li>Espaços de endereçamento contíguos: Cada espaço de endereçamento de processo deve ser alocado de forma contígua na memória física.&lt;/li>
&lt;li>Memória suficiente: O espaço de endereçamento do processo é menor do que a memória física total.&lt;/li>
&lt;li>Tamanho fixo: Cada espaço de endereçamento tem o mesmo tamanho.&lt;/li>
&lt;/ol>
&lt;p>Essas suposições simplificam a discussão inicial, permitindo a introdução gradual de mecanismos mais complexos depois.&lt;/p></description></item><item><title>.1 API-de-processos</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/1.1-api-de-processos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/1.1-api-de-processos/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;h1 id="process-api">Process API &lt;a href="#process-api" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;h2 id="the-fork-call">The Fork() Call &lt;a href="#the-fork-call" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Fork() eh usada para criar um novo processo.&lt;/p>


 
 &lt;div class="highlight">&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">&lt;code class="language-c" data-lang="c">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">#include&lt;/span> &lt;span style="color:#75715e">&amp;lt;stdio.h&amp;gt;&lt;/span>&lt;span style="color:#75715e">
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">#include&lt;/span> &lt;span style="color:#75715e">&amp;lt;stdlib.h&amp;gt;&lt;/span>&lt;span style="color:#75715e">
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">#include&lt;/span> &lt;span style="color:#75715e">&amp;lt;unistd.h&amp;gt;&lt;/span>&lt;span style="color:#75715e">
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#66d9ef">int&lt;/span> &lt;span style="color:#a6e22e">main&lt;/span>(&lt;span style="color:#66d9ef">int&lt;/span> argc, &lt;span style="color:#66d9ef">char&lt;/span> &lt;span style="color:#f92672">*&lt;/span>argv[]) {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#a6e22e">printf&lt;/span>(&lt;span style="color:#e6db74">&amp;#34;hello (pid:%d)&lt;/span>&lt;span style="color:#ae81ff">\n&lt;/span>&lt;span style="color:#e6db74">&amp;#34;&lt;/span>, (&lt;span style="color:#66d9ef">int&lt;/span>) &lt;span style="color:#a6e22e">getpid&lt;/span>());
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#66d9ef">int&lt;/span> rc &lt;span style="color:#f92672">=&lt;/span> &lt;span style="color:#a6e22e">fork&lt;/span>();
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#66d9ef">if&lt;/span> (rc &lt;span style="color:#f92672">&amp;lt;&lt;/span> &lt;span style="color:#ae81ff">0&lt;/span>) {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#75715e">// fork failed
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">&lt;/span> &lt;span style="color:#a6e22e">fprintf&lt;/span>(stderr, &lt;span style="color:#e6db74">&amp;#34;fork failed&lt;/span>&lt;span style="color:#ae81ff">\n&lt;/span>&lt;span style="color:#e6db74">&amp;#34;&lt;/span>);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#a6e22e">exit&lt;/span>(&lt;span style="color:#ae81ff">1&lt;/span>);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> } &lt;span style="color:#66d9ef">else&lt;/span> &lt;span style="color:#66d9ef">if&lt;/span> (rc &lt;span style="color:#f92672">==&lt;/span> &lt;span style="color:#ae81ff">0&lt;/span>) {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#75715e">// child (new process)
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">&lt;/span> &lt;span style="color:#a6e22e">printf&lt;/span>(&lt;span style="color:#e6db74">&amp;#34;child (pid:%d)&lt;/span>&lt;span style="color:#ae81ff">\n&lt;/span>&lt;span style="color:#e6db74">&amp;#34;&lt;/span>, (&lt;span style="color:#66d9ef">int&lt;/span>) &lt;span style="color:#a6e22e">getpid&lt;/span>());
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> } &lt;span style="color:#66d9ef">else&lt;/span> {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#75715e">// parent goes down this path (main)
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">&lt;/span> &lt;span style="color:#a6e22e">printf&lt;/span>(&lt;span style="color:#e6db74">&amp;#34;parent of %d (pid:%d)&lt;/span>&lt;span style="color:#ae81ff">\n&lt;/span>&lt;span style="color:#e6db74">&amp;#34;&lt;/span>,
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> rc, (&lt;span style="color:#66d9ef">int&lt;/span>) &lt;span style="color:#a6e22e">getpid&lt;/span>());
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> }
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#66d9ef">return&lt;/span> &lt;span style="color:#ae81ff">0&lt;/span>;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>}&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;p>Podemos perceber que a funcao fork() cria uma ramificacao a partir do processo atual, com outro PID (Process Identifir). Esta funcao cria uma copia quase exata (a excessao do PID) do processo que a chama, neste caso a rotina &lt;code>main&lt;/code>. Entretanto, ele podemos notar que ele nao printa novamente o hello world, pois a nova routina surge a partir do momento em que fork eh chamado. Por isso, no controle de fluxo, temos&lt;/p></description></item><item><title>.1 Controle-de-Acesso</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/14.1-controle-de-acesso/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/14.1-controle-de-acesso/</guid><description>&lt;h2 id="introdução">Introdução &lt;a href="#introdu%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Este capítulo aborda como o sistema operacional implementa políticas de segurança para controlar &lt;strong>quem pode acessar o quê&lt;/strong>, &lt;strong>de que maneira&lt;/strong> e &lt;strong>sob quais condições&lt;/strong>. Duas etapas principais:&lt;/p>
&lt;ol>
&lt;li>Verificar se o pedido está dentro da política de segurança.&lt;/li>
&lt;li>Permitir ou negar o acesso com base nessa verificação.&lt;/li>
&lt;/ol>
&lt;hr>
&lt;h2 id="1-o-problema-do-controle-de-acesso">1. O Problema do Controle de Acesso &lt;a href="#1-o-problema-do-controle-de-acesso" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;h3 id="elementos-centrais">Elementos centrais: &lt;a href="#elementos-centrais" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>&lt;strong>Sujeito (subject):&lt;/strong> Quem faz o pedido (usuário/processo).&lt;/li>
&lt;li>&lt;strong>Objeto (object):&lt;/strong> O que se deseja acessar (arquivo, dispositivo, etc.).&lt;/li>
&lt;li>&lt;strong>Acesso:&lt;/strong> Tipo de operação (leitura, escrita, execução&amp;hellip;).&lt;/li>
&lt;/ul>
&lt;p>🔍 O sistema operacional deve tomar decisões binárias (sim/não) sobre permissões, baseando-se em sua &lt;strong>política de segurança&lt;/strong>. Isso é feito por um &lt;strong>reference monitor&lt;/strong>, que deve ser:&lt;/p></description></item><item><title>.1 Politicas-de-swap</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/10.1-politicas-de-swap/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/10.1-politicas-de-swap/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;h1 id="cache-management">Cache Management &lt;a href="#cache-management" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Considerando que a memoria principal carrega parcialmente paginas que compoem a memoria virtual completa do sistema, podemos assumir a memoria entao como um &lt;em>cache&lt;/em>. Nosso objetivo, entao, sera diminuir a quantidade de &lt;strong>cache missess&lt;/strong>, ou seja, minimizar a quantidade de acesso a discos, que sempre eh o maior gargalo de um sistema computacional de Von Neumann.&lt;/p></description></item><item><title>.1 Tabelas-menores</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/9.1-tabelas-menores/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/9.1-tabelas-menores/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;h1 id="tabelas-de-paginas-lineares-sao-enormes">tabelas de paginas (lineares) sao enormes &lt;a href="#tabelas-de-paginas-lineares-sao-enormes" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;h2 id="solucao-simples-aumentar-cada-pagina">solucao simples: aumentar cada pagina &lt;a href="#solucao-simples-aumentar-cada-pagina" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>podemos reduzir o tamanho simplesmente utilizando de paginas maiores. Se tivermos um address space de 32-bit, podemos usar um VPN de 18-bits e 14 bits para o offset. Assumindo que cada PTE tem 4 bytes, temos $2^{18}$ entries na page table linear. (total 1mb por page table).&lt;/p></description></item><item><title>.1- Matriz de Confusão</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/6.1--matriz-de-confus%C3%A3o/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/6.1--matriz-de-confus%C3%A3o/</guid><description>&lt;p>Uma tabela que declara a qualidade de um teste. Se os maiores valores estão na diagonal principal da matriz, significa que o teste é bom.&lt;/p>
&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>&lt;/th>
 &lt;th>Resultado 1&lt;/th>
 &lt;th>Resultado 2&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>Espaço parcial&lt;/td>
 &lt;td>BOM&lt;/td>
 &lt;td>RUIM&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Espaço parcial 2&lt;/td>
 &lt;td>RUIM&lt;/td>
 &lt;td>BOM&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;h1 id="métricas-de-avaliação">Métricas de Avaliação &lt;a href="#m%c3%a9tricas-de-avalia%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>&lt;strong>Sensibilidade/Revocação&lt;/strong> -&amp;gt; taxa de verdadeiro positivo. ($S = \frac{VP}{VP + FN}$)&lt;/li>
&lt;li>&lt;strong>Especificidade do teste&lt;/strong> -&amp;gt; taxa de verdadeiro negativo. ($\xi = \frac{VN}{VN+PF}$)&lt;/li>
&lt;li>&lt;strong>Acurácia&lt;/strong> -&amp;gt; dentre todas, quais classificações estavam corretas. ($A = \frac{VP + VN}{VN + VP + FN + FP}$)&lt;/li>
&lt;li>&lt;strong>Precisão&lt;/strong> -&amp;gt; dentre as que foram ditas como corretas, quais são, de fato. ($P = \frac{VP}{VP+FP}$)&lt;/li>
&lt;/ul>
&lt;h2 id="exemplo">Exemplo &lt;a href="#exemplo" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>$\Omega = 20$
$A = 12$
$B = 8$&lt;/p></description></item><item><title>.1. Camada de Rede pt.2</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/9.1.-camada-de-rede-pt.2/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/9.1.-camada-de-rede-pt.2/</guid><description>&lt;h1 id="encaminhamento-de-datagramas">Encaminhamento de Datagramas &lt;a href="#encaminhamento-de-datagramas" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Cada pacote &amp;ldquo;salta&amp;rdquo; de um roteador até outro, conforme o roteamento determina, sem parar no roteador nunca (hot potato).&lt;/p>
&lt;p>Para enviar um datagrama, um emissor vai:&lt;/p>
&lt;ol>
&lt;li>Colocar o datagrama IP num frame da camada de enlace.&lt;/li>
&lt;li>Colocar o endereço de destino do frame (endereço MAC) como sendo aquele do destino do próximo salto.&lt;/li>
&lt;/ol>
&lt;p>Há 2 tipos:&lt;/p>
&lt;ul>
&lt;li>indireto:&lt;/li>
&lt;li>direto:&lt;/li>
&lt;/ul>
&lt;h2 id="indireto">Indireto &lt;a href="#indireto" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Host origem e o host destino não estão na mesma rede, ou seja, não tem o mesmo prefixo de rede.&lt;/p></description></item><item><title>.1. Drives de Discos Rígidos</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/12.1.-drives-de-discos-r%C3%ADgidos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/12.1.-drives-de-discos-r%C3%ADgidos/</guid><description>&lt;h1 id="device-driver">Device driver &lt;a href="#device-driver" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>usaremos esta camada baixa de abstração para permitir que o SO não se precise se preocupar com detalhes das operações de IO.&lt;/p>
&lt;h2 id="interface-do-driver">Interface do Driver &lt;a href="#interface-do-driver" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Um disco consiste numa quantidade de setores (blocos de 512-bytes). O Address Space de um disco equivale a $n$ setores, ou seja, um vetor de setores.
A unica garantia de atomicidade é em um único setor por vez, pela parte do disco.&lt;/p></description></item><item><title>.1. ffs</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/13.1.-ffs/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/13.1.-ffs/</guid><description>&lt;h1 id="o-problema-baixo-desempenho-do-sistema-de-arquivos-antigo">O Problema: Baixo Desempenho do Sistema de Arquivos Antigo &lt;a href="#o-problema-baixo-desempenho-do-sistema-de-arquivos-antigo" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Havia, inicialmente, uma falta de consciência acerca do disco: (i) Inodes e blocos de dados ficavam muito disntantes um do outro, tornando o acesso lento; (ii) O bloco em si era consideravelmente pequeno (512 bytes), o que tornava a transferência de dados consideravelmente pequena.&lt;/p>
&lt;h1 id="a-solução-do-ffs-fast-file-system-consciência-do-disco-e-localidade">A Solução do FFS (fast file system): Consciência do Disco e Localidade &lt;a href="#a-solu%c3%a7%c3%a3o-do-ffs-fast-file-system-consci%c3%aancia-do-disco-e-localidade" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>A inovação crítica é que cada grupo de blocos é como um mini sistema de arquivos autocontido. Ele possui:&lt;/p></description></item><item><title>.1. HTTP</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/7.1.-http/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/7.1.-http/</guid><description>&lt;p>Este documento representa meus estudos acerca do livro Redes de Computadores e a Internet - uma abordagem top down&lt;/p>
&lt;hr>
&lt;h1 id="http">HTTP &lt;a href="#http" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>URL (Uniform Resource Locator): identificador (traduzido pelos servidores dns), constituido por &lt;strong>FQDN&lt;/strong> e &lt;strong>path&lt;/strong>
&lt;ul>
&lt;li>FQDN (Fully Qualified Domain Name): é um nome de domínio completo que identifica a localização de um dispositivo ou serviço. ex: www2.unesp.br&lt;/li>
&lt;li>path: caminho relativo para um arquivo. ex: /imagem/maneira.jpg&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;p>// TODO&lt;/p>
&lt;h2 id="codigo-de-resposta">Codigo de resposta &lt;a href="#codigo-de-resposta" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>// TODO&lt;/p></description></item><item><title>.1. Locks</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/11.1.-locks/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/11.1.-locks/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;h1 id="locks">Locks &lt;a href="#locks" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Uma trava/lock eh apenas uma variavel que delimita uma regiao critica. Essa variavel armazena o estado da trava, seja &lt;strong>unlocked&lt;/strong> ou &lt;strong>locked&lt;/strong>.&lt;/p>
&lt;p>A ideia eh um tanto quanto simples. Quando uma thread acessa uma lock via lock(), ele &amp;ldquo;retem&amp;rdquo; (vira o &lt;strong>owner&lt;/strong>) a lock para si e so desfaz a trava quando chamado por unlock(). Se outra thread tentar acessar o codigo dentro da regiao critica ele nao conseguira prosseguir.&lt;/p></description></item><item><title>.1. Modelo-Endidade-Relacionamento-Estendido</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/3.1.-modelo-endidade-relacionamento-estendido/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/3.1.-modelo-endidade-relacionamento-estendido/</guid><description>&lt;p>Comecou a ser desenvolvido nos anos 82, atraves de contribuicoes externas a do autor Peter Scheins.&lt;/p>
&lt;h2 id="agregação">Agregação &lt;a href="#agrega%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Abstração em nível superior na qual um conjunto de relacionamentos eh considerado como conjunto de entidades e, a partir dai, eh possível associar este ultimo a outro conjunto de relacionamentos.&lt;/p>
&lt;blockquote>
&lt;p>[!summary] Em resumo&lt;/p>
&lt;p>Permite-se especificar conjunto de relacionamentos associados a conjuntos de relacionamentos.&lt;/p>&lt;/blockquote>
&lt;p>A agregação pode, inclusive, ter atributos próprios (não necessariamente precisa de chave primaria, mas pode-se ter um atributo que compõe a chave primaria).&lt;/p></description></item><item><title>.1. Multi-Level Feedback Queue</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/3.1.-multi-level-feedback-queue/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/3.1.-multi-level-feedback-queue/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;p>Como um sistema computacional de proposito geral normalmente nao sabe por quanto tempo rodar um processo, como sabemos e poderiamos decidir a forma mais otimizada de dividi-lo (ou nao) para escalonarmos corretamente todos os que estao na lista de processos?&lt;/p>
&lt;h1 id="the-multi-level-feedback-queue-mlfq">The Multi-Level Feedback Queue (MLFQ) &lt;a href="#the-multi-level-feedback-queue-mlfq" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Para fazer essa implementacao, definiremos prioridades para cada processo chamado. Assim, assumimos que:&lt;/p></description></item><item><title>.1. Normalização</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/4.1.-normaliza%C3%A7%C3%A3o/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/4.1.-normaliza%C3%A7%C3%A3o/</guid><description>&lt;p>Apresentada pelo Codd em 1971, é um processo para se obter bons projetos lógicos baseados no Modelo Relacional por meio da otimização de redundâncias e eliminação de anomalias.&lt;/p>
&lt;p>Normalização, logicamente, está na definição do Projeto Lógico.&lt;/p>
&lt;p>Em 71 o Codd apresenta a primeira, segunda, a terceira forma normal, juntamente a terceira corrigida (1FN, 2FN, 3FN, 3FNC) e finalmente, apresenta a 4FN (quarta forma normal).&lt;/p>
&lt;h1 id="anomalias">Anomalias: &lt;a href="#anomalias" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>$\underline{Nro_cli}$&lt;/th>
 &lt;th>Nome_cli&lt;/th>
 &lt;th>End_cli&lt;/th>
 &lt;th>Nro_Prod.&lt;/th>
 &lt;th>Nome_prod&lt;/th>
 &lt;th>Preco_prod&lt;/th>
 &lt;th>qtd_prod&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>123&lt;/td>
 &lt;td>Joao&lt;/td>
 &lt;td>XXX&lt;/td>
 &lt;td>1&lt;/td>
 &lt;td>ABCD&lt;/td>
 &lt;td>50,00&lt;/td>
 &lt;td>10&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>135&lt;/td>
 &lt;td>Pedro&lt;/td>
 &lt;td>yyy&lt;/td>
 &lt;td>1&lt;/td>
 &lt;td>ABCD&lt;/td>
 &lt;td>80,00&lt;/td>
 &lt;td>15&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>143&lt;/td>
 &lt;td>Joao&lt;/td>
 &lt;td>zzz&lt;/td>
 &lt;td>2&lt;/td>
 &lt;td>FGHI&lt;/td>
 &lt;td>20,00&lt;/td>
 &lt;td>5&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>?&lt;/td>
 &lt;td>?&lt;/td>
 &lt;td>?&lt;/td>
 &lt;td>3&lt;/td>
 &lt;td>JLM&lt;/td>
 &lt;td>35,00&lt;/td>
 &lt;td>?&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;p>&lt;code>Inclusão&lt;/code>: Valores Nulos não devem ser incluídos na tabela, se possível.
&lt;code>Exclusão&lt;/code>: Não se pode excluir dados associados.
&lt;code>Atualizações&lt;/code>: Propagação de esforços para atualização.&lt;/p></description></item><item><title>.2 Criptografia</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/14.2-criptografia/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/14.2-criptografia/</guid><description>&lt;h2 id="1-introdução">1. Introdução &lt;a href="#1-introdu%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>A criptografia é usada para proteger dados &lt;strong>fora do controle direto do sistema operacional&lt;/strong>, como quando são transmitidos pela rede ou armazenados em dispositivos removíveis. Seu objetivo é garantir &lt;strong>sigilo&lt;/strong>, &lt;strong>integridade&lt;/strong> e &lt;strong>autenticidade&lt;/strong> dos dados mesmo em ambientes inseguros.&lt;/p>
&lt;h2 id="2-fundamentos-da-criptografia">2. Fundamentos da Criptografia &lt;a href="#2-fundamentos-da-criptografia" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;h3 id="conceitos-principais">Conceitos principais &lt;a href="#conceitos-principais" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>&lt;strong>Plaintext (P)&lt;/strong>: dado original.&lt;/li>
&lt;li>&lt;strong>Ciphertext (C)&lt;/strong>: dado criptografado.&lt;/li>
&lt;li>&lt;strong>Key (K)&lt;/strong>: segredo usado no processo.&lt;/li>
&lt;li>&lt;strong>Encrypt (E)&lt;/strong>: transforma &lt;code>P&lt;/code> em &lt;code>C&lt;/code> usando &lt;code>K&lt;/code>: &lt;code>C = E(P, K)&lt;/code>&lt;/li>
&lt;li>&lt;strong>Decrypt (D)&lt;/strong>: transforma &lt;code>C&lt;/code> de volta em &lt;code>P&lt;/code> com &lt;code>K&lt;/code>: &lt;code>P = D(C, K)&lt;/code>&lt;/li>
&lt;/ul>
&lt;h3 id="exemplo">Exemplo &lt;a href="#exemplo" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>Texto original: &lt;code>Transfer $100 to my savings account&lt;/code>&lt;/li>
&lt;li>Cifra de César: &lt;code>Sqzmredq #099 sn lx rzuhmfr zbbntms&lt;/code>&lt;/li>
&lt;li>Cifra fraca e fácil de quebrar (substituição por deslocamento).&lt;/li>
&lt;/ul>
&lt;h3 id="observações">Observações &lt;a href="#observa%c3%a7%c3%b5es" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>A segurança depende &lt;strong>inteiramente do segredo da chave&lt;/strong>.&lt;/li>
&lt;li>Bons algoritmos como &lt;strong>AES&lt;/strong> devem ser usados.&lt;/li>
&lt;li>&lt;strong>Nunca crie seu próprio algoritmo de criptografia.&lt;/strong>&lt;/li>
&lt;/ul>
&lt;h2 id="3-criptografia-simétrica">3. Criptografia Simétrica &lt;a href="#3-criptografia-sim%c3%a9trica" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Usa a &lt;strong>mesma chave&lt;/strong> para encriptar e decriptar.&lt;/li>
&lt;li>Exemplo: AES.&lt;/li>
&lt;li>Rápida e adequada para grandes volumes de dados.&lt;/li>
&lt;li>Problema: &lt;strong>distribuição segura da chave&lt;/strong>.&lt;/li>
&lt;/ul>
&lt;h2 id="4-criptografia-de-chave-pública-asssimétrica">4. Criptografia de Chave Pública (Asssimétrica) &lt;a href="#4-criptografia-de-chave-p%c3%bablica-asssim%c3%a9trica" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Usa &lt;strong>par de chaves&lt;/strong>: uma pública e uma privada.&lt;/li>
&lt;li>Exemplo: RSA.&lt;/li>
&lt;li>Permite:
&lt;ul>
&lt;li>&lt;strong>Autenticação&lt;/strong>: encriptar com chave privada → qualquer um pode verificar com chave pública.&lt;/li>
&lt;li>&lt;strong>Sigilo&lt;/strong>: encriptar com chave pública → só o dono da chave privada pode ler.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>Mais lenta que criptografia simétrica.&lt;/li>
&lt;li>Usada principalmente para &lt;strong>troca de chave segura&lt;/strong>.&lt;/li>
&lt;/ul>
&lt;h3 id="exemplo-prático">Exemplo prático: &lt;a href="#exemplo-pr%c3%a1tico" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>Microsoft assina atualizações com sua &lt;strong>chave privada&lt;/strong>.&lt;/li>
&lt;li>Usuários verificam com a &lt;strong>chave pública&lt;/strong> que foi assinada pela Microsoft.&lt;/li>
&lt;/ul>
&lt;h2 id="5-hashes-criptográficos">5. Hashes Criptográficos &lt;a href="#5-hashes-criptogr%c3%a1ficos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Funções que mapeiam entrada de tamanho variável para saída de tamanho fixo.&lt;/li>
&lt;li>Ex: SHA-3.&lt;/li>
&lt;li>Usado para:
&lt;ul>
&lt;li>&lt;strong>Verificação de integridade&lt;/strong>&lt;/li>
&lt;li>&lt;strong>Armazenamento de senhas&lt;/strong>&lt;/li>
&lt;li>&lt;strong>Proof-of-work&lt;/strong> (blockchain, antispam)&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>Propriedades desejadas:
&lt;ul>
&lt;li>Dificuldade de colisão (duas entradas com mesmo hash).&lt;/li>
&lt;li>Dificuldade de inferência do conteúdo a partir do hash.&lt;/li>
&lt;li>Pequenas mudanças → grandes alterações no hash.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;h3 id="exemplo-1">Exemplo: &lt;a href="#exemplo-1" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>Arquivo + hash = integridade.&lt;/li>
&lt;li>Alteração no arquivo → hash diferente → detecção de ataque.&lt;/li>
&lt;/ul>
&lt;h2 id="6-quebrando-criptografia">6. Quebrando Criptografia &lt;a href="#6-quebrando-criptografia" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;h3 id="métodos-comuns">Métodos comuns: &lt;a href="#m%c3%a9todos-comuns" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>&lt;strong>Brute force&lt;/strong>: testar todas as chaves.&lt;/li>
&lt;li>&lt;strong>Fuga de chave&lt;/strong>: falhas de implementação, vazamentos (ex: Heartbleed).&lt;/li>
&lt;li>&lt;strong>Chaves previsíveis&lt;/strong>: gerar com relógio do sistema, PID, etc.&lt;/li>
&lt;li>&lt;strong>Chaves compartilhadas&lt;/strong>: mesmo par de chaves em múltiplos dispositivos.&lt;/li>
&lt;/ul>
&lt;h3 id="boas-práticas">Boas práticas: &lt;a href="#boas-pr%c3%a1ticas" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>Usar /dev/random (Linux) para obter entropia.&lt;/li>
&lt;li>Nunca armazenar chaves em texto puro no sistema.&lt;/li>
&lt;li>Usar &lt;strong>tamanho adequado de chave&lt;/strong> (AES-128 ou maior).&lt;/li>
&lt;/ul>
&lt;h2 id="7-criptografia-no-so">7. Criptografia no SO &lt;a href="#7-criptografia-no-so" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Se o sistema operacional &lt;strong>pode ver a chave&lt;/strong>, ele &lt;strong>pode quebrar a segurança&lt;/strong>.&lt;/li>
&lt;li>Em ambientes confiáveis, o SO pode usar criptografia para:
&lt;ul>
&lt;li>&lt;strong>Armazenar senhas&lt;/strong> com hash unidirecional.&lt;/li>
&lt;li>&lt;strong>Transmitir dados criptografados&lt;/strong> pela rede (mesmo que o canal seja inseguro).&lt;/li>
&lt;li>&lt;strong>Usar enclaves de hardware&lt;/strong> para isolar chaves (ex: TPM).&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;h2 id="8-criptografia-de-dados-em-repouso-at-rest">8. Criptografia de Dados em Repouso (At-Rest) &lt;a href="#8-criptografia-de-dados-em-repouso-at-rest" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Protege dados armazenados em disco contra acesso físico não autorizado.&lt;/li>
&lt;li>Tipos:
&lt;ul>
&lt;li>&lt;strong>Criptografia de arquivos individuais&lt;/strong>&lt;/li>
&lt;li>&lt;strong>Criptografia de volume&lt;/strong>&lt;/li>
&lt;li>&lt;strong>Full disk encryption (BitLocker, FileVault)&lt;/strong>&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;h3 id="benefícios">Benefícios: &lt;a href="#benef%c3%adcios" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>Protege dados em caso de perda ou roubo do dispositivo.&lt;/li>
&lt;/ul>
&lt;h3 id="limitações">Limitações: &lt;a href="#limita%c3%a7%c3%b5es" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>Não protege contra usuários com acesso legítimo.&lt;/li>
&lt;li>Não protege contra falhas no aplicativo ou no sistema operacional.&lt;/li>
&lt;/ul>
&lt;h3 id="exemplos">Exemplos: &lt;a href="#exemplos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>Backup na nuvem: criptografar antes do envio.&lt;/li>
&lt;li>Arquivamento: criptografar e armazenar sem necessidade de acesso regular.&lt;/li>
&lt;li>Email criptografado com GPG.&lt;/li>
&lt;/ul>
&lt;h2 id="9-vaults-de-senhas">9. Vaults de Senhas &lt;a href="#9-vaults-de-senhas" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Aplicações que armazenam senhas encriptadas.&lt;/li>
&lt;li>Chave derivada de &lt;strong>senha mestra&lt;/strong>.&lt;/li>
&lt;li>Armazenadas só na &lt;strong>RAM&lt;/strong> durante uso.&lt;/li>
&lt;li>Exemplo: gerenciadores de senhas como KeePass, Bitwarden.&lt;/li>
&lt;/ul>
&lt;h2 id="10-capacidades-criptográficas">10. Capacidades Criptográficas &lt;a href="#10-capacidades-criptogr%c3%a1ficas" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Solução para &lt;strong>capabilities forjáveis&lt;/strong> discutidas em controle de acesso.&lt;/li>
&lt;li>Um sistema pode emitir uma &lt;strong>capability criptografada&lt;/strong> que:
&lt;ul>
&lt;li>Indica permissões, identidade, tempo de expiração.&lt;/li>
&lt;li>Pode ser verificada por outro sistema com a chave correta.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>Pode usar:
&lt;ul>
&lt;li>&lt;strong>Chave simétrica&lt;/strong>: criador e verificador compartilham chave.&lt;/li>
&lt;li>&lt;strong>Chave pública&lt;/strong>: criador assina; verificador valida.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;h2 id="11-conclusão">11. Conclusão &lt;a href="#11-conclus%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>A criptografia é uma ferramenta poderosa, mas depende:
&lt;ul>
&lt;li>Do uso de &lt;strong>algoritmos fortes&lt;/strong>&lt;/li>
&lt;li>Da &lt;strong>secrecy da chave&lt;/strong>&lt;/li>
&lt;li>Da &lt;strong>implementação cuidadosa&lt;/strong>&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>Deve ser usada com parcimônia e &lt;strong>sabedoria arquitetural&lt;/strong>.&lt;/li>
&lt;li>Para SOs, seu uso é mais efetivo &lt;strong>fora da memória ativa do sistema&lt;/strong> ou &lt;strong>em trânsito&lt;/strong>.&lt;/li>
&lt;/ul>
&lt;h2 id="12-exemplos-práticos">12. Exemplos Práticos &lt;a href="#12-exemplos-pr%c3%a1ticos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>Aplicação&lt;/th>
 &lt;th>Criptografia Usada&lt;/th>
 &lt;th>Observação&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>HTTPS&lt;/td>
 &lt;td>Simétrica + Assimétrica&lt;/td>
 &lt;td>Troca de chave com RSA, dados com AES&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Senhas no Linux&lt;/td>
 &lt;td>Hash (SHA-3 com salt)&lt;/td>
 &lt;td>Nunca armazenadas em texto puro&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Backup na nuvem&lt;/td>
 &lt;td>Simétrica (AES)&lt;/td>
 &lt;td>Dados criptografados antes do upload&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Gerenciador de Senhas&lt;/td>
 &lt;td>AES + senha mestra&lt;/td>
 &lt;td>Armazena na RAM, requer senha ao iniciar&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>BitLocker / FileVault&lt;/td>
 &lt;td>Full disk encryption (AES)&lt;/td>
 &lt;td>Chave obtida via senha ou TPM no boot&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Emails com GPG&lt;/td>
 &lt;td>Chave pública + privada&lt;/td>
 &lt;td>Assinatura + criptografia&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table></description></item><item><title>.2. Álgebra Relacional</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/4.2.-%C3%A1lgebra-relacional/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/banco-de-dados/4.2.-%C3%A1lgebra-relacional/</guid><description>&lt;p>Operações da teoria dos conjuntos que suportam a linguagem SQL.&lt;/p>
&lt;ol>
&lt;li>
&lt;p>Seleção -&amp;gt; $\sigma_{&lt;p>}(R)$
onde R é uma relação e $p$ um predicado
obtém os elementos de R que atendem o predicado $p$.
![[Pasted image 20250513161726.png]]&lt;/p>
&lt;/li>
&lt;li>
&lt;p>Projeção $\prod_{\text{lista de atributos}}(R)$ -&amp;gt; obtém todos os elementos de R mas exibe apenas os atributos pedidos na lista de atributos.
![[Pasted image 20250513162010.png]]&lt;/p>
&lt;/li>
&lt;li>
&lt;p>Produto Cartesiano $R \times S$ -&amp;gt; Permite combinar a informação contida em duas relações.
cliente X Conta. Concatena todas as tuplas de R com todas as de S. ($n\times m$)
conta($\underline{rg_cli}$, num_cta, saldo)&lt;/p></description></item><item><title>.2. Camada de Rede pt.3</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/9.2.-camada-de-rede-pt.3/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/9.2.-camada-de-rede-pt.3/</guid><description>&lt;p>Para alcançar a &amp;ldquo;rede x&amp;rdquo;, colocamos os pacotes na interface y. Este mapeamento é dado na &lt;code>tabela de roteamento&lt;/code> através de algoritmos de roteamento da camada de rede.&lt;/p>
&lt;p>Objetivo: determinar melhor caminho pela rede.
Usaremos uma abstração de grafos para tal, no qual cada vértice é um roteador e cada aresta representa os links físicos, com w = custo do enlace.&lt;/p>
&lt;h1 id="tipos-de-algoritmos-de-roteamento">Tipos de Algoritmos de roteamento &lt;a href="#tipos-de-algoritmos-de-roteamento" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Podem ser classificados quanto:&lt;/p></description></item><item><title>.2. Compartilhamento-Proporcional-da-CPU</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/3.2.-compartilhamento-proporcional-da-cpu/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/3.2.-compartilhamento-proporcional-da-cpu/</guid><description>&lt;p>Esse documento representa parte dos meus estudos acerca do Livro - Operational Systems Three Easy Pieces, de dominio publico.&lt;/p>
&lt;hr>
&lt;h1 id="proportional-share">Proportional Share &lt;a href="#proportional-share" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Um exemplo de compartilhamento proporcional/justo eh o &lt;strong>lottery scheduling&lt;/strong>. Esse algoritmo representa uma ideia simples, processos que precisam de mais recurso tem mais chance de ganhar a loteria feita a cada &lt;em>n&lt;/em> segundos.&lt;/p>
&lt;h2 id="lottery-scheduling">Lottery Scheduling &lt;a href="#lottery-scheduling" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>O primeiro conceito de lottery scheduling sao os tickets, que sao usados para representar fatia de recursos que um processo deve receber. A porcentagem de tickets que um processo tem representa a parcela dos recursos que este proc tem.&lt;/p></description></item><item><title>.2. FTP</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/7.2.-ftp/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/7.2.-ftp/</guid><description>&lt;p>Este documento representa meus estudos acerca do livro Redes de Computadores e a Internet - uma abordagem top down&lt;/p>
&lt;hr>
&lt;h2 id="portas">Portas &lt;a href="#portas" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Port number: 16 bits&lt;/p>
&lt;p>2 tipos de portas:&lt;/p>
&lt;h2 id="well-known-service-portas-publicas">Well-Known Service (portas publicas) &lt;a href="#well-known-service-portas-publicas" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Sao reservadas para processos especificos, geralmente processos servidores (padronizadas pelo IANA -Internet Assigned Numbers Authority).&lt;/p>
&lt;p>Rodam no root (superusuario) mode, de 1 a 1023, ou seja, so roots conseguem alterar essas portas.&lt;/p>
&lt;h2 id="efemeras">Efemeras &lt;a href="#efemeras" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Portas temporarias usadas pela camada de transporte.
vao de 40000 ate 65535. Rodam no espaco de usuario.&lt;/p></description></item><item><title>.2. RAID's</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/12.2.-raids/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/12.2.-raids/</guid><description>&lt;p>Técnica utilizada para escalar o uso de discos num sistema computacional. Como o nome sugere, utiliza-se de varios discos simultaneamente com diversas técnicas e politicas de sincronização.&lt;/p>
&lt;p>Para o SO que acessa o RAID, ele se parece apenas como um disco com proporções homéricas, ou seja, não há diferença alguma na sua interface de conexão.&lt;/p>
&lt;h1 id="interface-e-componentes-internos-raid">Interface e componentes internos RAID &lt;a href="#interface-e-componentes-internos-raid" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>A interface externa é identica à servida por apenas um disco. O FS ou client simplesmente faz uma requisição &lt;em>lógica&lt;/em> de IO ao RAID, o qual traduz os endereços de acordo com sua política e controle interno e devolve o resultado esperado de um disco.&lt;/p></description></item><item><title>.2. Semaforos</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/11.2.-semaforos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/11.2.-semaforos/</guid><description>&lt;p>Um semáforo eh um objeto com um valor inteiro que contem 2 rotinas de manipulação:&lt;/p>
&lt;ul>
&lt;li>sem_wait()&lt;/li>
&lt;li>sem_post()&lt;/li>
&lt;/ul>


 
 &lt;div class="highlight">&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">&lt;code class="language-c" data-lang="c">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">#include&lt;/span> &lt;span style="color:#75715e">&amp;lt;semaphore.h&amp;gt;&lt;/span>&lt;span style="color:#75715e">
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#66d9ef">sem_t&lt;/span> s;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#a6e22e">sem_init&lt;/span>(&lt;span style="color:#f92672">&amp;amp;&lt;/span>s, &lt;span style="color:#ae81ff">0&lt;/span>, &lt;span style="color:#ae81ff">1&lt;/span>);&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;h2 id="semáforo-como-lock">Semáforo como lock &lt;a href="#sem%c3%a1foro-como-lock" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>so utilizar um wait previamente a sessão critica e liberá-lo após a região critica. Iniciar o semáforo com 1.&lt;/p>
&lt;h2 id="semáforo-para-ordenação">Semáforo para ordenação &lt;a href="#sem%c3%a1foro-para-ordena%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>podemos usar um semáforo como uma primitiva de ordenação, ou seja, colocamos uma thread em espera e chamamos uma função associada a ela. Mandamos um sem_wait() e fazemos o o codigo somente terminar quando zerar o valor de sem_init(t, 0, 0) com X iterações nas threads filhas chamadas, ou seja, quando o recurso do filho é criado.&lt;/p></description></item><item><title>.3. - SSD's - Solid-state storage device</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/12.3.---ssds---solid-state-storage-device/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/12.3.---ssds---solid-state-storage-device/</guid><description>&lt;p>Discos padrão são em torno de 100.000x mais lentos que o desempenho acumulado entre cache e CPU. Portanto usar um SSD hoje é quase indispensável. Ele usa uma tecnologia chamada de NAND-based flash.&lt;/p>
&lt;h2 id="operações-em-memória-flash">Operações em memória flash &lt;a href="#opera%c3%a7%c3%b5es-em-mem%c3%b3ria-flash" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Leitura, escrita (programação da página), apagamento de bloco.&lt;/p>
&lt;ul>
&lt;li>read: simples leitura em um vetor, acesso aleatório.&lt;/li>
&lt;li>erase&lt;/li>
&lt;li>program
Quando é necessária uma escrita de página, todos os bits de uma página em um SSD tem que ser igual a 1. Ou seja, toda escrita gera um &lt;em>overhead&lt;/em> de sobrescrita, onde colocamos todos os bits pra 1 e a partir dai ocorre a escrita. Esta operação também não pode ser paginada, tem que ser feita de forma blocada, ou seja, n blocos com m páginas (chamados de bloco de apagamento).&lt;/li>
&lt;/ul>
&lt;p>Este é um plano com 3 blocos e 12 páginas
![[Pasted image 20250514123914.png]]&lt;/p></description></item><item><title>.3. BGP</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/9.3.-bgp/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/9.3.-bgp/</guid><description>&lt;p>Os 3 cenários do BGP:&lt;/p>
&lt;ol>
&lt;li>Sessão &lt;code>eBGP&lt;/code> -&amp;gt; obter-se info de acesso a uma sub-rede a partir de ASs vizinhos&lt;/li>
&lt;li>Sessão &lt;code>iBGP&lt;/code> -&amp;gt; propagar info de acessibilidade a todos os roteadores internos do AS.&lt;/li>
&lt;li>Roteamento de transito entre AS&lt;/li>
&lt;/ol>
&lt;hr>
&lt;h3 id="vizinhança-external-bgp">Vizinhança &amp;ldquo;external BGP&amp;rdquo; &lt;a href="#vizinhan%c3%a7a-external-bgp" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;p>2 ou mais roteadores em ASs distintos se comunicam por roteamento inter-sistemas autônomos.&lt;/p>
&lt;p>![[Pasted image 20250603101145.png]]
Caminho de A-H: usa roteamento de trânsito.&lt;/p>
&lt;h3 id="vizinhança-internal-bgp">Vizinhança &amp;ldquo;internal BGP&amp;rdquo; &lt;a href="#vizinhan%c3%a7a-internal-bgp" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;p>A comunicação intra-sistemas autônomos ocorre quando o protocolo BGP-4 é configurado entre dois ou mais roteadores pertencentes ao mesmo AS.&lt;/p></description></item><item><title>.3. Problemas-comuns-de-concorrência</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/11.3.-problemas-comuns-de-concorr%C3%AAncia/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/11.3.-problemas-comuns-de-concorr%C3%AAncia/</guid><description>&lt;p>Starvation ocorre quando um processo nunca consegue ser executado devido a um scheduler não funcionar corretamente. Esse problema não é tratado por meio de primitivas e sim pela implementação de um scheduler que escala os processos conseguindo garantir execução a todos.&lt;/p>
&lt;p>O livelock ocorre quando dois processos ficam alternando o controle da CPU entre si, assim ambos continuam vivos tentando entrar em execução e passando o controle sobre a CPU e assim nenhum dos dois executam. Esse problema também não é tratado já que depende de “sorte”.&lt;/p></description></item><item><title>.3. SMTP</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/7.3.-smtp/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/7.3.-smtp/</guid><description>&lt;h1 id="email">Email &lt;a href="#email" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Tres componentes:&lt;/p>
&lt;ol>
&lt;li>Mail User Agent (MUA)&lt;/li>
&lt;li>Mail transport Agent (MTA)&lt;/li>
&lt;li>Mail Delivery Agent (POP3 / IMAP)&lt;/li>
&lt;/ol>
&lt;ul>
&lt;li>Entrega armazenamento no servidor receptor&lt;/li>
&lt;li>MDA ou MAA acessam o correio recebido&lt;/li>
&lt;/ul>
&lt;p>Utiliza-se da porta 25/TCP&lt;/p>
&lt;ul>
&lt;li>A transferencia eh direta ao receptor.&lt;/li>
&lt;/ul>
&lt;p>3 fases:&lt;/p>
&lt;ol>
&lt;li>negociacao (handshaking).&lt;/li>
&lt;li>transferencia de mensagens.&lt;/li>
&lt;li>encerramento.&lt;/li>
&lt;/ol>
&lt;p>Comandos sao em ASCII 7-bits e a resposta emite codigo e frase de status.&lt;/p></description></item><item><title>.4. DNS</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/7.4.-dns/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/7.4.-dns/</guid><description>&lt;p>Dispositivos na Internet sao identificados por numeros (IP).
Mas eh importante utilizar-se de mnemonicos para se comunicar com outras maquinas, principalmente para os seres humanos.&lt;/p>
&lt;blockquote>
&lt;p>Como podemos converter um endereco IP em um nome?&lt;/p>&lt;/blockquote>
&lt;p>Esse processo eh chamado de &lt;strong>resolucao de nomes&lt;/strong> em IP&amp;rsquo;s. Para isso, usaremos o protocolo DNS.&lt;/p>
&lt;h1 id="dns-domain-name-system">DNS (Domain Name System) &lt;a href="#dns-domain-name-system" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>o DNS eh composto por:&lt;/p>
&lt;ul>
&lt;li>uma base de dados distribuída (nameservers).&lt;/li>
&lt;li>um protocolo da camada de aplicação que permite consultar e resolver nomes.&lt;/li>
&lt;/ul>
&lt;p>O protocolo IP funciona sobre a UDP na porta 53 (53/UDP).&lt;/p></description></item><item><title>.5. Aplicacoes-P2P</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/7.5.-aplicacoes-p2p/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/redes-de-computadores/7.5.-aplicacoes-p2p/</guid><description>&lt;p>O mais usado na Internet.
Ele nao utiliza do potencial de computacao distribuida proveniente na Rede. Eh uma classe de aplicacoes que aproveita dos recursos na borda da rede, diretamente entre os sistemas.&lt;/p>
&lt;ul>
&lt;li>Armazenamento&lt;/li>
&lt;li>Processamento&lt;/li>
&lt;li>Largura de Banda&lt;/li>
&lt;/ul>
&lt;p>Quando um client procura por um arquivo em um seeder na rede e comeca a fazer o download, ele mesmo passa a ser um seeder, como um servidor, e disponibiliza o arquivo.&lt;/p></description></item><item><title>.AFD-Equivalente</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/6.afd-equivalente/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/6.afd-equivalente/</guid><description>&lt;h1 id="aula-6">Aula 6 &lt;a href="#aula-6" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Todo AFN tem um AFD equivalente. Ou seja, aceita a mesma linguagem.&lt;/p>
&lt;p>





 



 
&lt;/p>
&lt;p>





 



 
&lt;/p>
&lt;h1 id="prova-do-teorema">Prova do Teorema &lt;a href="#prova-do-teorema" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Seja $N=(Q_n, \Sigma, \delta_n ,q_{0n},F_n)$ o AFN que aceita alguma linguagem $L$. Vamos construir o AFD que ceita $L$.&lt;/p>
&lt;h2 id="caso-1-sem-epsilon-transição">Caso 1: Sem $\epsilon$-transição &lt;a href="#caso-1-sem-epsilon-transi%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>$Q_m=P(Q_n)$, ou seja, é o conjunto de $Q_n$.&lt;/li>
&lt;li>$\Sigma$ é igual nos dois casos.&lt;/li>
&lt;li>Para cada $R\in Q_n$ e $a \in \Sigma$, seja $\delta(R,a)={q \in Q_n|q\in \delta_n(r,a)\text{ para algum }r\in R}$. Ou seja $\delta_m(R,a)=\displaystyle\bigcup_{r\in R} \delta_n(r,a)$&lt;/li>
&lt;li>$q_{0m}={q_{0n}}$.&lt;/li>
&lt;li>$F_m={R\in Q_n|R \text{ contém ao menos 1 estado de aceitação de } Q_n}$ .&lt;/li>
&lt;/ul>
&lt;h2 id="caso-2-com-epsilon-transições">Caso 2: Com $\epsilon$-transições &lt;a href="#caso-2-com-epsilon-transi%c3%a7%c3%b5es" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>$Q_m=P(Q_n)$, ou seja, é o conjunto de $Q_n$.&lt;/li>
&lt;li>$\Sigma$ é igual nos dois casos.&lt;/li>
&lt;li>Agora modificamos a função de transição $\delta_n$ trocando $\delta(r,a)$ por $E(\delta(r,a))$. $\delta (R,a)={q\in Q|q\in E(\delta(r,a))\text{ para algum }r\in R}$&lt;/li>
&lt;li>$q_{0m}={q|q\text{ pode ser alcançada a partir de }R\text{ por zero ou mais } \epsilon \text { transições}}=E({q_{0n}}$. Definimos $E(R)$ como sendo o conjunto de estados que podem ser alcançados a partir de $R$ somente através de $\epsilon$ transições incluindo os membros de $R$&lt;/li>
&lt;li>$F_m={R\in Q_n|R \text{ contém ao menos 1 estado de aceitação de } Q_n}$ .&lt;/li>
&lt;/ul>
&lt;p>





 



 
&lt;/p></description></item><item><title>1 e 2 - Armazenamento secundário</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/1-2---armazenamento-secund%C3%A1rio/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/1-2---armazenamento-secund%C3%A1rio/</guid><description>&lt;h1 id="armazenamento-secundário-parte-1">Armazenamento secundário (parte 1) &lt;a href="#armazenamento-secund%c3%a1rio-parte-1" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;h1 id="formatação-física">Formatação Física &lt;a href="#formata%c3%a7%c3%a3o-f%c3%adsica" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>HDD é organizado em&lt;/p>
&lt;ul>
&lt;li>discos&lt;/li>
&lt;li>superfícies: organizados em trilhas&lt;/li>
&lt;li>trilhas: organizados em setores&lt;/li>
&lt;li>cilindro: conjunto de trilhas em diferentes discos&lt;/li>
&lt;/ul>
&lt;p>Seeking → movimento de posicionar a cabeça de R/W sobre a trilha/setor&lt;/p>
&lt;p>Cluster → conjunto de setores logicamente contíguos no disco, descritos pelo sistema de arquivos&lt;/p>
&lt;p>Extent → sequencia de clusters consecutivos em um disco&lt;/p>
&lt;p>Fragmentação → perda parcial de setores de tamanho fixo&lt;/p></description></item><item><title>AC</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/ac/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/ac/</guid><description>&lt;p>PT 1&lt;/p>
&lt;p>[[bcc/3° Semestre/AC/Conceitos/Conceitos|Conceitos]]&lt;/p>
&lt;p>[[Memórias]]&lt;/p>
&lt;p>[[Entrada e Saída]]&lt;/p>
&lt;p>[[SO]]&lt;/p>
&lt;p>[[Aritmética Computacional]]&lt;/p>
&lt;hr>
&lt;p>PT 2&lt;/p>
&lt;p>[[Conjunto de Instruções]]&lt;/p>
&lt;p>[[CPU]]&lt;/p>
&lt;p>[[Ciclo de instrução – O retorno]]&lt;/p>
&lt;p>[[RISC X CISC]]&lt;/p>
&lt;p>[[Paralelismo em nível de instrução]]&lt;/p>
&lt;p>[[Paralelismo em nível de dados]]&lt;/p>
&lt;p>[[GPU]]&lt;/p>
&lt;p>[[Paralelismo em nível de thread (n vou terminar esse)]]&lt;/p></description></item><item><title>Ajustando uma distribuição uniforme em uma distribuição exponencial</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/12---ajustando-uma-distribui%C3%A7%C3%A3o-uniforme-em-uma-distribui%C3%A7%C3%A3o-exponencial/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/12---ajustando-uma-distribui%C3%A7%C3%A3o-uniforme-em-uma-distribui%C3%A7%C3%A3o-exponencial/</guid><description>&lt;h2 id="t----frac1aln1-u">Se $F(t)= u,$ então t = $F^{-1}(u)$
$1 - e^{-\alpha t}=u \implies$
$1-u = e^{-\alpha t}\implies$
$\ln(1-u) = -\alpha t \implies$
$$t = - \frac{1}{a}\ln(1-u)$$ &lt;a href="#t----frac1aln1-u" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Para gerar uma seq de n valores com dist exp de parametro&lt;/p>
&lt;ol>
&lt;li>faça j=1&lt;/li>
&lt;li>gere o NA u, no intervalo $[0,1]$&lt;/li>
&lt;li>calcule o valor de t, usando a fórmula (1)&lt;/li>
&lt;li>verifique se t&amp;gt;0 e $n\geq 1$&lt;/li>
&lt;li>se $j&amp;lt;n$, faça j=j+1&lt;/li>
&lt;li>volte ao passo 2&lt;/li>
&lt;/ol>
&lt;hr>
&lt;p>Exemplo: Ajuste de modelo exponencial.
média = $\frac{1}{\alpha} = 3 ,\alpha = \frac{1}{3}$
T: tempo residual
$T ~ Exp(\frac{1}{3})$&lt;/p></description></item><item><title>Ajuste de Curvas com mínimos quadrados</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/17---ajuste-de-curvas-com-m%C3%ADnimos-quadrados/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/17---ajuste-de-curvas-com-m%C3%ADnimos-quadrados/</guid><description>&lt;h1 id="mínimos-quadrados">Mínimos quadrados &lt;a href="#m%c3%adnimos-quadrados" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Considere o problema de aproximar uma $f(x)$ ou um conjunto de dados ($X, Y$) por uma função $g(X)$ mais simples na forma que:&lt;/p>
&lt;ul>
&lt;li>(1) A diferença entre $f(x)$ e $g(x)$ seja mínima.&lt;/li>
&lt;li>(2) a função $g(x)$ seja mais fácil de ser manuseada.&lt;/li>
&lt;/ul>
&lt;h2 id="caso-discreto">Caso Discreto &lt;a href="#caso-discreto" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>A condição (2) do caso discreto é a seguinte:&lt;/p>
&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>X&lt;/th>
 &lt;th>$x_1$&lt;/th>
 &lt;th>$\dots$&lt;/th>
 &lt;th>$x_n$&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>Y&lt;/td>
 &lt;td>$f(x_{1})$&lt;/td>
 &lt;td>$\dots$&lt;/td>
 &lt;td>$f(x_n)$&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>$$I = \sum_{j=1}^{n}\limits[f(x_{j})-g(x_{j})]^{2}\times w_{j}$$&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>onde $w_{j}$ (weight) são os pesos atribuídos a cada diferença. Vamos considerar $w_{j} =1$ a priori.&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;p>Escolhemos $n$ funções $g, g_{1}, g_{2} \dots$ contínuas, e tomamos $g(x)$ como a comb. linear $G(x) = \alpha_{1}g_{1}(x) +\dots +\alpha_{n}g_{n}(x)$ com $\alpha_{j} \in R$.&lt;/p></description></item><item><title>Ajuste de curvas não linear</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/18---ajuste-de-curvas-n%C3%A3o-linear/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/18---ajuste-de-curvas-n%C3%A3o-linear/</guid><description>&lt;p>No caso não linear, $g(x)$ não precisa ser combinação linear.
Os casos serão:&lt;/p>
&lt;ul>
&lt;li>$g(x) = \alpha_{1}e^{\alpha_{2}\times x}$&lt;/li>
&lt;li>$g(x) = \alpha_{1}\alpha_{2}^{x}$&lt;/li>
&lt;li>$g(x) = \frac{1}{\alpha_{1}+\alpha_{2}x}$&lt;/li>
&lt;/ul>
&lt;h1 id="linearização">linearização &lt;a href="#lineariza%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Para resolver, recorremos a &lt;strong>linearização da $f$&lt;/strong>. Por exemplo, para o função $g(x) = \alpha e^{\alpha_{1}x}$. Usaremos o $\ln$ na $g(x)$
$h(x) = \ln g(x) = ln(\alpha_{1}e^{\alpha_{2}x})$
= $\ln\alpha_{1}+\ln e^{\alpha_{2}x}$
= $ln\alpha_{1} + \alpha_{2}x$ = $ax +b$&lt;/p></description></item><item><title>AL</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/algebra-linear/al/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/algebra-linear/al/</guid><description>&lt;p>AB = BA = Id.&lt;/p>
&lt;p>Esse método de escalonar a matriz ampliada do sistema para encontrar sua solução é conhecido como método de Gauss-Jordan.&lt;/p>
&lt;h3 id="sistema-de-cramer">SISTEMA DE CRAMER &lt;a href="#sistema-de-cramer" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;p>AX = B ⇔&lt;/p>
&lt;p>A⁻¹(AX) = A⁻¹B ⇔&lt;/p>
&lt;p>(A⁻¹A)X = A⁻¹B ⇔&lt;/p>
&lt;p>X = A⁻¹B.&lt;/p>
&lt;h2 id="espaço-vet">Espaço vet &lt;a href="#espa%c3%a7o-vet" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ol>
&lt;li>
&lt;p>u + v = v + u (comutativa).&lt;/p>
&lt;/li>
&lt;li>
&lt;p>u + (v + w) = (u + v) + w (associativa).&lt;/p>
&lt;/li>
&lt;li>
&lt;p>Existe em V um elemento neutro, denotado por 0, tal que u + 0 = u.&lt;/p></description></item><item><title>Algoritmo (Dec - Bin) (fracionários)</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/2---algoritmo-dec---bin-fracion%C3%A1rios/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/2---algoritmo-dec---bin-fracion%C3%A1rios/</guid><description>&lt;h1 id="dec---bin">DEC - Bin &lt;a href="#dec---bin" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>&lt;strong>Exemplo:&lt;/strong> $r = (0.625)_{10}$&lt;/p>
&lt;ol>
&lt;li>$0.625 = d_{1}\times 2^{-1} + d_{2}\times 2^{-2} + &amp;hellip; + d_{k}\times 2^{-k}$&lt;/li>
&lt;li>$1.250 = d_{1} + d_{2}\times 2^{-1} + &amp;hellip; + d_{k}\times 2^{-k+1}$&lt;/li>
&lt;li>$d_{2}\times 2^{-1} + &amp;hellip; + d_{k}\times 2^{-k+1} \leq 1\times 2^{-1} + &amp;hellip; + 1\times 2^{-k+1} \leq 2^{-1} + &amp;hellip; + 2^{-k+1} + &amp;hellip; = 1$
Portanto $d_{1}$ é a parte inteira de 1.250, ou seja $d_{1} = 1$. Logo,
$1.250 = 1 + d_{2} \times 2^{-1} + &amp;hellip; + d_{2} \times 2^{-k+1}$
Subtraindo 1, obtemos:
$0.250 = d_{2} \times 2^{-1} + &amp;hellip; + d_{k} \times 2^{-k+1}$
Multiplicando por 2 a equação:
$0.500 = d_{2} + &amp;hellip; + d_{k} \times 2^{-k+2}$ -&amp;gt; $d_{2} = 0$
&amp;hellip; (Repetição desse processo )&lt;/li>
&lt;/ol>
&lt;p>Seja $R_{0}$ um número fracionário positivo na base decimal, e seja $(0.d_{1}d_{2}&amp;hellip;)_{2}$ sua representação na base 2. Então:&lt;/p></description></item><item><title>Algoritmos Gulosos</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/12---algoritmos-gulosos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/12---algoritmos-gulosos/</guid><description/></item><item><title>analisador-lexico</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/2-analisador-lexico/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/2-analisador-lexico/</guid><description>&lt;ul>
&lt;li>A entrada na &amp;ldquo;fita&amp;rdquo; do scanner (AFD) é feita por um programa anterior (leitor de arquivo) que usa de separadores da linguagem de programação (e.g $).
&lt;ul>
&lt;li>O scanner (analisador léxico) então verifica se o(s) token(s) enviado(s) é(são) válido(s).&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>O analisar léxico analisa somente se os tokens são BEM FORMADOS.&lt;/li>
&lt;/ul>
&lt;h1 id="exemplo-de-erros-léxicos">Exemplo de erros léxicos &lt;a href="#exemplo-de-erros-l%c3%a9xicos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>Uso de caracteres fora do alfabeto da linguagem;&lt;/li>
&lt;li>Erros de grafia.&lt;/li>
&lt;/ul>
&lt;h1 id="token-padrões-e-lexemas">Token: padrões e lexemas &lt;a href="#token-padr%c3%b5es-e-lexemas" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>Cada LP possui um conjunto de tokens que definem as sequências de caracteres válidos para a linguagem.&lt;/li>
&lt;li>Cada sequência de caractere em um programa fonte tem significado próprio na LP.&lt;/li>
&lt;li>Por exemplo, a sequência &amp;ldquo;if&amp;rdquo; pode significar um identificador ou o nome de uma estrutura de controle (dependendo da linguagem).&lt;/li>
&lt;li>Sequências diferentes podem estar associadas ao mesmo token. Ex: 10 e 234&lt;/li>
&lt;li>A sequência de caracteres que forma um token é chamada &lt;strong>lexema&lt;/strong>
&lt;ul>
&lt;li>Ex: pi = 3,1416;&lt;/li>
&lt;li>pi é um lexema pra o token identificador.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>O padrão de um token é a regra de formação (ex: nome de variável em c).
&lt;ul>
&lt;li>Ex: token CONSTANTE_INTEIRA tem o padrão sequência de um ou mais dígitos&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;h1 id="maneira-de-implementar-um-analisador-léxico">Maneira de implementar um Analisador Léxico &lt;a href="#maneira-de-implementar-um-analisador-l%c3%a9xico" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ol>
&lt;li>Construir um simulador de um AF.&lt;/li>
&lt;li>Implementar as transições de estado no código (chumbado).&lt;/li>
&lt;li>Usar um gerador de analisador léxico.&lt;/li>
&lt;/ol></description></item><item><title>Analise e Verificação de Circuitos em FPGA</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/9---analise-e-verifica%C3%A7%C3%A3o-de-circuitos-em-fpga/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/9---analise-e-verifica%C3%A7%C3%A3o-de-circuitos-em-fpga/</guid><description>&lt;h1 id="análise-e-verificação-de-circuitos-em-fpga-utilizando-a-linguagem-vhdl">Análise e verificação de Circuitos em FPGA utilizando a linguagem VHDL &lt;a href="#an%c3%a1lise-e-verifica%c3%a7%c3%a3o-de-circuitos-em-fpga-utilizando-a-linguagem-vhdl" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>VHDL é um descrição de hardware, que ora ou outra é considerada um hardware.&lt;/p></description></item><item><title>Análise Exploratória de dados</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/14---an%C3%A1lise-explorat%C3%B3ria-de-dados/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/14---an%C3%A1lise-explorat%C3%B3ria-de-dados/</guid><description>&lt;p>O objetivo é a exploração irrestrita dos dados, na busca por padrões interessantes e conhecimento útil. &lt;strong>As conclusões não possibilitam generalização&lt;/strong>.&lt;/p>
&lt;p>Utilizaremos métodos numéricos e gráficos para descrever as varáveis de um conjunto de dados e as relações entre elas.&lt;/p>
&lt;h1 id="conceitos-e-definições">Conceitos e definições: &lt;a href="#conceitos-e-defini%c3%a7%c3%b5es" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>&lt;em>população (N)&lt;/em> é a coleção completa de todos os elementos (valores, pessoas, medidas&amp;hellip;).
&lt;em>amostra (n)&lt;/em> é um sub conjunto organizado por algum intuito.
&lt;em>censo&lt;/em> é a coleção de dados relativos a todos os elementos da população.
&lt;em>variabilidade&lt;/em> é a dispersão da &lt;strong>variável&lt;/strong>
&lt;em>dados&lt;/em> são informações sistematicamente registradas, sejam números ou rótulos. São inúteis sem contexto.&lt;/p></description></item><item><title>Análise Exploratória de Dados</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/15---an%C3%A1lise-explorat%C3%B3ria-de-dados/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/15---an%C3%A1lise-explorat%C3%B3ria-de-dados/</guid><description>&lt;p>Análise descritiva usando tabelas e gráficos.&lt;/p>
&lt;p>Método 5W1h-&amp;gt;
1 - what -&amp;gt; o que buscamos
2 - where -&amp;gt; onde o estudo está sendo realizado
3 - when -&amp;gt; quando serão coletados os dados
4 - who -&amp;gt; quem faz parte do estudo
5 - how -&amp;gt; como faremos
6 - why -&amp;gt; por que estamos realizando o estudo?&lt;/p></description></item><item><title>analise-sintatica</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/3-analise-sintatica/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/3-analise-sintatica/</guid><description>&lt;blockquote>
&lt;p>aula referente ao cap 4.1 e 4.4 do livro&lt;/p>&lt;/blockquote>
&lt;h1 id="análise-sintática">Análise Sintática &lt;a href="#an%c3%a1lise-sint%c3%a1tica" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>![[Pasted image 20250916171035.png]]&lt;/p>
&lt;p>Entrada: Cadeia de tokens representando o programa fonte e verifica se a cadeia em si pertence a linguagem gerada pela gramatica.&lt;/p>
&lt;p>Ele deve ser projetado para emitir mensagens de erros de uma forma inteligível e se recuperar deles, em certas ocasiões.&lt;/p>
&lt;p>Aqui, devemos estruturar a gramatica de fato, partindo, naturalmente, de uma &lt;em>keyword&lt;/em> definida, i.e, &lt;em>while&lt;/em> ou &lt;em>int&lt;/em>, assim, os próximos lexemas a serem aceitos devem se basear nessa indicação.&lt;/p></description></item><item><title>Aritmética Computacional</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/aritm%C3%A9tica-computacional/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/aritm%C3%A9tica-computacional/</guid><description>&lt;p>Toda aritmetica é realizada na ALU (arithmetic logic unit) na CPU&lt;/p>
&lt;ul>
&lt;li>Inteiros&lt;/li>
&lt;li>Floats&lt;/li>
&lt;/ul>
&lt;p>A unidade de controle, juntamente aos registradores, buscam e interconectam as informações no sistema computacional (desde a memória cache até a externa e I/O Devices);&lt;/p>
&lt;ul>
&lt;li>
&lt;p>A ALU também pode acionar algumas flags como resultado&lt;br>
de uma operação;&lt;/p>
&lt;/li>
&lt;li>
&lt;p>A Unidade de Controle provê sinais que controlam a&lt;br>
operação e o movimento dos dados na ALU.&lt;/p>
&lt;/li>
&lt;/ul>
&lt;h2 id="instruction-set">Instruction set &lt;a href="#instruction-set" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>contempla um compilado de instruções que a CPU pode utilizar. Uma ISA (Instruction Set Architecture) garante a unicidade de um tipo se Instruction Set para determinado hardware.&lt;/p></description></item><item><title>Arquitetura de Computadores Paralelos</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/8---arquitetura-de-computadores-paralelos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/8---arquitetura-de-computadores-paralelos/</guid><description/></item><item><title>Arquitetura e Funcionamento de Microcontroladores</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/2---arquitetura-e-funcionamento-de-microcontroladores/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/2---arquitetura-e-funcionamento-de-microcontroladores/</guid><description>&lt;ul>
&lt;li>sistemas embarcados → utilizados em ampla gama de dispositivos e setores. Em essência, eles são soluções criadas para desempenhar tarefas especificas em tempo real.&lt;/li>
&lt;/ul>
&lt;h2 id="microcontroladores">Microcontroladores &lt;a href="#microcontroladores" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>circuito integrado que forma um pequeno computador, tem memória, uma CPU, periféricos programáveis e comunicação, porém, de baixíssima capacidade (memso).
&lt;ul>
&lt;li>utilizaremos a arquitetura de Harvard, que possui memórias separadas para instruções e dados.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;p>desenvolveremos tanto firmware (colocado em uma mem não volátil) e software (carregada para a ram da memória secundária).&lt;/p></description></item><item><title>Árvore 2-4</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/11---%C3%A1rvore-2-4/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/11---%C3%A1rvore-2-4/</guid><description>&lt;p>É um caso especial da árvore B, de ordem 4. (árvore 2-3-4, arvore 2-4 ou arvore B simétrica)&lt;/p>
&lt;p>Tem até quatro filhos e até 3 chaves. Mas esta não é usada em memória secundária.&lt;/p>
&lt;p>&lt;strong>props&lt;/strong>&lt;/p>
&lt;ul>
&lt;li>são balanceadas&lt;/li>
&lt;li>são boas pra memória principal&lt;/li>
&lt;/ul>
&lt;p>lidamos com overflow na inserção com um split simples, mas sem escrita na memória&lt;/p>
&lt;p>A altura da árvore é O(log n).
![[arvore-2-4.excalidraw]]&lt;/p>
&lt;p>A utilização de cada página tende a ser próxima dos 69%.&lt;/p></description></item><item><title>Árvore R</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/12---%C3%A1rvore-r/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/12---%C3%A1rvore-r/</guid><description>&lt;p>Tipos de dados espaciais:&lt;/p>
&lt;ul>
&lt;li>ponto: unidade minima de um objeto espacial.&lt;/li>
&lt;li>linha: sequencia de pontos
&amp;hellip;&lt;/li>
&lt;/ul>
&lt;h2 id="mbr---minimum-bounding-rectangle">MBR - (Minimum Bounding Rectangle) &lt;a href="#mbr---minimum-bounding-rectangle" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>retangulo delimitador minimo.&lt;/p>
&lt;h1 id="r-tree">R TREE &lt;a href="#r-tree" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Objetivo: guardar dados utilizados com frequencia em muitas areas.
Utilizada para indexacao espacial, ou seja, para armazaenar dados que existem em multiplas dimensions como coords.&lt;/p>
&lt;h2 id="aplicacoes">Aplicacoes &lt;a href="#aplicacoes" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>GIS&lt;/li>
&lt;li>CAD&lt;/li>
&lt;li>VLSI&lt;/li>
&lt;li>P2P&lt;/li>
&lt;li>data streams..&lt;/li>
&lt;/ul>
&lt;h2 id="props">props &lt;a href="#props" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>bottom up&lt;/li>
&lt;li>balanceada&lt;/li>
&lt;/ul>
&lt;p>Uma arvore R de order $(m, M)$ e uma estrutura que contem:&lt;/p></description></item><item><title>Árvore Trie</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/6---%C3%A1rvore-trie/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/6---%C3%A1rvore-trie/</guid><description>&lt;p>๏ Tempo de busca proporcional ao tamanho das chaves
๏ Chaves com sufixos comuns compartilham caminho até a raiz
๏ Propícias para compactação no caso de letras do alfabeto
๏ boa opção para manter chaves grandes e de tamanho variável&lt;/p>
&lt;hr>
&lt;p>Árvores de busca digitais (tries)&lt;/p>
&lt;ul>
&lt;li>posição de um nó depende da comparação entre os bits da chave.&lt;/li>
&lt;li>vantagem:
&lt;ul>
&lt;li>impl mais simples pois não tem rotação&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>desvantagem:
&lt;ul>
&lt;li>se o conjunto é grande demais, precisamos de muitos bits para representá-la&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;blockquote>
&lt;p>uma arvore de busca de na qual o fator de sub-divisão, ou número máximo de filhos por nó, é igual ao número de símbolos do alfabeto&lt;/p></description></item><item><title>aula 6 asalr</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/5-asalr/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/5-asalr/</guid><description>&lt;h1 id="algoritmo-de-análise-sintática-descendente-não-recursivo-adnr">Algoritmo de Análise Sintática Descendente Não Recursivo (ADNR) &lt;a href="#algoritmo-de-an%c3%a1lise-sint%c3%a1tica-descendente-n%c3%a3o-recursivo-adnr" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Essa análise sintática usa a tabela preditiva, vista anteriormente.&lt;/p>
&lt;p>&lt;em>Entrada&lt;/em>: $w$ e $M$ (tabela sintática preditiva)&lt;/p>
&lt;p>&lt;em>inicio&lt;/em>
│ $ip$ aponta para o primerio simbolo de $w$
│ empilha $$$
│ empilha o simbolo inicial da gramática
│ &lt;em>repetir&lt;/em>
│ │ seja $X$ o simbolo no topo da pilha
│ │ seja $a$ o simbolo apontado por $ip$
│ │ se $X$ é um terminal então
│ │ │ &lt;em>se&lt;/em> $X$ = $a$ &lt;em>então&lt;/em>
│ │ │ │ desempilha $X$
│ │ │ │ avança $ip$
│ │ │ &lt;em>senao&lt;/em>
│ │ │ │ erro de análise sintática
│ │ &lt;em>senao se&lt;/em> $X$ é &lt;em>não-terminal&lt;/em> e $M[X,a]$ = $X \rightarrow Y_1 Y_2 \dots Y_k$ &lt;em>então&lt;/em>
│ │ │ desempilha $X$
│ │ │ empilha $Y_k, Y_{k-1}, \dots, Y_1$ (se $k$ = 0, nada é empilhado)
│ │ &lt;em>senao&lt;/em>
│ │ erro de análise sintática
│ &lt;em>até que&lt;/em> $X = $ $
&lt;em>fim&lt;/em>&lt;/p></description></item><item><title>aula 8 alg asdr</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/6-alg-analise-sintatica-ascendente/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/6-alg-analise-sintatica-ascendente/</guid><description>&lt;p>HOT TAKE: Analise Sintatica Ascendente LR precisa extender a gramatica.
HOT TAKE: Se A -&amp;gt; $\epsilon$ é uma produção, então A -&amp;gt; . é um item válido.&lt;/p>
&lt;p>Exercicio: construir a coleção cacônica de itens LR(0):
S -&amp;gt; L = R
S -&amp;gt; R
L -&amp;gt; * R
L -&amp;gt; id
R -&amp;gt; L&lt;/p>
&lt;p>feito no caderno&lt;/p>
&lt;p>Exercicio (casa): construir a tabela SLR para o exemplo anterior.&lt;/p>
&lt;hr>
&lt;h1 id="algoritmo-de-analise-sintatica-ascendente">Algoritmo de Analise Sintatica Ascendente &lt;a href="#algoritmo-de-analise-sintatica-ascendente" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>O algoritmo permance inalterado para as 3 formas de Analise (SLR, LRC, SALR).&lt;/p></description></item><item><title>automato-finito-rep.excalidraw</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/public/automato-finito-rep.excalidraw/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/public/automato-finito-rep.excalidraw/</guid><description>&lt;p>==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠== You can decompress Drawing data with the command palette: &amp;lsquo;Decompress current Excalidraw file&amp;rsquo;. For more info check in plugin settings under &amp;lsquo;Saving&amp;rsquo;&lt;/p>
&lt;h1 id="excalidraw-data">Excalidraw Data &lt;a href="#excalidraw-data" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;h2 id="text-elements">Text Elements &lt;a href="#text-elements" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Os estados sao representados por circulos rotulados ^JULCKB4k&lt;/p>
&lt;p>q1 ^FcWFXAjw&lt;/p>
&lt;p>q2 ^wxTjCFGD&lt;/p>
&lt;p>O estado inicial eh representado por uma seta: ^BqJr9nFM&lt;/p>
&lt;p>q1 ^opP4n8sl&lt;/p>
&lt;p>Estados finais sao representados com 2 circulos: ^PvnlgTb5&lt;/p></description></item><item><title>B-star and Virtual Trees</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/9---b-star-and-virtual-trees/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/9---b-star-and-virtual-trees/</guid><description>&lt;h1 id="b-tree">B* tree &lt;a href="#b-tree" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Tentativa de redistribuir chaves durante a inserção antes de particionar o nó.&lt;/p>
&lt;ul>
&lt;li>Variação da árvore-b no qual cada no tem, no mínimo, 2/3 do número máximo de chaves.
A geração destas árvores utiliza uma variação do processo de particionamento -&amp;gt; adiado até 2 paǵinas irmãs estejam cheias (2 pra 3).&lt;/li>
&lt;/ul>
&lt;h2 id="propriedades">propriedades &lt;a href="#propriedades" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>cada páginas tem no máximo m descendentes&lt;/li>
&lt;li>toda página tem no mínimo $\frac{2m-1}{3}$ descendentes&lt;/li>
&lt;li>a raiz tem pelo menos 2 descendentes&lt;/li>
&lt;li>todas as folhas estão no mesmo nível&lt;/li>
&lt;li>uma fola contém no mínimo $\lfloor \frac{2m-1}{3}\rfloor$ chaves&lt;/li>
&lt;/ul>
&lt;p>com 2/3 de ocupação toda página irmã tem condições de redistribuir após um underflow em página vizinha&lt;/p></description></item><item><title>B-TREE</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/8---b-tree/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/8---b-tree/</guid><description>&lt;h2 id="árvore-binária-de-busca">Árvore binária de busca &lt;a href="#%c3%a1rvore-bin%c3%a1ria-de-busca" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Da pra criar uma arvore de busca binária em um arquivo, com os &lt;strong>Records&lt;/strong> recebendo um ponteiro a direita e a esquerda do próximo registro, assim como uma chave própria.
(key, rrn-left, rrn-right). O que isso gera é um desbalanceamento.
![[Árvore Binária de Busca - files]]&lt;/p>
&lt;h2 id="avl">AVL &lt;a href="#avl" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>temos a garantia com O(log(n)). Problema:&lt;/p>
&lt;ul>
&lt;li>se as chaves estão no arquivos, há muitos acessos desnecessários.&lt;/li>
&lt;/ul>
&lt;h1 id="árvore-binária-paginada-paged-binary-tree">Árvore Binária Paginada (Paged Binary Tree) &lt;a href="#%c3%a1rvore-bin%c3%a1ria-paginada-paged-binary-tree" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Cada &amp;lsquo;página&amp;rsquo; é armazenada em um bloco, podendo conter um numero grande de Records, ou seja, é uma árvore &lt;em>blocada&lt;/em>.&lt;/p></description></item><item><title>B+ Tree</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/10---b+-tree/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/10---b+-tree/</guid><description>&lt;p>&lt;strong>Objetivo:&lt;/strong> permitir busca sequencial e direta.&lt;/p>
&lt;p>Pensada em ranges. Utilizada em muitos sistemas de arquivos.&lt;/p>
&lt;ul>
&lt;li>Conjunto de indices, organizado igualmente como a &lt;em>B_TREE&lt;/em>&lt;/li>
&lt;li>Sequence Set: lista encadeada que liga as folhas da b-tree (blocos de tamanho fixo ordenados pelas chaves).&lt;/li>
&lt;/ul>
&lt;h3 id="props">props &lt;a href="#props" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ol>
&lt;li>Os nós internos não contém dados secundários dos registros, apenas cópias das chaves e servem só como referência para o percurso. Em outras palavras, abrigam apenas separadores de chave.&lt;/li>
&lt;li>são utilizados blocos para armazenar os dados de fato, assim, o tamanho do bloco se difere da ordem da árvore.&lt;/li>
&lt;/ol>
&lt;p>podemos fazer a maior parte das exclusões e inclusões sem alterar os índices, apenas no conjunto sequencial.&lt;/p></description></item><item><title>Cálculo Numérico</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/c%C3%A1lculo-num%C3%A9rico/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/c%C3%A1lculo-num%C3%A9rico/</guid><description>&lt;p>[[1 - Representação numérica e análise de erros]]
[[2 - Algoritmo (Dec - Bin) (fracionários)]]
[[3 - Erros de arredondamento e truncamento]]
[[5 - Solução de equações não lineares por métodos numéricos]]
[[6 - Refinamento dos Resultados]]
[[7 - Método do Ponto Fixo (MPF)]]
[[8 - Método de Newton-Raphson]]
[[9 - Equações Polinomiais]]
[[10 - Sequência (ou cadeia) de Sturm + newton para polinomios]]
[[11 - Sistemas Lineares]]&lt;/p></description></item><item><title>Ciclo de instrução – O retorno</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/ciclo-de-instru%C3%A7%C3%A3o--o-retorno/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/ciclo-de-instru%C3%A7%C3%A3o--o-retorno/</guid><description>&lt;h1 id="indireção">Indireção &lt;a href="#indire%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>Endereçamento indireto requer mais acessos à memória;&lt;/li>
&lt;li>Pode ser imaginado como subciclo de instrução adicional.&lt;/li>
&lt;/ul>
&lt;p>![[/Untitled 7.png|Untitled 7.png]]&lt;/p>
&lt;hr>
&lt;h2 id="ciclo-de-dados">Ciclo de dados &lt;a href="#ciclo-de-dados" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;h2 id="busca">Busca: &lt;a href="#busca" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>— PC → próxima instrução;&lt;/p>
&lt;p>— Endereço da Instrução → MAR&lt;/p>
&lt;p>— Endereço → barramento de endereço&lt;/p>
&lt;p>— Unidade de controle solicita leitura de memória&lt;/p>
&lt;p>— Resultado colocado no barramento de dados →MBR , depois para IR;&lt;/p>
&lt;p>— Enquanto isso, PC incrementado em 1.&lt;/p></description></item><item><title>coloração</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/teoria-dos-grafos/colora%C3%A7%C3%A3o/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/teoria-dos-grafos/colora%C3%A7%C3%A3o/</guid><description>&lt;p>&lt;em>não vai cair:&lt;/em> polinômios cromáticos.&lt;/p>
&lt;h2 id="conceitos-pra-se-estudar">conceitos pra se estudar &lt;a href="#conceitos-pra-se-estudar" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Kmax
$\xi_\text{cromático}$
conjunto independentes de vértices
n° de dependência&lt;/p>
&lt;p>partição cromática -&amp;gt; conjunto de partições&lt;/p>
&lt;p>algoritmo guloso de coloração -&amp;gt; não garante a solução ótima&lt;/p>
&lt;h1 id="coloração-de-aresta">coloração de aresta &lt;a href="#colora%c3%a7%c3%a3o-de-aresta" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>índice cromático&lt;/p></description></item><item><title>Complexidade</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/2---complexidade/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/2---complexidade/</guid><description>&lt;p>Quantidade de trabalho depende da entrada/”estados” da aplicação e da estrutura de dados.&lt;/p>
&lt;p>Se a complexidade é tomada como máxima para qualquer caso a complexidade é chamada de &lt;code>complexidade no pior caso&lt;/code>&lt;/p>
&lt;p>Se, acaso, a ocorrência for média, chama-se de &lt;code>complexidade média&lt;/code>&lt;/p>
&lt;ul>
&lt;li>
&lt;p>tipos de complexidade&lt;/p>
&lt;/li>
&lt;li>
&lt;p>melhor caso&lt;/p>
&lt;/li>
&lt;li>
&lt;p>pior caso&lt;/p>
&lt;/li>
&lt;li>
&lt;p>caso médio&lt;/p>
&lt;/li>
&lt;/ul>
&lt;h3 id="função-assintótica">função assintótica &lt;a href="#fun%c3%a7%c3%a3o-assint%c3%b3tica" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;p>buscamos uma $f(n)$﻿ que representa o custo tanto de eficiência de acesso, eficiência energética e/ou tempo de execução.&lt;/p></description></item><item><title>Conceitos</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/1---conceitos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/1---conceitos/</guid><description>&lt;h2 id="high-level-lang">high level lang &lt;a href="#high-level-lang" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>compiladores/interpretadores&lt;/li>
&lt;li>abstração da maquina&lt;/li>
&lt;li>recursos&lt;/li>
&lt;li>frameworks e bilbliotecas&lt;/li>
&lt;/ul>
&lt;h2 id="low-level">low level &lt;a href="#low-level" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>assembler (montador)&lt;/li>
&lt;li>ISA&lt;/li>
&lt;li>hardware&lt;/li>
&lt;li>registers and mem&lt;/li>
&lt;/ul>
&lt;hr>
&lt;h1 id="conceitos-básicos">conceitos básicos &lt;a href="#conceitos-b%c3%a1sicos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>assembly → forma de representar textualmente um o conjunto de instruções de uma máquina&lt;/p>
&lt;ul>
&lt;li>microcontrolador → serve como um micro computador, o qual possui processamento, mem e etc&lt;/li>
&lt;li>microprocessador → processamento.&lt;/li>
&lt;/ul>
&lt;p>assembler → montador, traduz o assembly para lang de maquina&lt;/p>
&lt;p>assembly n é portável&lt;/p></description></item><item><title>Conceitos</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/1---conceitos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/1---conceitos/</guid><description>&lt;ul>
&lt;li>&lt;input disabled="" type="checkbox"> Experimentos ou fenômenos aleatórios: quando resultados não podem ser preditos, mesmo que seja observado inúmeras vezes. Sujeito à influencia de fatores casuais.&lt;/li>
&lt;/ul>
&lt;h1 id="espaço-amostral">Espaço Amostral &lt;a href="#espa%c3%a7o-amostral" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>é um conjunto de todos os resultados possíveis de um fenômeno aleatório.
Cada resultado representa um &lt;code>ponto amostral&lt;/code>.&lt;/p>
&lt;h1 id="eventos">Eventos &lt;a href="#eventos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>subconjuntos de um espaço amostral. Um evento é dito corrido se quaisquer elementos é um resultado observado.&lt;/p>
&lt;ul>
&lt;li>Evento simples: cada resultado possível do experimento.&lt;/li>
&lt;li>Evento Composto: eventos simples recortados por uma regra definida.&lt;/li>
&lt;li>União: a união de 2 eventos $A\cup B$﻿, seja composto ou simples&lt;/li>
&lt;li>Intersecção: entre 2 eventos $A\cap B$﻿&lt;/li>
&lt;li>Complementar: parte fora da intersecção de A e B&lt;/li>
&lt;/ul></description></item><item><title>Conceitos Básicos</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/1---conceitos-b%C3%A1sicos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/1---conceitos-b%C3%A1sicos/</guid><description>&lt;h2 id="11-algoritmos">1.1 Algoritmos &lt;a href="#11-algoritmos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Definição de algoritmo: informalmente, um algoritmo é qualquer procedimento&lt;br>
computacional bem definido que toma algum valor ou conjunto de valores como entrada e&lt;br>
produz algum valor ou conjunto de valores como saída. Portanto, um algoritmo é uma&lt;br>
sequência de etapas computacionais que transformam a entrada na saída. Também&lt;br>
podemos considerar um algoritmo como uma ferramenta para resolver um problema&lt;br>
computacional bem definido. O enunciado do problema específica em termos gerais a&lt;br>
relação desejada entre entrada e saída. O algoritmo descreve um procedimento&lt;br>
computacional específico para se conseguir essa relação entre entrada e saída.&lt;/p></description></item><item><title>Conjunto de Instruções</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/conjunto-de-instru%C3%A7%C3%B5es/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/conjunto-de-instru%C3%A7%C3%B5es/</guid><description>&lt;h1 id="modos-de-endereçamento">Modos de endereçamento &lt;a href="#modos-de-endere%c3%a7amento" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>um bit identifica o modo de endereçamento&lt;/li>
&lt;/ul>
&lt;h2 id="tipos">TIPOS &lt;a href="#tipos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;hr>
&lt;ul>
&lt;li>
&lt;p>Imediato&lt;/p>
&lt;ul>
&lt;li>instrução guarda também o operando&lt;/li>
&lt;li>economiza um ciclo mas útil apenas para instruções simples&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>
&lt;p>Direto&lt;/p>
&lt;ul>
&lt;li>instrução guarda uma referência a instrução que está na memória principal&lt;/li>
&lt;li>limitada pelo espaço do endereçamento&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>
&lt;p>Indireto&lt;/p>
&lt;ul>
&lt;li>instrução guarda uma referência a uma referencia a instrução que está na memória principal&lt;/li>
&lt;li>refere-se a um endereço de uma palavra na memória, a qual contem o endereço completo do operando.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>
&lt;p>Registrador Direto&lt;/p></description></item><item><title>CPU</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/cpu/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/cpu/</guid><description>&lt;h1 id="registradores">Registradores &lt;a href="#registradores" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;h2 id="dados-e-endereços">Dados e endereços &lt;a href="#dados-e-endere%c3%a7os" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>
&lt;p>Acumulador e segmento de endereço, respectivamente&lt;/p>
&lt;/li>
&lt;li>
&lt;p>Balanço:&lt;/p>
&lt;p>→ Menos registradores há mais referências à memória;&lt;/p>
&lt;p>→ mais registradores ocupam mais espaço no processador (mais caro tbm)&lt;/p>
&lt;/li>
&lt;li>
&lt;p>Tamanho do registrador&lt;/p>
&lt;p>→ Grande o suficiente para manter palavra, endereço e op code completos&lt;/p>
&lt;/li>
&lt;/ul>
&lt;h2 id="códigos-condicionais">Códigos condicionais &lt;a href="#c%c3%b3digos-condicionais" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>
&lt;p>Servem para:&lt;/p>
&lt;p>— Conjuntos de bits individuais.&lt;/p>
&lt;ul>
&lt;li>Ex: resultado da última operação foi zero.&lt;/li>
&lt;/ul>
&lt;p>— Podem ser lidos (implicitamente) por programas.&lt;/p></description></item><item><title>default notes</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/default-notes/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/default-notes/</guid><description>&lt;h3 id="common-dos-interrupts-and-functions">Common DOS Interrupts and Functions &lt;a href="#common-dos-interrupts-and-functions" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ol>
&lt;li>&lt;strong>INT 21h&lt;/strong> (DOS Interrupt):
&lt;ul>
&lt;li>&lt;strong>INT 21h&lt;/strong> is the most commonly used interrupt in DOS. It provides access to a wide range of DOS services such as file handling, input/output operations, memory management, and program termination.&lt;/li>
&lt;li>The specific service is determined by the value in the &lt;code>AH&lt;/code> register.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ol>
&lt;h4 id="common-int-21h-functions-ah-values">&lt;strong>Common INT 21h Functions (AH Values):&lt;/strong> &lt;a href="#common-int-21h-functions-ah-values" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h4>&lt;ul>
&lt;li>
&lt;p>&lt;strong>AH = 01h&lt;/strong>: &lt;strong>Read a single character from standard input (usually the keyboard)&lt;/strong>&lt;/p></description></item><item><title>Definições</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/5---defini%C3%A7%C3%B5es/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/5---defini%C3%A7%C3%B5es/</guid><description>&lt;p>$i)$ se os eventos $A_1, A_2&amp;hellip;, A_n$ formam uma &lt;strong>partição&lt;/strong> do espaço amostral, então $\sum_{i=1}^n P(A_1) =1$.
$ii)$ Se $\emptyset$ é um evento impossível, então $P(\theta) = 0$
$iii)$ Para todo evento $A\subset \Omega, P(A) = 1 -P(\overline A)$&lt;/p>
&lt;blockquote>
&lt;p>$\Omega$ = espaço amostral
$P(.)$ -&amp;gt; probabilidade de .
$\Omega = A\cup\overline A$
$P(\Omega) = P(A\cup\overline A)$
$P(A) = 1 - P(\overline A)$&lt;/p>&lt;/blockquote>
&lt;p>$iv)$ Sejam $A\subset\Omega$ e $B\subset\Omega$. Então, $P(A\cup B)= P(A) + P(B) - P(A\cap B)$
$v)$ Sejam $A\subset\Omega$ e $B\subset\Omega$, sendo que $B\subset A$ Então, $P(B)\leq P(A)$.&lt;/p></description></item><item><title>Divisão e Conquista</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/4---divis%C3%A3o-e-conquista/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/4---divis%C3%A3o-e-conquista/</guid><description>&lt;p>Divisão de problemas maiores para gerar subproblemas com recursão, capazes de serem resolvidos.&lt;/p>
&lt;p>Neste método, temos:&lt;/p>
&lt;ul>
&lt;li>caso base -&amp;gt; problema simples o bastante para ser resolvido.&lt;/li>
&lt;li>caso recursivo:
&lt;ul>
&lt;li>divisão: dividir o problema em subproblemas&lt;/li>
&lt;li>conquista: resolver recursivamente os subproblemas&lt;/li>
&lt;li>combinação: das soluções dadas aos subproblemas, associá-las ao problema &amp;ldquo;acima&amp;rdquo;&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;h2 id="merge-sort">Merge Sort &lt;a href="#merge-sort" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>
&lt;p>&lt;strong>Divisão&lt;/strong>: Em cada etapa, ele ordena um subvetor $A[p:q]$, dividindo-o a cada chamada por 2, sempre pegando cada metade até achar o caso base (vetor unitário ou nulo)&lt;/p></description></item><item><title>dualidade</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/otimiza%C3%A7%C3%A3o-linear/dualidade/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/otimiza%C3%A7%C3%A3o-linear/dualidade/</guid><description>&lt;h1 id="dualidade">Dualidade &lt;a href="#dualidade" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>A dualidade é um conceito fundamental na otimização linear que estabelece uma relação entre dois problemas de otimização: o problema primal e o problema dual. Cada problema de otimização linear tem um problema dual associado, e as soluções desses problemas estão interligadas.&lt;/p>
&lt;h2 id="relaxação-lagrangeana">Relaxação Lagrangeana &lt;a href="#relaxa%c3%a7%c3%a3o-lagrangeana" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Considere um problema primal:&lt;/p>
&lt;p>Minimizar $f(x) = c^T x$
sujeito a $Ax = b$
$x \geq 0$&lt;/p>
&lt;p>que agora será chamado de problema primal.&lt;/p></description></item><item><title>ED 2</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/ed-2/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/ed-2/</guid><description>&lt;p>[[1-2 - Armazenamento secundário]]
[[3 - Organização de arquivos]]
[[4 - Index]]
[[5 - Hashing]]
[[6 - Árvore Trie]]
[[7 - Hashing extensível]]
[[8 - B-TREE]]&lt;/p>
&lt;p>![[File Structures (Michael J. Folk, Bill Zoellick) (Z-Library).pdf]]&lt;/p>
&lt;h1 id="topics">Topics &lt;a href="#topics" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>๏ Operações e fundamentos de arquivos
• Arquivos físicos e lógicos
• Operações em C
๏ Armazenamento secundário
• HDs: históricos, custo, desempenho&amp;hellip;
• Organização de informações em disco: discos, superfícies, setores, trilhas, cilindros
• Sistemas de Arquivos: FAT32 e NTFS
๏ Minimizando problemas em discos
๏ Jornada de um Byte
๏ Gerenciamento de Buffer
๏ Organização em campos
๏ Organização em registros
๏ Acesso a registros
๏ Modelo abstrato de dados
๏ Cabeçalhos, metadados e taggs
๏ Leitura e escrita
๏ Desempenho em organização de arquivos
• Compressão
• Compactação
• Fragmentação
• Busca
๏ Indíces
๏ Arvore Trie
๏ Hashing Externo
๏ B-TREE&lt;/p></description></item><item><title>Entrada e Saída</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/entrada-e-sa%C3%ADda/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/entrada-e-sa%C3%ADda/</guid><description>&lt;p>Dispositivos são provavelmente mais lentos do que a CPU&lt;/p>
&lt;p>Estão, existem módulos de conexão tanto com periféricos quanto com CPU e memória&lt;/p>
&lt;p>Barramento do Sistema envia os dados para o módulo de E/S que redireciona para os dispositivos&lt;/p>
&lt;h1 id="funções-do-módulo-de-es">Funções do módulo de E/S &lt;a href="#fun%c3%a7%c3%b5es-do-m%c3%b3dulo-de-es" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>Controle e temporização&lt;/li>
&lt;li>Comunicação com a CPU&lt;/li>
&lt;li>Comunicação com dispositivo&lt;/li>
&lt;li>Buffering de dados&lt;/li>
&lt;li>Detecção de erro&lt;/li>
&lt;/ul>
&lt;h1 id="etapas">Etapas &lt;a href="#etapas" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>CPU → módulo de E/S → transferencia de dados (dispositivo → E/S) → CPU&lt;/p></description></item><item><title>Equações Polinomiais</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/9---equa%C3%A7%C3%B5es-polinomiais/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/9---equa%C3%A7%C3%B5es-polinomiais/</guid><description>&lt;p>Um polinômio de grau n é uma expressão da forma&lt;/p>
&lt;ul>
&lt;li>$P_{n(x)}= a_{a}+ a_{i}x^{1}+..+a_{n}x^n$&lt;/li>
&lt;li>$P_{n(x)}= a_{n}x^{n}+ a_{i}x^{1}+..+ a_{a}$ ou&lt;/li>
&lt;li>$P_{n}(x) = \sum^{n}&lt;em>{i=0a} a&lt;/em>{i}x^{i}$
com $a_{n}\neq 0$ e os $a_{i}$ são números reais.&lt;/li>
&lt;/ul>
&lt;h1 id="teorema-fundamental-da-álgebra">Teorema Fundamental da Álgebra. &lt;a href="#teorema-fundamental-da-%c3%a1lgebra" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Seja $n\geq P_{n}(x)$ um polinômio de grau n. Então $P_{n}(x)$ tenha exatamente $n$ raízes (zeros da função), podendo ser reais ou complexos, desde que cada zero seja contado com a multiplicidade.
Dizemos que um zero $\xi$ de $P_{n}(x)$ tem multiplicidade $k \ (1 \leq k \leq n)$ se $P_{n(\xi)}=0,\ P_{n}&amp;rsquo;(\xi), \ P_{n}^{n}(\xi) = 0, \ .., \ P_{n}^{k-1}(\xi) = 0$ e $P_{n}^{k}(\xi) \neq 0$&lt;/p></description></item><item><title>Erros de arredondamento e truncamento</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/3---erros-de-arredondamento-e-truncamento/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/3---erros-de-arredondamento-e-truncamento/</guid><description>&lt;h1 id="truncamento">Truncamento &lt;a href="#truncamento" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>seja S$[10, t, M_{min}, M_{max}﻿]$ um sistema de aritmética de ponto flutuante de $t$ dígitos. Então todo número em $S$ é forma:&lt;/p>
&lt;p>$\pm0. d_1.d_2 &amp;hellip;d_t.10^M$﻿&lt;/p>
&lt;p>com $M\in [M_{min}, M_{max}]$﻿ inteiro $d_x1$﻿ ≠ 0&lt;/p>
&lt;p>$x = f_x .10^q+g_x .10^{q-t}$﻿&lt;/p>
&lt;p>$0.1 \leq |f_x| \lt 1 , 0.1 \leq |g_x| &amp;lt;1$﻿&lt;/p>
&lt;p>Para calcular o erro na aproximação por truncamento, calculamos primeiro o erro absoluto:&lt;/p>
&lt;p>$|EAx| = |f_x .10^q+g_x .10^{q-t}-f_x.10^q|$﻿&lt;/p>
&lt;p>portanto,&lt;/p>
&lt;p>==$|EAx| &amp;lt; 10^{q-t}$==﻿&lt;/p></description></item><item><title>exec</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/exec/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/linguagens-formais-e-automatos/exec/</guid><description>&lt;ol>
&lt;li>gramatica&lt;/li>
&lt;li>tipos de gramatica&lt;/li>
&lt;li>automatos finitos deterministicos&lt;/li>
&lt;li>automatos finitos nao Deterministicos&lt;/li>
&lt;li>AFD equivalente qualquer AFN&lt;/li>
&lt;li>Operacoes fechadas em AFN&amp;rsquo;s&lt;/li>
&lt;/ol></description></item><item><title>exemplo-problema-artificial</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/otimiza%C3%A7%C3%A3o-linear/exemplo-problema-artificial/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/otimiza%C3%A7%C3%A3o-linear/exemplo-problema-artificial/</guid><description>&lt;p>Exemplo (problema artificial):&lt;/p>
&lt;p>Maximizar $g(x) = 3x_1 + 2x_2$
sujeito a $2x_1 + x_2 \leq 2$
$3x_1 + 4x_2 \geq 12$
$x_1, x_2 \geq 0$&lt;/p>
&lt;h1 id="metodo-do-grande-m">Metodo do grande-M &lt;a href="#metodo-do-grande-m" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Colocando na Forma padrão:
Minimizar $f(x) = -3x_1 - 2x_2 + 0x_3 + 0x_4$
sujeito a $2x_1 + x_2 + x_3 = 2$
$3x_1 + 4x_2 - x_4 = 12$
$x_1, x_2, x_3, x_4 \geq 0$&lt;/p>
&lt;p>$$
A = \begin{bmatrix}
2 &amp;amp; 1 &amp;amp; 1 &amp;amp; 0 \
3 &amp;amp; 4 &amp;amp; 0 &amp;amp; -1
\end{bmatrix}, \quad
b = \begin{bmatrix} 2 \ 12 \end{bmatrix}, \quad
c = \begin{bmatrix} -3 \ -2 \ 0 \ 0 \end{bmatrix}
$$&lt;/p></description></item><item><title>exercicios</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/exercicios/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/exercicios/</guid><description>&lt;p>AULA 1&lt;/p>
&lt;hr>
&lt;p>AULA 2
Identifique os tokens:
int a,b,c;
char cadeia;
leia(a);
b = 3;
c = 2;
c = c + a + b;
escreva(c);
Cadeia = &amp;lsquo;S&amp;rsquo;;
escreva(S);&lt;/p>
&lt;hr>
&lt;p>AULA 3&lt;/p>
&lt;hr>
&lt;p>AULA 4
Exercício(casa): usando derivação, obtenha 10 cadeias da linguagem abaixo
$G = ({E, E&amp;rsquo;, T, T&amp;rsquo;}, {+,-,*,/,num}, P, E)$
$P: E -&amp;gt; TE&amp;rsquo;$
$E&amp;rsquo; \rightarrow +TE&amp;rsquo; | - TE&amp;rsquo; | \epsilon$
$T \rightarrow FT&amp;rsquo;$
$T&amp;rsquo; \rightarrow *FT&amp;rsquo; | /FT&amp;rsquo; | \epsilon$
$F \rightarrow (E) | num$&lt;/p></description></item><item><title>exercicios</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/programa%C3%A7%C3%A3o-concorrente-e-paralela/exercicios/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/programa%C3%A7%C3%A3o-concorrente-e-paralela/exercicios/</guid><description>&lt;h1 id="monitores">Monitores &lt;a href="#monitores" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>5.3&lt;/p>


 
 &lt;div class="highlight">&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">&lt;code class="language-c" data-lang="c">&lt;span style="display:flex;">&lt;span>monitor empty {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	&lt;span style="color:#66d9ef">int&lt;/span> empty &lt;span style="color:#f92672">=&lt;/span> &lt;span style="color:#ae81ff">0&lt;/span>; 
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	cond cv; 
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	proc &lt;span style="color:#a6e22e">empty&lt;/span>() {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		&lt;span style="color:#66d9ef">return&lt;/span> empty &lt;span style="color:#f92672">==&lt;/span> &lt;span style="color:#ae81ff">0&lt;/span>;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	}
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	proc &lt;span style="color:#a6e22e">em_wait&lt;/span>() {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		empty&lt;span style="color:#f92672">--&lt;/span>;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		&lt;span style="color:#a6e22e">wait&lt;/span>()
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	}
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	proc &lt;span style="color:#a6e22e">em_signal&lt;/span>() {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		empty&lt;span style="color:#f92672">++&lt;/span>;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		&lt;span style="color:#a6e22e">signal&lt;/span>()
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	}
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>}
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	
&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;p>Problema: Implemente uma solução para o problema dos Leitores-Escritores com prioridade para leitores. As regras são:&lt;/p>
&lt;ul>
&lt;li>Vários processos leitores podem acessar a base de dados simultaneamente.&lt;/li>
&lt;li>Apenas um processo escritor pode acessar a base de dados por vez.&lt;/li>
&lt;li>Se um escritor estiver acessando a base de dados, nenhum leitor pode acessá-la.&lt;/li>
&lt;li>Se um leitor estiver lendo, um escritor deve esperar.&lt;/li>
&lt;li>Se novos leitores chegarem enquanto outros já estão lendo, eles devem ter permissão para ler imediatamente, sem esperar por escritores que já estejam na fila. Isso pode levar à inanição (starvation) dos escritores.&lt;/li>
&lt;/ul>


 
 &lt;div class="highlight">&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">&lt;code class="language-c" data-lang="c">&lt;span style="display:flex;">&lt;span>monitor RW {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	&lt;span style="color:#66d9ef">int&lt;/span> nr &lt;span style="color:#f92672">=&lt;/span> &lt;span style="color:#ae81ff">0&lt;/span>, nw &lt;span style="color:#f92672">=&lt;/span> &lt;span style="color:#ae81ff">0&lt;/span>;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	&lt;span style="color:#66d9ef">int&lt;/span> num_data &lt;span style="color:#f92672">=&lt;/span> &lt;span style="color:#ae81ff">0&lt;/span>;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	cond read, writ;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	procedure Reader [i&lt;span style="color:#f92672">=&lt;/span>&lt;span style="color:#ae81ff">0&lt;/span> to N] {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		&lt;span style="color:#66d9ef">if&lt;/span> (num_data &lt;span style="color:#f92672">==&lt;/span> &lt;span style="color:#ae81ff">0&lt;/span>) {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>			&lt;span style="color:#a6e22e">signal&lt;/span>(writ);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>			&lt;span style="color:#a6e22e">wait&lt;/span>(read);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		}
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		nr&lt;span style="color:#f92672">++&lt;/span>;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		num_data&lt;span style="color:#f92672">--&lt;/span>;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		&lt;span style="color:#a6e22e">signal&lt;/span>(read);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	}
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	procedure Writers [i&lt;span style="color:#f92672">=&lt;/span>&lt;span style="color:#ae81ff">0&lt;/span> to M] {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		&lt;span style="color:#66d9ef">if&lt;/span> (nr &lt;span style="color:#f92672">&amp;gt;&lt;/span> &lt;span style="color:#ae81ff">0&lt;/span> &lt;span style="color:#f92672">||&lt;/span> nw &lt;span style="color:#f92672">&amp;gt;&lt;/span> &lt;span style="color:#ae81ff">0&lt;/span>) 
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>			&lt;span style="color:#a6e22e">wait&lt;/span>(writ);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		nw&lt;span style="color:#f92672">++&lt;/span>;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		num_data&lt;span style="color:#f92672">++&lt;/span>;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		&lt;span style="color:#66d9ef">if&lt;/span> (&lt;span style="color:#f92672">!&lt;/span>&lt;span style="color:#a6e22e">empty&lt;/span>(read))
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>			&lt;span style="color:#a6e22e">signal_all&lt;/span>(read);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>		&lt;span style="color:#66d9ef">else&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>			&lt;span style="color:#a6e22e">signal&lt;/span>(writ);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>	}
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>}&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;h1 id="await">Await &lt;a href="#await" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;h1 id="barreira">Barreira &lt;a href="#barreira" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>3.15 - Barreira Borboleta ou&lt;/p></description></item><item><title>Exercícios</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/exerc%C3%ADcios/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/exerc%C3%ADcios/</guid><description>&lt;p>![[lista1.pdf]]&lt;/p>
&lt;h1 id="solução">Solução &lt;a href="#solu%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>1 - Um arquivo lógico representa a forma como a linguagem de alto nível representa e enxerga os dados, não necessariamente representa como um arquivo físico está localizado no sistema. Ele é o IO buffer que utilizamos em memória principal. Ambos representam conjuntos de bytes, evidentemente, porém, um arquivo físico não tem distinção de suas qualidades internas, ou seja, não difere uma struct de um inteiro ou etc.&lt;/p></description></item><item><title>Exercícios</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/exerc%C3%ADcios/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/exerc%C3%ADcios/</guid><description>&lt;p>1 -
2 - isso se dá ao fato de que a função 1 é linear, mesmo que seja multiplicada por um numero não comum ($10^{3}$). Isso quer dizer que, por exemplo, na ocorrência 10000000, o algoritmo que é quadrático seria maior que o linear.&lt;/p></description></item><item><title>Exercícios CN</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/exerc%C3%ADcios-cn/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/exerc%C3%ADcios-cn/</guid><description>&lt;p>[[Exercícios CN - draw]]
![[PrimeiraListaExerc-CalcNum.pdf]]&lt;/p></description></item><item><title>Exercicios PAA</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/exercicios-paa/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/exercicios-paa/</guid><description>&lt;p>[[Exercícios PAA - draw]]&lt;/p>
&lt;h1 id="exercício-1">Exercício 1 &lt;a href="#exerc%c3%adcio-1" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>descreva um algoritmo que, dado um conjunto S de n inteiros
e um outro inteiro x, determine se existem ou não dois elementos em S
cuja soma seja exatamente x. Seu algoritmo deverá levar um tempo Θ(n
lg n) no pior caso.&lt;/p>
&lt;hr>
&lt;h1 id="solução">Solução: &lt;a href="#solu%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Temos inicialmente, que ordenar o vetor para poder saber que numeros operar.
Portanto, usaremos o merge Θ(n log(n)).
Agora, usaremos 2 ponteiros para passar pelo vetor ordenado. Assim, podemos usar o seguinte critério:&lt;/p></description></item><item><title>Exercicios-2</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/exercicios-2/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/exercicios-2/</guid><description>&lt;h1 id="heaps">Heaps &lt;a href="#heaps" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ol>
&lt;li>Quais são os números mínimo e máximo de elementos em um heap de altura h?
R:&lt;/li>
&lt;/ol>
&lt;ul>
&lt;li>mínimo: 2^h (apenas a última camada preenchida parcialmente).&lt;/li>
&lt;li>máximo: 2h+1−12h+1−1 (todas as camadas preenchidas completamente).&lt;/li>
&lt;/ul>
&lt;ol start="2">
&lt;li>
&lt;p>Mostre que um heap de n elementos tem altura ⌊lg n⌋.
R: Um heap nada mais eh do que uma arvore indexada, o que significa que as propriedades de altura permanecem. Ou seja, log n.&lt;/p>
&lt;/li>
&lt;li>
&lt;p>Mostre que, em qualquer subárvore de um heap de máximo, a raiz da subárvore
contém o maior valor que ocorre em qualquer lugar nessa subárvore.
R:
A propriedade de heap de máximo garante que o valor na raiz de qualquer subárvore é maior ou igual aos valores em seus filhos, o que se propaga recursivamente para todos os descendentes.&lt;/p></description></item><item><title>Exercicios-3</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/exercicios-3/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/exercicios-3/</guid><description>&lt;h1 id="programação-dinâmica">Programação dinâmica &lt;a href="#programa%c3%a7%c3%a3o-din%c3%a2mica" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ol>
&lt;li>Considere uma modificação do problema do corte da haste no qual, além de um preço
pi para cada haste, cada corte incorre em um custo fixo c. A receita associada à solução,
agora, é a soma dos preços das peças menos os custos da execução dos cortes. Dê um
algoritmo de programação dinâmica para resolver esse problema modificado.&lt;/li>
&lt;li>Modifique CORTA-HASTE e CORTA-HASTE-MEMOIZADO de modo que seus laços for
subam para apenas ⌊n/2⌋, em vez de subir para n. Que outras mudanças de
procedimentos precisariam ser feitas? Como os tempos de execução seriam afetados?&lt;/li>
&lt;li>Modifique CORTA-HASTE-MEMOIZADO para retornar não somente o valor, mas
também a solução propriamente dita.&lt;/li>
&lt;li>Os números de Fibonacci são definidos pela recorrência:&lt;/li>
&lt;/ol>
&lt;p>Fi = {
0 se i = 0,
1 se i = 1,
Fi−1 + Fi−2&lt;/p></description></item><item><title>Fatoração LU com pivoteamento parcial</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/13---fatora%C3%A7%C3%A3o-lu-com-pivoteamento-parcial/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/13---fatora%C3%A7%C3%A3o-lu-com-pivoteamento-parcial/</guid><description>&lt;h1 id="teorema-fatoração-lu">Teorema (Fatoração LU) &lt;a href="#teorema-fatora%c3%a7%c3%a3o-lu" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Seja A uma matriz $n\times m$ e $A_k$ a martiz constituida das primeiras k linhas e k colunas de A.
Se $det(A_k) \neq 0, \forall k=1, 2, 3, &amp;hellip;, n-1$ então A admite uma composição A=LU , onde $L = (l_{ij})&lt;em>{n\times m}$ é uma matriz triangular inferior $U = (u&lt;/em>{ij})&lt;em>{n\times m}$ é uma matriz triangular superior e $det(A) = u&lt;/em>{11} \times u_{22} \times &amp;hellip; \times u_{nn}$&lt;/p></description></item><item><title>Forma de lagrange e Método das diferenças</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/21---forma-de-lagrange-e-m%C3%A9todo-das-diferen%C3%A7as/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/21---forma-de-lagrange-e-m%C3%A9todo-das-diferen%C3%A7as/</guid><description>&lt;h1 id="forma-de-lagrange">Forma de Lagrange &lt;a href="#forma-de-lagrange" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Sejam $x_{0}, x_{1}, \dots, x_{n} \ (n+1)$ nós de interpolação, $f(x)$ uma função $y_{j}=f(x_{j})$, $j=0, \dots, n$.
A forma de Lagrange do polinômio interpolador $g_{n}(x)$ consiste em escrever $g_{n}(x)$ como $g_{n}(x) = y_{0}L_{0}(x)+y_{1}L_{1}(x)+\dots+y_{n}L_{n}(x)$, onde $L_{j}(x)$ são polinômios de grau $n$ satisfazendo a condição $$L_{j}(x_{i}) = \begin{cases}
0, se \ i \neq j \ 1, se \ i = j
\end{cases}$$
Logo,
$g_{n}(x_{i}) = y_{i}L_{i}(x_{i})=y_{i}=f(x_{i})$&lt;/p>
&lt;p>Os polinômios $L_{j}(x)$ que satisfazem a condição anterior são $$L_{j}(x) = \frac{(x-x_{0})(x-x_{1})\times\dots\times(x-x_{n})}{(x_{j}-x_{0})(x_{j}-x_{1}\times\dots\times (x_{j}- x_{j}))}$$
$$= \frac{\prod^{}&lt;em>{i\neq j}(x-x&lt;/em>{i})}{\prod_{i\neq j}(x_{j}-x_{i})}$$&lt;/p></description></item><item><title>Forma matricial do método de Gauss-Seidel</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/16---forma-matricial-do-m%C3%A9todo-de-gauss-seidel/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/16---forma-matricial-do-m%C3%A9todo-de-gauss-seidel/</guid><description>&lt;p>Sejam :
$A = \begin{bmatrix} a_{11} &amp;amp; a_{12} &amp;amp; \dots &amp;amp; a_{1n} \ a_{21} &amp;amp; a_{22} &amp;amp; \dots &amp;amp; a_{2n} \ \vdots &amp;amp; \vdots &amp;amp; &amp;amp; \vdots \ a_{n1} &amp;amp; a_{n2} &amp;amp; \dots &amp;amp; a_{nn} \end{bmatrix}$&lt;/p>
&lt;p>$L = \begin{bmatrix} 0 &amp;amp; 0 &amp;amp; \dots &amp;amp; 0 \ a_{21} &amp;amp; 0 &amp;amp; \dots &amp;amp; 0 \ \vdots &amp;amp; \vdots &amp;amp; &amp;amp; \vdots \ a_{n1} &amp;amp; a_{n2} &amp;amp; \dots &amp;amp; 0 \end{bmatrix} + D= \begin{bmatrix} a_{11} &amp;amp; 0 &amp;amp; \dots &amp;amp; 0 \ 0 &amp;amp; a_{22} &amp;amp; \dots &amp;amp; 0 \ \vdots &amp;amp; \vdots &amp;amp; &amp;amp; \vdots \ 0 &amp;amp; 0 &amp;amp; \dots &amp;amp; a_{nn} \end{bmatrix} + R=\begin{bmatrix} 0 &amp;amp; a_{12} &amp;amp; \dots &amp;amp; a_{1n} \ 0 &amp;amp; 0 &amp;amp; \dots &amp;amp; a_{2n} \ \vdots &amp;amp; \vdots &amp;amp; &amp;amp; \vdots \ 0 &amp;amp; 0 &amp;amp; \dots &amp;amp; 0 \end{bmatrix}$&lt;/p></description></item><item><title>Gauss Seidel</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/15---gauss-seidel/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/15---gauss-seidel/</guid><description>&lt;p>$Ax = b \implies$
$\begin{cases} x_{1}^{k+1}= \frac{-a_{12}}{a_{11}} - \ &amp;hellip; \ - \frac{\frac{a_{n}}{a_{n}}+b_{1}}{a_{11}} \ {&amp;hellip;&amp;hellip;&amp;hellip;&amp;hellip;.} + \frac{b_{2}}{a_{22}}\end{cases}$&lt;/p></description></item><item><title>GPU</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/gpu/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/gpu/</guid><description>&lt;p>É um processador vetorial pica pra caramba&lt;/p>
&lt;h1 id="programação-em-gpu">Programação em GPU &lt;a href="#programa%c3%a7%c3%a3o-em-gpu" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>permitir uso da gpu simultaneamente a cpu e otimziar ao máximo os seus processamentos&lt;/p>
&lt;p>→ CUDA (nvidia)&lt;/p>
&lt;p>→ OpenCL&lt;/p>
&lt;hr>
&lt;h1 id="cuda">CUDA &lt;a href="#cuda" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>o compilador utiliza-se de threads CUDA, reunidos em blocos de 32 unidades, ou seja, é uma execução SIMD multithreaded&lt;/p>
&lt;ul>
&lt;li>execução assíncrona&lt;/li>
&lt;li>Scatter-Gather&lt;/li>
&lt;li>Mask Registers&lt;/li>
&lt;li>muitos arquivos de registradores&lt;/li>
&lt;/ul>
&lt;h2 id="isa-da-gpu-nvidia">Isa da GPU NVIDIA &lt;a href="#isa-da-gpu-nvidia" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>PTX (Parallel Threads Execution) → utiliza registrador virtual (alocado conforme necessário) e há uma análise de convergência ou divergência de código.&lt;/p></description></item><item><title>Hashing</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/5---hashing/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/5---hashing/</guid><description>&lt;p>#hash #keys #index&lt;/p>
&lt;h1 id="tabela-hash">Tabela hash &lt;a href="#tabela-hash" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>é uma estrutura de dados que permite acesso rápido e eficiente com base em uma chave.&lt;/li>
&lt;li>é composta por um array de &amp;ldquo;baldes&amp;rdquo; onde os dados são armazenados&lt;/li>
&lt;li>a ideia e usar uma &lt;strong>função de hash&lt;/strong> que transforma a chave no indice do array.&lt;/li>
&lt;/ul>
&lt;h2 id="função-hashingespalhamento">Função hashing/espalhamento &lt;a href="#fun%c3%a7%c3%a3o-hashingespalhamento" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>$h(k)$ transforma uma chave &lt;strong>k&lt;/strong> em um endereço associado.&lt;/li>
&lt;li>similiar a indexação.&lt;/li>
&lt;/ul>
&lt;h3 id="hashing-interno">Hashing interno &lt;a href="#hashing-interno" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;p>hashing em memória principal, cada slot da hash representa um registro&lt;/p></description></item><item><title>Hashing extensível</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/7---hashing-extens%C3%ADvel/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/7---hashing-extens%C3%ADvel/</guid><description>&lt;ul>
&lt;li>O espalhamento extensível usa tries de ordem 2 como índices.&lt;/li>
&lt;li>Tabela de espalhamento indexa um conjunto de cestos&lt;/li>
&lt;li>Função Hash gera um endereço binário&lt;/li>
&lt;li>Busca por chave: análise bit-a-bit do valor de h(key) permite localizar o seu cesto.&lt;/li>
&lt;li>Níveis internos: rotulados com bits&lt;/li>
&lt;li>Nível dos nós folha: buckets contendo várias chaves ou registros&lt;/li>
&lt;/ul>
&lt;h2 id="diretório">Diretório &lt;a href="#diret%c3%b3rio" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Se faz necessário transformar a trie em um vetor de registros consecutivos, formando um diretório de endereços de espalhamento e ponteiros para os cestos associados.&lt;/p></description></item><item><title>Heap Sort</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/8---heap-sort/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/8---heap-sort/</guid><description>&lt;h3 id="conteudo-pra-eng-software-bom">conteudo pra Eng. software bom &lt;a href="#conteudo-pra-eng-software-bom" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;p>Sort -&amp;gt; saiba o merge sort.
Tabela Hash -&amp;gt; esteja preparado pra explicar uma tabela hash e saiba como implementá-la.
Usar API, uma lang, conhecimento de design e POO, dijkstra, A*
ED-&amp;gt; dinâmicas, tabela hash, dicionário, heap e grafos.
Matemática discreta
AVL, DFS, BFS, Dijkstra e A*&lt;/p>
&lt;hr>
&lt;h1 id="heap">heap &lt;a href="#heap" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>árvore binária quase-completa&lt;/li>
&lt;li>vetorizada.&lt;/li>
&lt;li>filho a esquerda de i (2i)&lt;/li>
&lt;li>filho a direita de i(2i +1)&lt;/li>
&lt;li>pai de i = i/2&lt;/li>
&lt;li>A[0] = raiz da árvore&lt;/li>
&lt;/ul>
&lt;h2 id="heap-máximo-e-minimo">heap máximo e minimo &lt;a href="#heap-m%c3%a1ximo-e-minimo" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>&lt;em>máximo&lt;/em> $A[PAI(i)] \geq A[i]$ maior elemento está na raiz, menor na ultima folha a direita 16 -&amp;gt; 1
&lt;em>minimo&lt;/em> $A[PAI(i)] \leq A[i]$ o contrário&lt;/p></description></item><item><title>Index</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/4---index/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/4---index/</guid><description>&lt;blockquote>
&lt;p>arquivo de índices contém todos os índices que referenciam os registros dentro dos arquivos de dados.&lt;/p>&lt;/blockquote>
&lt;h1 id="index">Index &lt;a href="#index" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Fornece mecanismos para localizar informações. É representado por vetores (maps, nesse caso) que contém as #keys e os campos de referencia. Deve-se criar uma chave primária para acesso à um campo ou guardar a referência ao seu endereço (apenas em runtime).&lt;/p>
&lt;blockquote>
&lt;p>Um índice, em geral, tem tamanho fixo e estão em outros arquivos. Tendo 2 campos fixos, a chave e o endereço (lógico ou físico). Ou pode ser uma árvore como a [[8 - B-TREE]]&lt;/p></description></item><item><title>index-5</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/4-an%C3%A1lisesint%C3%A1ticapreditivan%C3%A3orecursiva/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/4-an%C3%A1lisesint%C3%A1ticapreditivan%C3%A3orecursiva/</guid><description>&lt;h1 id="analise-sintática-preditiva-não-recursiva">Analise Sintática Preditiva Não Recursiva &lt;a href="#analise-sint%c3%a1tica-preditiva-n%c3%a3o-recursiva" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Algoritmo: Construção da tabela de análise sintática Preditiva&lt;/p>
&lt;p>Entrada: gramática G
Saída: tabela sintática M
Método:&lt;/p>
&lt;ol>
&lt;li>Para cada produção $A \rightarrow \alpha$, faça os passos 2 e 3:&lt;/li>
&lt;li>Para cada terminal $a$ em Primeiro($\alpha$), adicione a produção $A \rightarrow \alpha$ à entrada $M[A, a]$.&lt;/li>
&lt;li>Se $\epsilon$ estiver em Primeiro($\alpha$), adicionar $A \rightarrow \alpha$ em $M[A, b]$ para cada terminal b em Seguinte(A).&lt;/li>
&lt;/ol>
&lt;p>Exercicio: Construir a tabela de analise sintática preditiva para a seguinte gramática&lt;/p></description></item><item><title>Instruction Set Architecture</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/3---instruction-set-architecture/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/3---instruction-set-architecture/</guid><description>&lt;p>&lt;strong>Arquitetura do Conjunto de Instruções - (ISA) x86 - 8086&lt;/strong>&lt;/p>
&lt;h1 id="isa">&lt;strong>ISA&lt;/strong> &lt;a href="#isa" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Arquitetura de Conjunto de Instruções(ISA) é uma conexão entre o software e o hardware, correspondendo aos níveis de linguagem de montagem(assembly) e de linguagens de máquina e por isso deve ser equilibrada entre ambos, facilitando a montagem para ambas as partes. Em resumo, a ISA são as operações que o processador, microcontrolador, microprocessador, CPU, fornece ou disponibiliza para o programador, ou seja, é a representação em mnemônicos do código de máquina, com finalidade de facilitar o acesso aos componentes. O nível ISA define como a máquina apresenta a um programador de linguagem de máquina ou ao desenvolvedor de compiladores e interpretadores, sabendo quais são as instruções disponíveis, qual o modelo de memória usado, assim como seus registradores e seus tipos e quais tipos de dados a máquina suporta. Além da montagem, a ISA é essencial para o desenvolvimento de compiladores, definindo o conjunto de instruções que a CPU pode realizar, além de todos os recursos que a ISA proporciona.&lt;/p></description></item><item><title>intro-simplex</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/otimiza%C3%A7%C3%A3o-linear/intro-simplex/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/otimiza%C3%A7%C3%A3o-linear/intro-simplex/</guid><description>&lt;h1 id="soluções-básicas">Soluções Básicas &lt;a href="#solu%c3%a7%c3%b5es-b%c3%a1sicas" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Precisamos transformar, inicialmente, os problemas de otmização linear em sua forma padrão, ou seja, com restrições antes dadas por inequações em equações. Para isso, utilizamo-nos das variáveis de folga, que representam a diferença entre o lado esquerdo e o lado direito de uma inequação.&lt;/p>
&lt;p>Uma solução básica é, portanto, uma solução que satisfaz todas as restrições e que possui exatamente $m$ variáveis básicas (não nulas), node $m$ é o número de restrições do problema. As demais variáveis são chamadas de variáveis não básicas e são iguais a zero.&lt;/p></description></item><item><title>introdução</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/1-introdu%C3%A7%C3%A3o/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/1-introdu%C3%A7%C3%A3o/</guid><description>&lt;h1 id="introdução">Introdução &lt;a href="#introdu%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Compilador: programa que recebe entradas de texto em uma determinada linguagem fonte e a &amp;ldquo;traduz&amp;rdquo; sem percas para uma outra determinada linguagem, através do seguinte fluxo de dados: (1) analise; e (2) síntese.&lt;/p>
&lt;ol>
&lt;li>
&lt;p>Analise: subdividida em:&lt;/p>
&lt;ul>
&lt;li>analisador léxico: responsável por tokenizar (ler, agrupar e classificar) o input de texto recebido pelo compilador (arquivo(s)).&lt;/li>
&lt;li>analisador sintático: responsável por fazer uma analise hierárquica dos tokens, agrupando-os em coleções com significados coletivos.&lt;/li>
&lt;li>analisador semântico: assegura que os componentes agrupados tem algum sentido (e.g int = 5 e nao int = 2.0 ou &amp;ldquo;2&amp;rdquo;)&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>
&lt;p>Síntese:&lt;/p></description></item><item><title>Introdução</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/1---introdu%C3%A7%C3%A3o/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/1---introdu%C3%A7%C3%A3o/</guid><description>&lt;p>&lt;strong>organização estruturada de computadores&lt;/strong>: projetar sistemas computacionais de forma sistemática e organizada.
[[Organização de Computadores]]&lt;/p>
&lt;hr>
&lt;h1 id="linguagens-níveis-e-máquinas-virtuais">Linguagens, níveis e máquinas virtuais &lt;a href="#linguagens-n%c3%adveis-e-m%c3%a1quinas-virtuais" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>&lt;em>tradução:&lt;/em> reescrever um programa escrito em uma máquina, traduzindo suas instruções para instruções aceitas em outra máquina.&lt;/p>
&lt;p>&lt;em>interpretação:&lt;/em> um programa em uma máquina passa a ser tratado como uma entrada em outra, sendo lido linha a linha e executando diretamente a sequência de instruções equivalente.&lt;/p>
&lt;p>&lt;em>máquina virtual:&lt;/em> simula um ambiente onde um outro sistema é utilizado. Digamos que um programa rode em Windows de forma padrão, mas você precisa do mesmo em Linux. Pode-se dizer que uma máquina virtual simula o sistema escolhido, interpretando suas instruções para o ambiente &lt;em>&lt;strong>macro&lt;/strong>&lt;/em>.&lt;/p></description></item><item><title>Invariante de laço e Ordem de crescimento</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/3---invariante-de-la%C3%A7o-e-ordem-de-crescimento/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/3---invariante-de-la%C3%A7o-e-ordem-de-crescimento/</guid><description>&lt;h2 id="ordenação-por-inserção">Ordenação por inserção &lt;a href="#ordena%c3%a7%c3%a3o-por-inser%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>insere ordenado ai&lt;/p>
&lt;p>subdivide em 2 conjuntos, um ordenado o outro não&lt;/p>
&lt;p>o algoritmo acaba quando o Vetor A[1..n] contém valores originais, mas ordenados.&lt;/p>
&lt;hr>
&lt;h1 id="testes">Testes &lt;a href="#testes" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>provando um algoritmo fácil&lt;/li>
&lt;/ul>
&lt;h2 id="invariante-de-laço">Invariante de laço &lt;a href="#invariante-de-la%c3%a7o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>qualquer algoritmo de ordenação iterativo pode ser descrito por um invariante de laço (funciona como uma indução matemática)&lt;/p>
&lt;p>para o insertion sort, um invariante correto, seria:&lt;/p>
&lt;ul>
&lt;li>
&lt;p>“No inicio de cada iteração para o laço for das linhas 1-8, o sub-vetor A[1:i-1] consiste nos elementos que estavam originalmente em A[i:j-1], porém em sequência ordenada”&lt;/p></description></item><item><title>Lab. de Montagem</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/lab.-de-montagem/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/lab.-de-montagem/</guid><description>&lt;p>p1 - 20% → pode imprimir conteúdo pra prova
p2 - 40%&lt;/p>
&lt;hr>
&lt;p>artigo/relatório - 20%
seminário - 20%
→ desenvolvido em assembly&lt;/p>
&lt;hr></description></item><item><title>lalr</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/7-lalr/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/7-lalr/</guid><description>&lt;h1 id="tabela-lalr">Tabela LALR &lt;a href="#tabela-lalr" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Conjunto de itens igual LR(1), mas unindo os conjuntos de itens que possuem o mesmo núcleo (core), ou seja, que o lookahead é diferente.&lt;/p>
&lt;p>Tarefa: estudar a construção da tabela LALR a partir da tabela LR(1), no capitulo 4 do livro.&lt;/p>
&lt;h1 id="erros-sintáticos">Erros sintáticos &lt;a href="#erros-sint%c3%a1ticos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>exemplo: var i integer; // falta :&lt;/p>
&lt;p>Estratégias de tratamento de erros:&lt;/p>
&lt;ul>
&lt;li>Panic mode: pula0se parte do texto de entrada ate encontrar um token de sync (a partir dai continua a analise). Pode ser uma palavra-chave, um simbolo especial ou o fim de linha.&lt;/li>
&lt;li>Reparo (recuperação total): opção mais comum é inserir ou remover tokens para continuar a analise. Pode ser custoso.&lt;/li>
&lt;/ul>
&lt;h1 id="analise-semântica">Analise Semântica &lt;a href="#analise-sem%c3%a2ntica" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Feita durante a analise sintática, verificando se o sentido do programa está correto.&lt;/p></description></item><item><title>Manipulação dos Diferentes Tipos de Registradores</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/5---manipula%C3%A7%C3%A3o-dos-diferentes-tipos-de-registradores/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/5---manipula%C3%A7%C3%A3o-dos-diferentes-tipos-de-registradores/</guid><description>&lt;p>CS -&amp;gt; code segment
DS -&amp;gt; data segment, contém o endereço base do segmento de dados
ES -&amp;gt; extra (data) segment
FS -&amp;gt; segmento com mais dados
GS -&amp;gt; ainda mais dados
SS -&amp;gt; Segmento de pilha (stack)&lt;/p>
&lt;hr>
&lt;p>é possśivel dividir registrador entre a parte alta e baixa, os quais representam metade.&lt;/p>
&lt;h2 id="exemplos">exemplos &lt;a href="#exemplos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>MOV AX 25
MOV BX 4
IMUL BX; multiplica AX por BX;&lt;/p>
&lt;p>DX pode ser uma memória temporária&lt;/p></description></item><item><title>Matrizes</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/11---matrizes/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/11---matrizes/</guid><description>&lt;h1 id="multiplicação-de-cadeias-de-matrizes">Multiplicação de cadeias de matrizes &lt;a href="#multiplica%c3%a7%c3%a3o-de-cadeias-de-matrizes" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Temos uma sequência (cadeia)$〈A_1 , A_2 , &amp;hellip;, A_n 〉$ de n matrizes para multiplicar e desejamos calcular o produto $A_1A_2&amp;hellip;A_n$ usando o algoritmo-padrão para multiplicação de matrizes retangulares, enquanto minimizamos o número de multiplicações escalares.&lt;/p>
&lt;p>A multiplicação de matrizes é associativa, ou seja o resultado depende da ordem em que é realizada, assim, $A_1(A_2(A_3A_4)))\neq (A_1((A_2A_3)A_4))$. No problema de multiplicação de cadeias de matrizes, não estamos realmente multiplicando matrizes. Nossa meta é apenas determinar uma ordem para multiplicar matrizes que tenha o custo mais baixo.&lt;/p></description></item><item><title>Método de Newton-Raphson</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/8---m%C3%A9todo-de-newton-raphson/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/8---m%C3%A9todo-de-newton-raphson/</guid><description>&lt;p>Seja $g(x) = x + A(x)f(x)$, temos, então, o objetivo de determinar $A(x)$ que garanta a derivada 0 no ponto fixo.&lt;/p>
&lt;p>Vamos impor sobre $g(x)$ a condição de que $g&amp;rsquo;(\xi) = 0$, onde $\xi$ é solução de $f(x) = 0$. Derivando $g(x)$ temos:
$$g&amp;rsquo;(x) = 1 + A&amp;rsquo;(x)f(x)+A(x)f&amp;rsquo;(x)\newline
g&amp;rsquo;(\xi) = 1 + A&amp;rsquo;(\xi)f(\xi)+A(\xi)f&amp;rsquo;(\xi)\newline
$$
Sabemos que $A&amp;rsquo;(\xi).f(\xi) = 0$, porntato:
$$0 = 1 + A(\xi)f&amp;rsquo;(\xi)$$
Logo:
$$ A(\xi) = - \frac1{f&amp;rsquo;(\xi)}$$
Podemos, então, escolher
$$A(x) = -\frac1{f&amp;rsquo;(x)}$$
Temos que: $f&amp;rsquo;(x) \neq 0$ perto de $\xi$
Logo:
$$ g(x) = x - \frac{f(x)}{f&amp;rsquo;(x)}$$&lt;/p></description></item><item><title>Método do Ponto Fixo (MPF)</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/7---m%C3%A9todo-do-ponto-fixo-mpf/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/7---m%C3%A9todo-do-ponto-fixo-mpf/</guid><description>&lt;h1 id="ponto-fixo">Ponto Fixo &lt;a href="#ponto-fixo" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Seja $g:[a,b] \rightarrow R$ e $\xi \in [a,b]$
Dizemos que $\xi$ é ponto fixo de $g$ se
$g(\xi) = \xi$&lt;/p>
&lt;p>Ex: x² -&amp;gt; não altera os valores de 0 e 1, ou seja, f(x) = x, se x = [0, 1]&lt;/p>
&lt;p>Ou seja, onde os o gráfico de função $f(x)$ intersecta a reta $y = x$&lt;/p>
&lt;hr>
&lt;h1 id="método-do-ponto-fixo">Método do ponto fixo &lt;a href="#m%c3%a9todo-do-ponto-fixo" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>O método do ponto fixo consiste em transformar uma equação $f(x) = 0$ em uma função da forma
$$x = g(x)$$
Definimos uma sequência numérica, então, como:
$x_{k+1} = g(x_{k}),k=0,1, [..]$ para alguma aproximação inicial $x_0$. Ou seja,
$$x_{0}, x_{1} = g(x_{0})&amp;hellip;$$
se a sequencia $(x_k)_{k\geq0}$ converge, então ela converge para o ponto fixo de $g(x)$ ($\xi$)&lt;/p></description></item><item><title>Métodos Iterativos de solução de sistemas</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/14---m%C3%A9todos-iterativos-de-solu%C3%A7%C3%A3o-de-sistemas/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/14---m%C3%A9todos-iterativos-de-solu%C3%A7%C3%A3o-de-sistemas/</guid><description>&lt;p>Considere o espaço vetorial $R^{n}$ das n-uplas $(x_{1}, x_{2},&amp;hellip;, x_{n})$ de números reais.
A norma euclidiana em $R^{n}$ é dada por $||(x_{1}, x_{2},..,x_{n})|| = \sqrt{x_{1}^{2} + .. + x_{n}^{2}}$&lt;br>
$d = ||x-y||$
outras normas:&lt;/p>
&lt;ul>
&lt;li>norma da soma -&amp;gt; $||x||&lt;em>{1}$ = $|x&lt;/em>{1}| + |x_{2}| +&amp;hellip;+|x_{n}|$&lt;/li>
&lt;li>norma do máximo -&amp;gt; $||x||&lt;em>{\infty} = max&lt;/em>{1\leq x \leq n} |x_{i}|$ &amp;ndash; usaremos essa&lt;/li>
&lt;/ul>
&lt;p>Todas essas normas são equivalentes e também induzem à ideia de distância em $R^{n}$.&lt;/p></description></item><item><title>microarquitetura</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/4---microarquitetura/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/4---microarquitetura/</guid><description>&lt;h2 id="exemplo-de-microarquitetura">Exemplo de Microarquitetura &lt;a href="#exemplo-de-microarquitetura" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>O projeto de microarquitetura pode ser visto como um problema de programação, onde cada instrução no nível ISA é uma função chamada por um programa mestre.&lt;/li>
&lt;li>O programa mestre é um laço simples e sem fim que invoca funções com base em variáveis acessíveis, conhecidas como o &lt;strong>estado do computador&lt;/strong>.&lt;/li>
&lt;li>IFU -&amp;gt; instruction fetch unit&lt;/li>
&lt;li>EU -&amp;gt; executa&lt;/li>
&lt;/ul>
&lt;h3 id="caminho-de-dados">Caminho de Dados &lt;a href="#caminho-de-dados" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>O caminho de dados é a parte da CPU que contém a ULA (Unidade Lógica e Aritmética), suas entradas e saídas.&lt;/li>
&lt;li>Para controlar o caminho de dados, são necessários 29 sinais, divididos em cinco grupos funcionais:
&lt;ul>
&lt;li>sinais para controle de escrita nos registradores.&lt;/li>
&lt;li>sinais para controle dos registradores para a entrada da ULA.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;h2 id="projeto-de-nível-de-microarquitetura">Projeto de Nível de Microarquitetura &lt;a href="#projeto-de-n%c3%advel-de-microarquitetura" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;h3 id="melhoria-de-velocidade">Melhoria de Velocidade &lt;a href="#melhoria-de-velocidade" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>Existem três abordagens básicas para aumentar a velocidade de execução:
&lt;ol>
&lt;li>Reduzir o número de ciclos de clock para cada instrução.&lt;/li>
&lt;li>Simplificar a organização, tornando o ciclo de clock mais curto.&lt;/li>
&lt;li>Sobrepor a execução de instruções.&lt;/li>
&lt;/ol>
&lt;/li>
&lt;/ul>
&lt;h3 id="operações-por-instrução">Operações por Instrução &lt;a href="#opera%c3%a7%c3%b5es-por-instru%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>Para cada instrução, as seguintes operações podem ocorrer:
&lt;ol>
&lt;li>O PC (Program Counter) é incrementado.&lt;/li>
&lt;li>O próximo byte da sequência de instruções é buscado.&lt;/li>
&lt;li>Operandos são lidos e escritos na memória.&lt;/li>
&lt;li>A ULA realiza cálculos e armazena os resultados.&lt;/li>
&lt;/ol>
&lt;/li>
&lt;/ul>
&lt;h3 id="pipeline">Pipeline &lt;a href="#pipeline" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>Pipeline é uma técnica fundamental que permite sobreposição de execução de instruções, reduzindo o tempo total de processamento.&lt;/li>
&lt;/ul>
&lt;h2 id="memória-cache">Memória Cache &lt;a href="#mem%c3%b3ria-cache" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Uma cache armazena palavras de memória usadas recentemente, acelerando o acesso.&lt;/li>
&lt;li>Muitas arquiteturas modernas utilizam &lt;strong>cache dividida&lt;/strong> para instruções e dados.&lt;/li>
&lt;li>Sistemas podem ter até três níveis de cache para otimizar ainda mais o desempenho.&lt;/li>
&lt;/ul>
&lt;h3 id="tipos-de-cache">Tipos de Cache &lt;a href="#tipos-de-cache" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;ul>
&lt;li>&lt;strong>Cache de Mapeamento Direto&lt;/strong>: o tipo mais simples de cache.&lt;/li>
&lt;li>&lt;strong>Cache Associativa&lt;/strong>: permite que múltiplos blocos de memória sejam mapeados para uma mesma linha de cache.&lt;/li>
&lt;/ul>
&lt;h2 id="previsão-de-desvio">Previsão de Desvio &lt;a href="#previs%c3%a3o-de-desvio" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Programas não seguem uma sequência linear, mas incluem muitas instruções de desvio.&lt;/li>
&lt;li>O pipelining precisa lidar com desvios, que criam &lt;strong>slots de atraso&lt;/strong>.&lt;/li>
&lt;li>Técnicas como o &lt;strong>histórico de desvio de 1 bit&lt;/strong> e &lt;strong>histórico de desvio de 2 bits&lt;/strong> são utilizadas para prever desvios com mais precisão.&lt;/li>
&lt;/ul>
&lt;h2 id="execução-fora-de-ordem-e-renomeação-de-registrador">Execução Fora de Ordem e Renomeação de Registrador &lt;a href="#execu%c3%a7%c3%a3o-fora-de-ordem-e-renomea%c3%a7%c3%a3o-de-registrador" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>A &lt;strong>renomeação de registrador&lt;/strong> evita hazards entre instruções (WAR e WAW), alocando registradores temporários que não são visíveis para o programador.&lt;/li>
&lt;li>Esta técnica permite a emissão de instruções em paralelo, aumentando o desempenho.&lt;/li>
&lt;/ul>
&lt;h2 id="execução-especulativa">Execução Especulativa &lt;a href="#execu%c3%a7%c3%a3o-especulativa" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>A execução especulativa divide o programa em &lt;strong>blocos básicos&lt;/strong> e tenta prever a execução de instruções futuras.&lt;/li>
&lt;li>Um problema com a execução especulativa é que as instruções executadas podem causar exceções ou serem inválidas, pois dependem de uma condição futura.&lt;/li>
&lt;/ul></description></item><item><title>Modelo Normal ou Curva Gaussiana</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/13---modelo-normal-ou-curva-gaussiana/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/13---modelo-normal-ou-curva-gaussiana/</guid><description>&lt;p>$$f(x) = \frac{1}{\sigma\sqrt{2\pi}}e^{\frac{-1}{2}(\frac{x-\micro}{\sigma})^{2}};x\in R$$
média = $\micro$
desvio padrão = $\sigma$
Função unimodal em com forma de sino.&lt;/p>
&lt;h2 id="props">props &lt;a href="#props" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>
&lt;p>muitos fenômenos são associados a este modelo.&lt;/p>
&lt;/li>
&lt;li>
&lt;p>pode ser usado para aproximar modelo de variáveis aleatórias como binomial, Poisson&amp;hellip;&lt;/p>
&lt;/li>
&lt;li>
&lt;p>Proporciona um embasamento para a inferência clássica que possibilita estimar parâmetros e testar hipóteses.&lt;/p>
&lt;/li>
&lt;li>
&lt;p>A área sosb $f(x)$ compreendida entre $\micro - \sigma$ e $\micro + \sigma$ é de 68.27%&lt;/p></description></item><item><title>Modelos Probabilísticos para v.a discretas</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/9---modelos-probabil%C3%ADsticos-para-v.a-discretas/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/9---modelos-probabil%C3%ADsticos-para-v.a-discretas/</guid><description>&lt;h1 id="modelo-binomial">Modelo Binomial &lt;a href="#modelo-binomial" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>$p(x) = P(X = x) = \binom{n}{x}p^{x}(1-p)^n-x$;
$x = 0,1,2,&amp;hellip;,n$&lt;/p>
&lt;p>p -&amp;gt; proporção
x -&amp;gt; valores possíveis&lt;/p>
&lt;p>&lt;em>notação:&lt;/em> $X-b(n,p)$
p &amp;lt; 1&lt;/p>
&lt;p>$E(X) = np$
$V(X) = np(1-p)$&lt;/p>
&lt;h2 id="exemplo">exemplo &lt;a href="#exemplo" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>noticias falsas enviadas a 100 pessoas com 0.7 chance delas acreditarem
$n=100$
$p=0.7$
$X:$ n° de pessoas que acreditam em noticias falsas
E(X) -&amp;gt; quantas pessoas eu espero que acreditem&lt;/p>
&lt;ul>
&lt;li>$100 \times 0.7 = 70$&lt;/li>
&lt;/ul>
&lt;p>&lt;em>enunciado&lt;/em>: qual a probabilidade de no máximo 2 pessoas acreditem que a notícia é verdadeira?&lt;/p></description></item><item><title>Montar um caso real - probabilidade e estatística</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/montar-um-caso-real---probabilidade-e-estat%C3%ADstica/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/montar-um-caso-real---probabilidade-e-estat%C3%ADstica/</guid><description>&lt;p>exercício: montar uma matriz de confusão, achar a sensibilidade, a precisão, a acurácia e especifidade baseado em um set real.&lt;/p>
&lt;h1 id="teste-genérico">Teste Genérico &lt;a href="#teste-gen%c3%a9rico" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;h2 id="exemplo-de-dataset-pequeno-para-classificação-binária-gerado-pelo-gpt">Exemplo de Dataset Pequeno para Classificação Binária (gerado pelo gpt) &lt;a href="#exemplo-de-dataset-pequeno-para-classifica%c3%a7%c3%a3o-bin%c3%a1ria-gerado-pelo-gpt" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Dados:&lt;/p>
&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>Amostra&lt;/th>
 &lt;th>Predição do Modelo&lt;/th>
 &lt;th>Classe Verdadeira&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>1&lt;/td>
 &lt;td>Positivo&lt;/td>
 &lt;td>Positivo&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>2&lt;/td>
 &lt;td>Positivo&lt;/td>
 &lt;td>Negativo&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>3&lt;/td>
 &lt;td>Negativo&lt;/td>
 &lt;td>Negativo&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>4&lt;/td>
 &lt;td>Positivo&lt;/td>
 &lt;td>Positivo&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>5&lt;/td>
 &lt;td>Negativo&lt;/td>
 &lt;td>Negativo&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>6&lt;/td>
 &lt;td>Negativo&lt;/td>
 &lt;td>Positivo&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>7&lt;/td>
 &lt;td>Positivo&lt;/td>
 &lt;td>Positivo&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>8&lt;/td>
 &lt;td>Negativo&lt;/td>
 &lt;td>Negativo&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>9&lt;/td>
 &lt;td>Positivo&lt;/td>
 &lt;td>Negativo&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>10&lt;/td>
 &lt;td>Positivo&lt;/td>
 &lt;td>Positivo&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;p>Compilado:&lt;/p></description></item><item><title>Nivel arquitetura do conjunto de instruções</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/5---nivel-arquitetura-do-conjunto-de-instru%C3%A7%C3%B5es/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/5---nivel-arquitetura-do-conjunto-de-instru%C3%A7%C3%B5es/</guid><description>&lt;p>O nivel ISA precisa de informações prévias declaras sobre o sistema computacional, como por exemplo:&lt;/p>
&lt;ul>
&lt;li>tamanho da stack&lt;/li>
&lt;li>tipo de registradores&lt;/li>
&lt;li>tipo de dados&lt;/li>
&lt;li>instruções na memória fisica&lt;/li>
&lt;/ul>
&lt;p>No geral, é separada uma palavra de $n$ bytes que representa a memória do sistema (os endereços), ou seja, que quando referenciada, indica a posição de alguma outra palavra em uma memória maior.&lt;/p>
&lt;h2 id="endereçamento">Endereçamento &lt;a href="#endere%c3%a7amento" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Pode-se colocar o endereço completado do operando na instrução, permitindo o acesso direto a ele, também pode-se colocar o operando em si na instrução (horrivel).
Outra maneira, é usar o endereçamento indexado, o qual salva um valor que representa uma posição em um conjunto pré definido de memória, como um vetor ou outra estrutura de dados.&lt;/p></description></item><item><title>Nível de linguagem de montagem</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/7---n%C3%ADvel-de-linguagem-de-montagem/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/7---n%C3%ADvel-de-linguagem-de-montagem/</guid><description/></item><item><title>nível lógico digital</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/3---n%C3%ADvel-l%C3%B3gico-digital/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/3---n%C3%ADvel-l%C3%B3gico-digital/</guid><description>&lt;h1 id="portas-e-álgebra-booleana">Portas e álgebra booleana &lt;a href="#portas-e-%c3%a1lgebra-booleana" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>![[Pasted image 20240906081026.png]]&lt;/p>
&lt;p>Usaremos tabelas verdade baseadas na álgebra booleana.&lt;/p>
&lt;p>O objetivo é criar um circuito que faz um cálculo da maneira mais efetiva possível, ou seja, tem a menor quantidade de portas e a mesma precisão.&lt;/p>
&lt;p>![[Pasted image 20240906081353.png]]&lt;/p>
&lt;h2 id="circuitos-integrados">Circuitos integrados &lt;a href="#circuitos-integrados" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Os componentes lógicos são agora distribuídos dentro de chips, que são um pedaço de silício que compreende portas lógicas.
Tipos comuns de pacotes de circuito integrado, incluindo um pacote dual-in-line, ou DIP, PGA e LGA.&lt;/p></description></item><item><title>Notações</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/5---nota%C3%A7%C3%B5es/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/5---nota%C3%A7%C3%B5es/</guid><description>&lt;p>A ideia é chegar o mais rápido possível na ordem de crescimento de um algoritmo.&lt;/p>
&lt;h2 id="notação-o">Notação $O$ &lt;a href="#nota%c3%a7%c3%a3o-o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>A notação O caracteriza o limite superior sobre o comportamento assintótico de uma função. Em outras palavras, descreve o limite de crescimento de alguma função. Representamos sempre pelo termo de mais alta ordem de uma função de custo. A constante apenas modifica o quanto de entrada será necessário para chegar no limite definido, então ela n importa.&lt;/p></description></item><item><title>Ordenacao em Tempo Linear</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/9---ordenacao-em-tempo-linear/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/9---ordenacao-em-tempo-linear/</guid><description>&lt;p>O modelo de árvore de decisão:&lt;/p>
&lt;ul>
&lt;li>uma árvore binária cheia que representa comparações entre elementos para obter informações de ordem para uma sequência de entrada. Isto é, dados 2 elementos $a_{i}$ e $a_{j}$ executamos um dos testes $a_i&amp;lt; a_j, a_i \leq a_j, a_i = a_j, a_i &amp;gt; a_{j} \ ou \ a_{i} \geq a$&lt;/li>
&lt;/ul>
&lt;h2 id="props">props &lt;a href="#props" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>cada nó interno é tido como um intervalo do vetor $i:j$.&lt;/li>
&lt;li>cada folha é uma permutação entre os elementos do vetor.&lt;/li>
&lt;/ul>
&lt;h1 id="ordenação-por-contagem-counting-sort">Ordenação por contagem (Counting Sort) &lt;a href="#ordena%c3%a7%c3%a3o-por-contagem-counting-sort" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Uma ordenação por contagem supõe que cada um dos n elementos de entrada é um inteiro na faixa 1 a k, para algum inteiro k. Quando k = $O(n)$ a ordenação é executada no tempo n.&lt;/p></description></item><item><title>Organização de arquivos</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/3---organiza%C3%A7%C3%A3o-de-arquivos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/ed-2/3---organiza%C3%A7%C3%A3o-de-arquivos/</guid><description>&lt;h1 id="organização-de-arquivos">Organização de Arquivos &lt;a href="#organiza%c3%a7%c3%a3o-de-arquivos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Stream → não precisa ser ligado a arquivos, necessariamente, são espécies de buffers&lt;/p>
&lt;p>Arquivo → conjunto de bytes foda com extensão&lt;/p>
&lt;h1 id="organização-em-registros">Organização em registros &lt;a href="#organiza%c3%a7%c3%a3o-em-registros" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>registro (struct) → conjunto de campos agrupados&lt;/p>
&lt;ul>
&lt;li>tem como objetivo preservar significado e estados&lt;/li>
&lt;/ul>
&lt;h2 id="métodos-de-organização">Métodos de organização &lt;a href="#m%c3%a9todos-de-organiza%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>
&lt;p>pode-se declarar indicadores, seja de tamanho de bytes de um registro ou apenas um separador entre campos&lt;/p>
&lt;/li>
&lt;li>
&lt;p>pode-se usar um indice externo&lt;/p></description></item><item><title>Organização de Computadores</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/organiza%C3%A7%C3%A3o-de-computadores/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/organiza%C3%A7%C3%A3o-de-computadores/</guid><description>&lt;p>[livro](&lt;a href="https://ia801605.us.archive.org/32/items/tanenbaum-organizacao-estruturada-de-computadores-6a/Tanenbaum" rel="external" target="_blank">https://ia801605.us.archive.org/32/items/tanenbaum-organizacao-estruturada-de-computadores-6a/Tanenbaum&lt;svg width="16" height="16" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">&lt;path fill="currentColor" d="M14 5c-.552 0-1-.448-1-1s.448-1 1-1h6c.552 0 1 .448 1 1v6c0 .552-.448 1-1 1s-1-.448-1-1v-3.586l-7.293 7.293c-.391.39-1.024.39-1.414 0-.391-.391-.391-1.024 0-1.414l7.293-7.293h-3.586zm-9 2c-.552 0-1 .448-1 1v11c0 .552.448 1 1 1h11c.552 0 1-.448 1-1v-4.563c0-.552.448-1 1-1s1 .448 1 1v4.563c0 1.657-1.343 3-3 3h-11c-1.657 0-3-1.343-3-3v-11c0-1.657 1.343-3 3-3h4.563c.552 0 1 .448 1 1s-.448 1-1 1h-4.563z"/>&lt;/svg>&lt;/a> - Organização Estruturada de Computadores - 6a.pdf)&lt;/p>
&lt;p>[[1 - Introdução]]
[[2 - Organização de sistemas de computadores]]
[[3 - nível lógico digital]]&lt;/p></description></item><item><title>Organização de sistemas de computadores</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/2---organiza%C3%A7%C3%A3o-de-sistemas-de-computadores/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/2---organiza%C3%A7%C3%A3o-de-sistemas-de-computadores/</guid><description>&lt;ul>
&lt;li>somente operações LOAD/STORE devem referenciar a memória.&lt;/li>
&lt;li>necessários muitos registradores, trabalhando em uma pipeline unica ou dividida em threads físicas e/ou logicas, onde cada registrador manipulado pode ser parte do processo.&lt;/li>
&lt;/ul>
&lt;p>#Memoria #cache #ram #paralelismo&lt;/p>
&lt;h1 id="instruções">Instruções &lt;a href="#instru%c3%a7%c3%b5es" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>[[Conjunto de Instruções]]
[[Ciclo de instrução – O retorno]]
A CPU executa cada instrução em uma série de pequenas etapas. Em termos simples, as etapas são as seguintes:&lt;/p>
&lt;ol>
&lt;li>Trazer a próxima instrução da memória até o registrador ele instrução.&lt;/li>
&lt;li>Alterar o contador de programa para que aponte para a próxima instrução.&lt;/li>
&lt;li>Determinar o tipo de instrução trazida.&lt;/li>
&lt;li>Se a instrução usar uma palavra na memória, determinar onde essa palavra está.&lt;/li>
&lt;li>Trazer a palavra para dentro de um registrador da CPU, se necessário.&lt;/li>
&lt;li>Executar a instrução.&lt;/li>
&lt;li>Voltar à etapa 1 para iniciar a execução da instrução seguinte.&lt;/li>
&lt;/ol>
&lt;h1 id="paralelismo">Paralelismo &lt;a href="#paralelismo" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>[[Paralelismo em nível de instrução]]
[[Paralelismo em nível de dados]]
[[Paralelismo em nível de thread (n vou terminar esse)]]&lt;/p></description></item><item><title>Paralelismo em nível de dados</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/paralelismo-em-n%C3%ADvel-de-dados/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/paralelismo-em-n%C3%ADvel-de-dados/</guid><description>&lt;p>DLP (data level paralelism)&lt;/p>
&lt;p>→ SIMD (Single Instruction Multiple Data)&lt;/p>
&lt;ul>
&lt;li>Arquiteturas Vetoriais&lt;/li>
&lt;li>SIMD para multimídia (SPDO – Simultaneous Parallel Data Operation);&lt;/li>
&lt;li>GPU (Graphical Processing Unit).&lt;/li>
&lt;/ul>
&lt;hr>
&lt;h1 id="arquitetura-vetorial">Arquitetura vetorial &lt;a href="#arquitetura-vetorial" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>coleta dados da memória, coloca em arquivos em registradores sequenciais e os trata com uma instrução apenas, retornando a memória após o tratamento.&lt;/p>
&lt;p>A ideia dos programas vetoriais é manter a memória ocupada todo tempo.&lt;/p>
&lt;h1 id="vmips">VMIPS &lt;a href="#vmips" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>trata-se do uso da MIPS (microprocessors without interlocekd pipeline stages) mas vetorial, utilizado em RISC normalmente&lt;/li>
&lt;li>todas as operações são feitas em registradores, ou seja, tem a velocidade de memória mais absurda possível&lt;/li>
&lt;/ul>
&lt;h2 id="isa-vmips">ISA VMIPS &lt;a href="#isa-vmips" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>registradores vetoriais
&lt;ul>
&lt;li>único vetor fixo de um registrador&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>unidades funcionais vetoriais
&lt;ul>
&lt;li>cada unidade é pipelined&lt;/li>
&lt;li>uma operação iniciada por ciclo&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>unidade de carregamento/armazenamento vetorial
&lt;ul>
&lt;li>carrega e armazena nas pipelines&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>conjunto de registradores escalares
&lt;ul>
&lt;li>calculam os endereços para a load/store e promovem a entrada de dados na VMIPS&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;hr>
&lt;h1 id="tempo-de-execução">Tempo de execução &lt;a href="#tempo-de-execu%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>depende&lt;/p></description></item><item><title>Paralelismo em nível de instrução</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/paralelismo-em-n%C3%ADvel-de-instru%C3%A7%C3%A3o/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/paralelismo-em-n%C3%ADvel-de-instru%C3%A7%C3%A3o/</guid><description>&lt;h1 id="visão-geral">Visão geral &lt;a href="#vis%c3%a3o-geral" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>pipeline busca sobrepor operações da instrução de forma paralela, tornando cada parte do processador utilizável enquanto outra está em uso, montando assim um “dado duto”&lt;/p>
&lt;p>![[/Untitled 9.png|Untitled 9.png]]&lt;/p>
&lt;hr>
&lt;p>Os processadores usam uma pipeline pra sobrepor instruções. → ILP – Instruction Level Parallelism;&lt;/p>
&lt;p>Existem 2 tipos de ILP, assistido por hardware e por software.&lt;/p>
&lt;p>Em geral, tende-se a utilizar mais ILPs em pontos com loops, visto que a execução do próximo loop pode ser prevista de acordo com o atual, admitindo poucos erros.&lt;/p></description></item><item><title>Paralelismo em nível de thread (n vou terminar esse)</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/paralelismo-em-n%C3%ADvel-de-thread-n-vou-terminar-esse/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/paralelismo-em-n%C3%ADvel-de-thread-n-vou-terminar-esse/</guid><description>&lt;p>MMID → (Multiple Instruction Multiple Data);&lt;/p></description></item><item><title>Persistência</title><link>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/12---persist%C3%AAncia/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/5-semestre/sistemas-operacionais/12---persist%C3%AAncia/</guid><description>&lt;p>DMI - Direct Media Interface, o qual conecta diretamente a um I/O Chip
PCIe (Peripheral Component Interconnect Express)&lt;/p>
&lt;h2 id="responsabilidades-do-so">Responsabilidades do SO: &lt;a href="#responsabilidades-do-so" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>checar disponibilidade do IO device. Chamamos o estado de espera (enquanto STATUS == BUSY) como polling. Esse polling representa verificações constantes ao dispositivo de IO se ele está ou não disponível.&lt;/p>
&lt;p>Quando a CPU está envolvida no processo de IO, chamamos isso de &lt;code>IO Programado ou PIO.&lt;/code>&lt;/p>
&lt;blockquote>
&lt;p>[!error] Error&lt;/p></description></item><item><title>Pivoteamento Parcial</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/12---pivoteamento-parcial/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/12---pivoteamento-parcial/</guid><description>&lt;p>Pivoteamento parcial é uma estratégia para evitar erros de solução de sistemas cuja origem são pivôs muito pequenos ($x\times10^{-i&amp;gt;2}$) em módulo. Dado um sistema:
$$Ax=b$$
a estratégia de pivoteamento parcial consiste em:
Para $j=1,2,3 &amp;hellip;,n-1$, na Etapa $j$ da eliminação de &lt;em>Gauss&lt;/em> consideramos o pivô $a_{jj}$ e escolhemos a linha $i \gt j$ que satisfaz $|a_{ij}| = max_{k&amp;gt;j}|a_{ij}|$ e trocamos a linha $i$ com a linha $j$.&lt;/p>
&lt;p>nota de otário (eu):&lt;/p></description></item><item><title>planejamento trabalho</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/planejamento-trabalho/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/planejamento-trabalho/</guid><description>&lt;blockquote>
&lt;p>5 semanas&lt;/p>&lt;/blockquote>
&lt;h2 id="1-semana">1 semana &lt;a href="#1-semana" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Fonte de dados
Análise exploratória dos dados
Pré-processamento dos dados&lt;/p>
&lt;h2 id="3-semanas">3 semanas &lt;a href="#3-semanas" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Escolha do modelo de recomendação
Implementação do modelo
Avaliação do modelo por métricas adequadas
Elaboração de relatório&lt;/p>
&lt;h2 id="1-semana-1">1 semana &lt;a href="#1-semana-1" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Criação de uma interface simples
Slide&lt;/p>
&lt;p>entregas seriam toda quarta feira até o dia 6, tendo assim dia 13 e 20 para margem de erro.&lt;/p></description></item><item><title>Probabilidade Condicional</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/6---probabilidade-condicional/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/6---probabilidade-condicional/</guid><description>&lt;p>def: 2 eventos A e B, sendo P(B) &amp;gt; 0, definimos a probabilidade condicional de A dado B, P(A\B), como sendo:
$$ P(A \backslash B) = \frac{P(A\cap B)}{P(B)}$$&lt;/p>
&lt;p>Desta relação, obtemos a &lt;strong>regra do produto da probabilidades&lt;/strong>:
$$P(A\cap B)= P(A\backslash B)\ P(B)$$&lt;/p>
&lt;blockquote>
&lt;p>basicamente, é a probabilidade de algo ocorrer baseado em outro algo que tem sua própria probabilidade&lt;/p>&lt;/blockquote>
&lt;p>sintaxe: P(A \ M) -&amp;gt; lido como: probabilidade de A acontecer se M -&amp;gt; P de A se M;&lt;/p></description></item><item><title>Probabilidade e Estatística</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/probabilidade-e-estat%C3%ADstica/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/probabilidade-e-estat%C3%ADstica/</guid><description>&lt;p>[[bcc/4° Semestre/Probabilidade e Estatística/1 - Conceitos|1 - Conceitos]]
[[3 - Probabilidades]]
[[3 - só no caderno]]
[[5 - Definições]]
[[6 - Probabilidade Condicional]]
[[6.1- Matriz de Confusão]]
[[8 - Variáveis Aleatórias]]&lt;/p></description></item><item><title>Probabilidades</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/3---probabilidades/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/3---probabilidades/</guid><description>&lt;p>Probabilidade é um numero real no intervalo de 0 a 1 que é utilizado para exprimir a chance de ocorrência de determinado evento.&lt;/p>
&lt;blockquote>
&lt;p>consiste na teoria matemática usada para se estudar a incerteza proveniente dos fenômenos aleatórios.&lt;/p>&lt;/blockquote>
&lt;p>&lt;strong>grau de convicção&lt;/strong>: quantificado pelo valor da probabilidade.&lt;/p>
&lt;hr>
&lt;p>Uma função $P(.)$ é denominada probabilidade se satisfaz as condições:&lt;/p>
&lt;p>$i.$ $P(\Omega) = 1$
$ii.$ $0\leq P(A)\leq1, \forall A \subset \Omega$&lt;br>
$iii.$&lt;/p></description></item><item><title>Problemas NP Completos</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/13---problemas-np-completos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/13---problemas-np-completos/</guid><description/></item><item><title>problemas-comuns</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/otimiza%C3%A7%C3%A3o-linear/problemas-comuns/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/otimiza%C3%A7%C3%A3o-linear/problemas-comuns/</guid><description>&lt;p>Trataremos de 4 problemas padrão da prog. linear neste documento:&lt;/p>
&lt;ul>
&lt;li>Problema da Mistura&lt;/li>
&lt;li>Problema do Transporte&lt;/li>
&lt;li>Problema do Transbordo&lt;/li>
&lt;li>Problema da Designação&lt;/li>
&lt;/ul>
&lt;h1 id="problema-da-mistura">Problema da mistura &lt;a href="#problema-da-mistura" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Entende-se como um problema de se misturar ingredientes ou materiais com um suposto custo associado e uma determinada quantidade (os quais se deseja otimizar). Cada um dos ingredientes possui uma quantia de componentes a qual se é necessário assegurar uma quantidade correta na mistura.&lt;/p></description></item><item><title>Prog Dinamica</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/10---prog-dinamica/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/10---prog-dinamica/</guid><description>&lt;p>Programação dinâmica: subdividir um problema de otimização nos quais temos estratégias mais simples de chegar em solução ótima.&lt;/p>
&lt;p>A estratégia fundamental é armazenar a solução para cada um desses subproblemas em vez de recalculá-la. Veremos como essa ideia pode transformar algs de tempo péssimo em um tempo ótimo.&lt;/p>
&lt;p>Os algoritmos gulosos se aplicam a problemas de otimização. A ideia é fazer cada escolha de maneira ótima local, resultando em um algoritmo mais rápido do que aquele obtido na prog dinâmica.&lt;/p></description></item><item><title>Projeto e Analise de Algoritmos</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/projeto-e-analise-de-algoritmos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/projeto-e-analise-de-algoritmos/</guid><description>&lt;p>[[1 - Conceitos Básicos]]
[[2 - Complexidade]]
[[3 - Invariante de laço e Ordem de crescimento]]
[[4 - Divisão e Conquista|4 - Divisão e Conquista]]&lt;/p>
&lt;p>&lt;a href="https://ia801902.us.archive.org/17/items/2008-book-the-algorithm-design-manual/2008_Book_TheAlgorithmDesignManual.pdf" rel="external" target="_blank">https://ia801902.us.archive.org/17/items/2008-book-the-algorithm-design-manual/2008_Book_TheAlgorithmDesignManual.pdf&lt;svg width="16" height="16" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">&lt;path fill="currentColor" d="M14 5c-.552 0-1-.448-1-1s.448-1 1-1h6c.552 0 1 .448 1 1v6c0 .552-.448 1-1 1s-1-.448-1-1v-3.586l-7.293 7.293c-.391.39-1.024.39-1.414 0-.391-.391-.391-1.024 0-1.414l7.293-7.293h-3.586zm-9 2c-.552 0-1 .448-1 1v11c0 .552.448 1 1 1h11c.552 0 1-.448 1-1v-4.563c0-.552.448-1 1-1s1 .448 1 1v4.563c0 1.657-1.343 3-3 3h-11c-1.657 0-3-1.343-3-3v-11c0-1.657 1.343-3 3-3h4.563c.552 0 1 .448 1 1s-.448 1-1 1h-4.563z"/>&lt;/svg>&lt;/a>&lt;/p></description></item><item><title>Pseudo Instruções e Diretivas de Montagem</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/7---pseudo-instru%C3%A7%C3%B5es-e-diretivas-de-montagem/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/7---pseudo-instru%C3%A7%C3%B5es-e-diretivas-de-montagem/</guid><description>&lt;h1 id="pseudo-instrução">pseudo instrução &lt;a href="#pseudo-instru%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Pseudo instruções são comandos usados em asm que não correspondem diretamente a uma instrução de máquina mas que ajudam a simplificar o código e são transformadas em instruções de máquina.&lt;/p>
&lt;p>Elas são reconhecidas pelo montador que as converte em uma ou mais instruções.
&lt;strong>EX:&lt;/strong>&lt;/p>
&lt;ul>
&lt;li>alocação de memória;&lt;/li>
&lt;li>atribuição de valores; e&lt;/li>
&lt;li>manipulação de dados.&lt;/li>
&lt;/ul>
&lt;h1 id="diretivas">diretivas &lt;a href="#diretivas" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>servem apenas para o montador, elas não geram código executável.&lt;/p>
&lt;p>&lt;em>end&lt;/em>: marca o final do código fonte.
&lt;em>segment&lt;/em>:
&lt;em>DB&lt;/em>: declara um ou mais bytes de dados. Pode ser usado para definir variáveis de byte e inicializá-las com valores especificos.
&lt;em>EQU&lt;/em>: define uma constante com valor fixo.
&lt;em>NOP&lt;/em>: não faz nada, consome um ciclo de clock.&lt;/p></description></item><item><title>Recorrências</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/6---recorr%C3%AAncias/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/projeto-e-analise-de-algoritmos/6---recorr%C3%AAncias/</guid><description>&lt;p>É uma equação ou inequação que descreve uma função em termos de seu valor em outros argumentos, normalmente menores. (explicitamente, recursão)&lt;/p>
&lt;p>Uma recorrência é algorítmica se, para cada constante de limiar suficientemente grande $n_{0}&amp;gt; 0$, as seguintes props forem verdadeiras:&lt;/p>
&lt;ul>
&lt;li>$\forall n &amp;lt; n_{0}, T(n) = \Theta(1)$
-$\forall n \geq n_{0}$ cada caminho de recursão termina em um caso base dentro de um numero finito de chamadas recursivas&lt;/li>
&lt;/ul>
&lt;hr>
&lt;p>Adotamos a seguinte convenção:&lt;/p></description></item><item><title>Refinamento dos Resultados</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/6---refinamento-dos-resultados/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/6---refinamento-dos-resultados/</guid><description>&lt;p>Fase 1 -&amp;gt; [[5 - Solução de equações não lineares por métodos numéricos]]&lt;/p>
&lt;blockquote>
&lt;p>Refinamento de zeros de funções através de métodos iterativos&lt;/p>&lt;/blockquote>
&lt;h2 id="métodos">Métodos &lt;a href="#m%c3%a9todos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>um métodos iterativo é a construção de uma sequência de valor $x_0, x_1, x_2,&amp;hellip;, x_{x-1}$ tais que:&lt;/li>
&lt;li>$(i)$ para obter $x_{k-1}$ podemos utilizar $x_0, x_1, &amp;hellip;, x_k$. Ou seja, utilizar os elementos anteriores da sequência&lt;/li>
&lt;li>$(ii)$ $\lim_{n-&amp;gt;\inf} x_n = \xi$ (zero da função)&lt;/li>
&lt;/ul>
&lt;h3 id="critério-de-parada-e-precisão">Critério de parada e precisão &lt;a href="#crit%c3%a9rio-de-parada-e-precis%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;p>Momento em que pararemos a sequência, ou seja, o quão próximo estaremos do zero função. Desta forma, temos 2 definições:&lt;/p></description></item><item><title>Regressão Linear</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/19---regress%C3%A3o-linear/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/19---regress%C3%A3o-linear/</guid><description>&lt;p>$x_{1}, x_{2},\dots,x_{n}$: variáveis independentes
$y$: variável dependente
$y = \alpha_{1}x_{1}+\alpha_{2}x_{2} + \dots + \alpha_{n}x_{n}$&lt;/p>
&lt;p>Por exemplo, obteoms y variável dependente e x variável independente:&lt;/p>
&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>x&lt;/th>
 &lt;th>$x_1$&lt;/th>
 &lt;th>..&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>y&lt;/td>
 &lt;td>$y_{1}$&lt;/td>
 &lt;td>&amp;hellip;&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>$y = a+bx$&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table></description></item><item><title>Representação numérica e análise de erros</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/1---representa%C3%A7%C3%A3o-num%C3%A9rica-e-an%C3%A1lise-de-erros/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/1---representa%C3%A7%C3%A3o-num%C3%A9rica-e-an%C3%A1lise-de-erros/</guid><description>&lt;h2 id="11-conversão-do-sistema-binário-para-decimal">1.1 Conversão do sistema binário para decimal &lt;a href="#11-convers%c3%a3o-do-sistema-bin%c3%a1rio-para-decimal" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Dado um número natural $\beta$, um numero $x$ é escrito na base $\beta$ se $x = a_{n}\beta^n + a_{n-1} \beta^{n-1}+ &amp;hellip; + a_{0} \beta^{0}$
&lt;ul>
&lt;li>Usamos então a notação $x = (a_{n}a_{n-1}&amp;hellip;a_{1}a_{0})_\beta$(polinômio avaliado em $\beta$).&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>Na base 2, se $x = (d_{k}d_{k-1}&amp;hellip;d_{1}d_{0})&lt;em>{2}$, então $x =d&lt;/em>{k}2^{k}+d_{k-1}2^{k-1} +&amp;hellip;+ d_{1}2^{1} + d_{0}2^{0}$ .&lt;/li>
&lt;li>Podemos simplificar a conversão de binário para decimal, colocando a &amp;ldquo;base&amp;rdquo; em evidência (no caso, 2).&lt;/li>
&lt;li>&lt;strong>Exemplo:&lt;/strong> $x = 1\cdot2^{4} + 0\cdot2^{3} + 1\cdot2^{2}+1\cdot2^{1}+1\cdot2^{0}$ -&amp;gt; $x = 2\cdot(2\cdot(2\cdot(1\cdot2^{1}+0)+1)+1)+1$
&lt;ul>
&lt;li>De 15 para 8 operações necessárias&lt;/li>
&lt;li>$a_{4}$: primeiro dígito (1 no exemplo)&lt;/li>
&lt;li>$a_{3} = a_{4} \times 2 + 0 = 2$&lt;/li>
&lt;li>$a_{2} = a_{3} \times 2 + 1 = 5$&lt;/li>
&lt;li>$a_{1} = a_{2} \times 2 + 1 = 11$&lt;/li>
&lt;li>$a_{0} = a_{1} \times 2 + 1 = 23$&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;h3 id="algoritmo">Algoritmo: &lt;a href="#algoritmo" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;p>$x = (d_{k}d_{k-1}&amp;hellip;d_{1}d_{0})&lt;em>{2}$, $d&lt;/em>{k} \in [0,1]$
$A_{k} = d_{k}$
$A_{i} = 2 \times A_{i+1} + d_{i}$ para $i = k-1, &amp;hellip;, 0$
$A_{0}$: número $x$ na base 10&lt;/p></description></item><item><title>RISC X CISC</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/risc-x-cisc/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/risc-x-cisc/</guid><description>&lt;h1 id="cisc">Cisc &lt;a href="#cisc" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>Grandes conjuntos de instruções.&lt;/li>
&lt;li>Mais modos de endereçamento.&lt;/li>
&lt;li>Implementações de hardware de instruções de high level language&lt;/li>
&lt;/ul>
&lt;p>![[/Untitled 8.png|Untitled 8.png]]&lt;/p>
&lt;hr>
&lt;h1 id="chamadas-de-procedimento">Chamadas de procedimento &lt;a href="#chamadas-de-procedimento" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>Muito demorada.&lt;/li>
&lt;li>Depende do número de parâmetros passados.&lt;/li>
&lt;li>Depende do nível de aninhamento.&lt;/li>
&lt;li>Maioria dos programas não faz muitas chamadas seguidas por muitos retornos.&lt;/li>
&lt;li>Maioria das variáveis é local.&lt;/li>
&lt;li>(Compare com localidade de referência)&lt;/li>
&lt;/ul>
&lt;h2 id="arquivo-de-registradores-grande">Arquivo de registradores grande &lt;a href="#arquivo-de-registradores-grande" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Solução de software:
&lt;ul>
&lt;li>Requer que compilador reserve registradores.&lt;/li>
&lt;li>Aloca com base nas variáveis mais usadas em determinado momento.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul>
&lt;h2 id="janela-de-registradores">Janela de Registradores &lt;a href="#janela-de-registradores" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Intervalo limitado de profundidade de chamada.&lt;/li>
&lt;li>Usam múltiplos conjuntos pequenos de registradores.&lt;/li>
&lt;/ul>
&lt;h2 id="operação-de-buffer-circular">Operação de buffer circular &lt;a href="#opera%c3%a7%c3%a3o-de-buffer-circular" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Quando uma chamada é feita, um ponteiro de janela atual é movido para mostrar a janela de registrador atualmente ativa. Se todas as janelas estiverem em uso, uma interrupção é gerada.&lt;/p></description></item><item><title>Sequência (ou cadeia) de Sturm + newton para polinomios</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/10---sequ%C3%AAncia-ou-cadeia-de-sturm-+-newton-para-polinomios/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/10---sequ%C3%AAncia-ou-cadeia-de-sturm-+-newton-para-polinomios/</guid><description>&lt;p>Considere um polinômio $P_{n}(x)$ de grau $n$. Defina a seguinte sequência de polinômios:
$g_{0}(x) = P_{n}(x)$
$g_{1}(x) = P&amp;rsquo;&lt;em>{n}(x)$
e em geral, definimos o termo $g_k(x)$ como sendo resto da divisão $-\frac{g&lt;/em>{k-2}(x)}{g_{k-1}(x)}$
&lt;strong>I.e&lt;/strong>: $g_0/g_1$ = $q_2$, o resto da divisão $r_2$ = $-g_2$, isso de k = 0 até n, só parando quando $g_k$ for um uma constante.&lt;/p>
&lt;p>A sequencia $g_{0}(x), g_{1}(x),.., g_{k}(x), &amp;hellip;$ é chamada de sequência de Sturm.&lt;/p></description></item><item><title>Simulação de Linguagem Assembly x86 para 8086</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/4---simula%C3%A7%C3%A3o-de-linguagem-assembly-x86-para-8086/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/lab.-de-montagem/4---simula%C3%A7%C3%A3o-de-linguagem-assembly-x86-para-8086/</guid><description>&lt;h1 id="1--familia-x86">1- Familia x86 &lt;a href="#1--familia-x86" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Familia de processadores da intel. É importante ver o &lt;strong>asm&lt;/strong> especificamente nessses modelos. Baseada na arquitetura de Von Neumann, com uma [[CPU]] e uma [[Memoria Interna]]/Principal. Baseado, essencialmente em CISC. Vide [[RISC X CISC]];&lt;/p>
&lt;h2 id="registradores">Registradores &lt;a href="#registradores" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>AX - Acumulador (Usado em &lt;strong>operações aritméticas&lt;/strong>)&lt;/li>
&lt;li>CX - Contador (Usado em loops)&lt;/li>
&lt;li>DX - Registrador de Dados (Usado em I/O, multiplicações e divisões)&lt;/li>
&lt;li>BX - Base (usado para apontar referências no segmento de dados).&lt;/li>
&lt;li>SP - Stack Pointer (pilha)&lt;/li>
&lt;li>BP - Apontador da base do frame&lt;/li>
&lt;li>SI - Indice da fonte de dados a copiar (SOURCE INDEX)&lt;/li>
&lt;li>DI - Indice do destino de dados.&lt;/li>
&lt;/ul>
&lt;blockquote>
&lt;p>são dividos em 6 segmentos&lt;/p></description></item><item><title>Sistema operacional</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/6---sistema-operacional/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/organiza%C3%A7%C3%A3o-de-computadores/6---sistema-operacional/</guid><description>&lt;p>[[SO]]&lt;/p></description></item><item><title>Sistemas Lineares</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/11---sistemas-lineares/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/11---sistemas-lineares/</guid><description>&lt;h1 id="operações-elementares-como-operações-matriciais">Operações elementares como operações matriciais &lt;a href="#opera%c3%a7%c3%b5es-elementares-como-opera%c3%a7%c3%b5es-matriciais" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ol>
&lt;li>
&lt;p>Matriz elementar de permutação de linhas&lt;/p>
&lt;ul>
&lt;li>A matriz $P_{i,j}$ que troca as linhas i e j de lugar na matriz identidade $I_{n}= (\delta_{ij})$ é chamada e matriz de permutação nas linhas i e j e, quando multiplicada por uma matriz A à esquerda, ela permuta as linhas i e j de A.&lt;/li>
&lt;li>Obs: $P_{i,j}$ é inversível e $P^{-1} = P_{ij}$&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>
&lt;p>Matriz elementar que multiplica linhas por um numero $\alpha \neq 0$&lt;/p></description></item><item><title>SO</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/so/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/so/</guid><description>&lt;p>Criado para facilitar o uso do sistema computacional&lt;/p>
&lt;h2 id="serviços-de-um-so">Serviços de um SO &lt;a href="#servi%c3%a7os-de-um-so" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Permite a criação de programas com abstraction high level, a unificação de programas e acesso a dispositivos E/S, para os arquivos, ao sistema e detecta erros.&lt;/p>
&lt;ul>
&lt;li>Batch (lotes), único programa e MultiProgramação&lt;/li>
&lt;li>Trabalha com filas de prioridade para execução de tarefas, as quais quanto mais paralelizadas, mais velozes.&lt;/li>
&lt;li>Swapping, SO cria memória virtual na memória externa para utilizar como uma memória principal em casos de processos que estão na fila de longo prazo&lt;/li>
&lt;/ul>
&lt;h2 id="particionamento">Particionamento &lt;a href="#particionamento" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Aglutinação: juntar buracos adjacentes em um grande buraco.&lt;/li>
&lt;li>Compactação: de vez em quando, percorre a memória e move todos os buracos para um bloco&lt;br>
livre (desfragmentação de disco).&lt;/li>
&lt;/ul></description></item><item><title>só no caderno</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/3---s%C3%B3-no-caderno/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/3---s%C3%B3-no-caderno/</guid><description/></item><item><title>Solução de equações não lineares por métodos numéricos</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/5---solu%C3%A7%C3%A3o-de-equa%C3%A7%C3%B5es-n%C3%A3o-lineares-por-m%C3%A9todos-num%C3%A9ricos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/c%C3%A1lculo-num%C3%A9rico/5---solu%C3%A7%C3%A3o-de-equa%C3%A7%C3%B5es-n%C3%A3o-lineares-por-m%C3%A9todos-num%C3%A9ricos/</guid><description>&lt;ul>
&lt;li>vamos ver métodos numéricos p/ resolver equações do tipo
$f(x) = 0$&lt;/li>
&lt;li>onde $f:[a,b]$ reais é uma continua derivável em (a,b)&lt;/li>
&lt;li>$f$ tem derivadas de todas as ordem de $(a,b)$&lt;/li>
&lt;/ul>
&lt;p>Um numero real (ou complexo) $\xi$ é um zero da função $f(x)$ ou uma raiz da equação $f(x) = 0$, ou ainda, uma &lt;em>solução&lt;/em> de $f(x) = 0$, se $f(\xi) = 0$&lt;/p>
&lt;ul>
&lt;li>estamos interessados somente em raízes reais. Deixaremos o caso complexo de fora.&lt;/li>
&lt;/ul>
&lt;h1 id="interpretação-gráfica">Interpretação Gráfica &lt;a href="#interpreta%c3%a7%c3%a3o-gr%c3%a1fica" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;blockquote>
&lt;p>ex. no caderno&amp;hellip;&lt;/p></description></item><item><title>solucao-grafica</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/otimiza%C3%A7%C3%A3o-linear/solucao-grafica/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/otimiza%C3%A7%C3%A3o-linear/solucao-grafica/</guid><description>&lt;h1 id="solução-gráfica-com-2-variáveis">Solução Gráfica com 2 variáveis &lt;a href="#solu%c3%a7%c3%a3o-gr%c3%a1fica-com-2-vari%c3%a1veis" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Maximizar $f(x_1, x_2) = x_1 + 2x_2$
sujeito a:
$x_1 + x_2 \leq 4$
$x_1 \leq 2$
$x_2 \leq 3$
$x_1, x_2 \geq 0$&lt;/p>
&lt;p>Para resolver o problema graficamente, primerio precisamos representar a região factível no plano. A região deste problema é:
$S = {(x_1, x_2) | x_1 + x_2 \leq 4, x_1 \leq 2, x_2 \leq 3, x_1, x_2 \geq 0}$&lt;/p>
&lt;p>A partir da representação, representamos a equação da função objetivo (já que é uma reta) como f(x_1, x_2) = k, onde k é uma constante. Assim, temos:
$x_1 + 2x_2 = k$&lt;/p></description></item><item><title>Teste do Qui-Quadrado</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/10---teste-do-qui-quadrado/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/10---teste-do-qui-quadrado/</guid><description>&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>Observado&lt;/th>
 &lt;th>1&lt;/th>
 &lt;th>&lt;/th>
 &lt;th>&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>ESperado&lt;/td>
 &lt;td>1.1&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>$\sum_{k=1}^{n}\limits\frac{(O_{j}-E_{j})^2}{E_{j}}$&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>$X²$&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>gl = k - 1 (grau de liberade = numero de células - 1)&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table></description></item><item><title>Variáveis Aleatórias</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/8---vari%C3%A1veis-aleat%C3%B3rias/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/8---vari%C3%A1veis-aleat%C3%B3rias/</guid><description>&lt;h1 id="distribuição-de-probabilidade">Distribuição de probabilidade &lt;a href="#distribui%c3%a7%c3%a3o-de-probabilidade" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>é um modelo probabilístico que relaciona os valores de uma variável à probabilidade daquele valor na população.
Iremos relacionar valores que ela pode assumir aos eventos .&lt;/p>
&lt;h1 id="definição">Definição &lt;a href="#defini%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>uma variável aleatória X é uma variável numérica cujo valor é um resultado de um fenômeno aleatório. Tal variável pode ser discreta ou contínua.&lt;/p>
&lt;hr>
&lt;h2 id="distribuições-discretas">Distribuições discretas &lt;a href="#distribui%c3%a7%c3%b5es-discretas" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>modelos relacionados às &lt;strong>variáveis aleatórias discretas&lt;/strong>. Os valores formam um conjunto discreto.&lt;/p></description></item><item><title>Variáveis Aleatórias Contínuas</title><link>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/11---vari%C3%A1veis-aleat%C3%B3rias-cont%C3%ADnuas/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/4-semestre/probabilidade-e-estat%C3%ADstica/11---vari%C3%A1veis-aleat%C3%B3rias-cont%C3%ADnuas/</guid><description>&lt;h1 id="modelo-uniforme">Modelo uniforme &lt;a href="#modelo-uniforme" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Def: Uma variável aleatória X tem distribuição Uniforme no intervalo $[a,b]$ se sua &lt;strong>função densidade&lt;/strong> de probabilidade for dada por:
$$ f(x) \begin{cases}
\frac{1}{b-a} &amp;amp; se &amp;amp; a \leq x\leq b \
\ \ 0, &amp;amp; se &amp;amp; x&amp;lt;a \ ou \ x&amp;gt;b
\end{cases} $$
Notação: $X \eqcirc u(a,b)$
média: $E(X) = \frac{b+a}{2}$
variância: $V(X) = \frac{(b-a)²}{12}$&lt;/p>
&lt;ol>
&lt;li>$f(x) \geq0$&lt;/li>
&lt;li>$\int^{\infty}_{-\infty}\limits{f(x)dx} = 1$&lt;/li>
&lt;li>$f(x) = P(X\leq x)$
&lt;ul>
&lt;li>disclaimer, toda variável contínua $P(X = x) = 0$&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>função de distribuição acumulada = 	$\int^{x}_{-x}\limits{f(x)dx}$&lt;/li>
&lt;/ol>
&lt;h2 id="exercício">Exercício &lt;a href="#exerc%c3%adcio" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ol>
&lt;li>Um ônibus chega dez minutos em um ponto de parada. Assume-me que o tempo de espera para 1 indivíduo é uma v.a com dist. contínua.
a) Qual a P de que o indivíduo espere mais que 10m?
$\int^{10}_{7}\limits{\frac{1}{10}}dx$ = $\frac{3}{10}$&lt;/li>
&lt;/ol>
&lt;p>b) qual a $P(|x-5|\leq2)$? = 0.4&lt;/p></description></item><item><title>. OpenMP</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/programa%C3%A7%C3%A3o-concorrente-e-paralela/aula-5-threads-openmp/2.-openmp/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/programa%C3%A7%C3%A3o-concorrente-e-paralela/aula-5-threads-openmp/2.-openmp/</guid><description>&lt;blockquote>
&lt;p>[!tip] Nao cai na prova&lt;/p>&lt;/blockquote>
&lt;p>API portável para threads em sistemas multiprocessadores de memória compartilhada.&lt;/p>
&lt;p>Padroniza paralelismo em grão fino (laços). Paralelizar parcialmente seções do código que podem ser intensos ao processamento.&lt;/p>
&lt;h2 id="usando-em-c">Usando em C &lt;a href="#usando-em-c" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>

 
 &lt;div class="highlight">&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">&lt;code class="language-c" data-lang="c">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#a6e22e">main&lt;/span> () {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#75715e">#pragma omp parallel for \
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e"> shared(A)private(i)
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">&lt;/span> &lt;span style="color:#66d9ef">for&lt;/span> (i &lt;span style="color:#f92672">=&lt;/span> &lt;span style="color:#ae81ff">1&lt;/span>; i &lt;span style="color:#f92672">&amp;lt;=&lt;/span> &lt;span style="color:#ae81ff">12&lt;/span>; i&lt;span style="color:#f92672">++&lt;/span>) {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> [...]
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> }
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>}&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;p>neste exemplo&lt;/p>
&lt;ul>
&lt;li>A (vetor) é compartilhado entre as $i$ threads geradas&lt;/li>
&lt;li>i (iterador) é privado entre as threads, ou seja, cada valor de $i$ representa uma thread&lt;/li>
&lt;/ul>
&lt;p>Para criar novas threads, o usuário define uma região paralela:&lt;/p></description></item><item><title>. threads</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/programa%C3%A7%C3%A3o-concorrente-e-paralela/aula-5-threads-openmp/1.-threads/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/programa%C3%A7%C3%A3o-concorrente-e-paralela/aula-5-threads-openmp/1.-threads/</guid><description>&lt;blockquote>
&lt;p>[!tip] Nao cai na prova&lt;/p>&lt;/blockquote>
&lt;p>São processos que executam sem a carga de gerenciamento normal.&lt;/p>
&lt;p>Seu uso permite a construção de programas paralelos, mesmo usando apenas uma única máquina (multithreading).&lt;/p>
&lt;p>Usando pthread (padrão posix)&lt;/p>


 
 &lt;div class="highlight">&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">&lt;code class="language-c" data-lang="c">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#66d9ef">pthread_attr_t&lt;/span> atrib;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#66d9ef">pthread_t&lt;/span> &lt;span style="color:#66d9ef">thread&lt;/span>;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#a6e22e">pthread_attr_init&lt;/span>(atrib, PTHREAD_SCOPE_SYSTEM); &lt;span style="color:#75715e">// alterando o escalonamento da thread.
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#a6e22e">pthread_create&lt;/span>(&lt;span style="color:#f92672">&amp;amp;&lt;/span>ident, &lt;span style="color:#f92672">&amp;amp;&lt;/span>atrib, (&lt;span style="color:#66d9ef">void&lt;/span>&lt;span style="color:#f92672">*&lt;/span>)start_func, arg);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#a6e22e">pthread_exit&lt;/span>(ident, ptr_valor); &lt;span style="color:#75715e">// sai da thread 
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#a6e22e">pthread_join&lt;/span>(ident, ptr_valor); &lt;span style="color:#75715e">// espera o termino da thread
&lt;/span>&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div></description></item><item><title>aula 9 bison asdrc</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/extra/bison/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/extra/bison/</guid><description>&lt;h1 id="bison-parser-generator">Bison (parser generator) &lt;a href="#bison-parser-generator" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>Preambulo: declaração dos tokens, artefatos, ordem de precedência e etc.&lt;/li>
&lt;/ul>


 
 &lt;div class="highlight">&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">&lt;code class="language-c" data-lang="c">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#f92672">%&lt;/span>{
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#75715e">#include&lt;/span> &lt;span style="color:#75715e">&amp;lt;stdio.h&amp;gt;&lt;/span>&lt;span style="color:#75715e">
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#f92672">%&lt;/span>}&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;ul>
&lt;li>Gramática (LLR):&lt;/li>
&lt;li>funções: seção de funções auxiliares&lt;/li>
&lt;/ul>
&lt;h2 id="compilação">Compilação &lt;a href="#compila%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>O código Bison deve ser transformado em código C, via comando:&lt;/p>


 
 &lt;div class="highlight">&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">&lt;code class="language-sh" data-lang="sh">&lt;span style="display:flex;">&lt;span>bison -d -v parser.y&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;p>Logo em seguida deve ser compilado via g++&lt;/p>


 
 &lt;div class="highlight">&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">&lt;code class="language-sh" data-lang="sh">&lt;span style="display:flex;">&lt;span>gcc parser.tab.c -lfl &lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;h1 id="integração-com-flex">Integração com flex &lt;a href="#integra%c3%a7%c3%a3o-com-flex" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>parser.tab.c:&lt;/li>
&lt;li>parser.tab.h: podemos incluir no flex&lt;/li>
&lt;li>parser.output: descrição da gramática gerada&lt;/li>
&lt;/ul>


 
 &lt;div class="highlight">&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">&lt;code class="language-c" data-lang="c">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#f92672">%&lt;/span>{
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">#include&lt;/span> &lt;span style="color:#75715e">&amp;#34;parser.tab.h&amp;#34;&lt;/span>&lt;span style="color:#75715e">
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">&lt;/span>&lt;span style="color:#f92672">%&lt;/span>}&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;p>o arquivo flex não terá mais uma função auxiliar main, ou seja, o bison terá que tê-la.&lt;/p></description></item><item><title>Barramentos</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/conceitos/barramentos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/conceitos/barramentos/</guid><description>&lt;p>Dedicado: uso de linhas distintas para endereço, dados e etc..&lt;/p>
&lt;p>Multiplexado: endereço e dados tudo junto ai mesmo e fé pra achar&lt;/p>
&lt;p>Linha de controle, dados e endereço, no geral&lt;/p></description></item><item><title>Conceitos</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/conceitos/conceitos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/conceitos/conceitos/</guid><description>&lt;h2 id="lei-de-moore">Lei de moore &lt;a href="#lei-de-moore" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Até 2014, todo ano se dobrava a quantidade de transistores num processador, o numero baixou para cerca de 18 meses e continua diminuindo&lt;/p>
&lt;h2 id="ciclo-de-instrução">Ciclo de instrução &lt;a href="#ciclo-de-instru%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Calcula endereço de uma nova instrução → busca a instrução → decodifica uma instrução → calcula endereço dos operandos → busca dos operandos → operação → calculo do operando ao final → armazenamento&lt;/p>
&lt;h2 id="interrupções">Interrupções &lt;a href="#interrup%c3%a7%c3%b5es" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>o barramento de controle recebe uma interrupção, que para a execução da instrução atual no próximo clock, salvando seu contexto para uso posterior ao fim da interrupção ou apenas buscando a próxima instrução&lt;/p></description></item><item><title>exemplos</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/programa%C3%A7%C3%A3o-concorrente-e-paralela/aula-7-dist-mem/exemplos/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/programa%C3%A7%C3%A3o-concorrente-e-paralela/aula-7-dist-mem/exemplos/</guid><description>&lt;h1 id="barbeiro-dorminhoco-com-troca-de-mensagens">barbeiro dorminhoco com troca de mensagens &lt;a href="#barbeiro-dorminhoco-com-troca-de-mensagens" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>problema do barbeiro visto em SO, mas com canais&lt;/p>
&lt;p>solucao porca (nossa)
chan bar_in(int), cli_in(int), cli_out(int), bar_out(int);&lt;/p>


 
 &lt;div class="highlight">&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">&lt;code class="language-python" data-lang="python">&lt;span style="display:flex;">&lt;span>process Barber {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> int receba &lt;span style="color:#f92672">=&lt;/span> &lt;span style="color:#ae81ff">0&lt;/span>;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#66d9ef">while&lt;/span> (receba &lt;span style="color:#f92672">!=&lt;/span> EOS) {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> receive bar_in(receba);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> send cli_in(receba)
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> corta()
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> send bar_out(receba)
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> receive cli_out(receba)
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> }
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>}
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>process Clients \[i&lt;span style="color:#f92672">=&lt;/span>&lt;span style="color:#ae81ff">1&lt;/span> to N\] {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#66d9ef">while&lt;/span>(true) {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> int liberado, acabou;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> send bar_in(i);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> receive cli_in(liberado);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#66d9ef">if&lt;/span> (liberado &lt;span style="color:#f92672">!=&lt;/span> i)
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> send cli_in(liberado);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> receive bar_out(acabou);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> send cli_out(acabou);
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> }
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>}&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;hr>
&lt;p>solução Aleardo&lt;/p></description></item><item><title>flex</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/extra/flex/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/compiladores/extra/flex/</guid><description>&lt;p>aula de flex&lt;/p>
&lt;h1 id="padrões-de-expressões-regulares">Padrões de expressões regulares &lt;a href="#padr%c3%b5es-de-express%c3%b5es-regulares" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>POSIX é o padrão, mas o que mais está sendo utilizado é PCRE.&lt;/p>
&lt;ul>
&lt;li>Literais -&amp;gt; example&lt;/li>
&lt;li>Conjuntos [] -&amp;gt; [a-zA-Z] // Na tabela ASCII, existem outros caracteres entre Z e a (como [, , ], ^,_, `)&lt;/li>
&lt;li>Grupos () -&amp;gt; (abc)&lt;/li>
&lt;li>Ancoras ^ $ -&amp;gt; ^example$&lt;/li>
&lt;li>União | -&amp;gt; (let|const)&lt;/li>
&lt;li>Fechamento * (0 ou +) + (positivo) {valor arbitrário} -&amp;gt; (ab)*[c-z]+[[:digit:]] {1, 3}&lt;/li>
&lt;li>Expansão {NAME} -&amp;gt; a{NAME}b (sendo NAME um valor definido pelo usuário)&lt;/li>
&lt;li>Curinga . -&amp;gt; .&lt;/li>
&lt;li>Escape \ -&amp;gt; \.\+\(&lt;/li>
&lt;/ul>
&lt;hr>
&lt;h1 id="flex">Flex &lt;a href="#flex" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>char* yytext
&lt;ul>
&lt;li>string contendo o valor do token atual&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>int yylen
&lt;ul>
&lt;li>tamanho da string do token atual&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>FILE* yyin
&lt;ul>
&lt;li>contem o arquivo de leitura. Por padrao, stdin (console).&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>void yyrestart(FILE* new_file)
&lt;ul>
&lt;li>injeta um novo arquivo dentro de yyin.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>FILE* yyout
&lt;ul>
&lt;li>Contem o arquivo que recebera a saide do programa (padrao stdout).&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>int yylineno
&lt;ul>
&lt;li>Numero da linha atual (precisa de %option yylineno) no preambulo.&lt;/li>
&lt;/ul>
&lt;/li>
&lt;/ul></description></item><item><title>intro+cores</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/computa%C3%A7%C3%A3o-gr%C3%A1fica/aula-1-intro/intro+cores/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/computa%C3%A7%C3%A3o-gr%C3%A1fica/aula-1-intro/intro+cores/</guid><description>&lt;h1 id="ementa">Ementa &lt;a href="#ementa" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;ul>
&lt;li>Dispositivos e sistemas graficos (matriciais e vetoriais)&lt;/li>
&lt;li>Transformacoes geometricas no plano e no espaço&lt;/li>
&lt;li>Rasterização de primitivas gráficas&lt;/li>
&lt;li>Coordenadas homogêneas&lt;/li>
&lt;li>Composições de transformações&lt;/li>
&lt;li>Técnicas para preenchimento de polígonos&lt;/li>
&lt;li>Técnicas de recorte&lt;/li>
&lt;li>Projeções paralelas e cônicas&lt;/li>
&lt;li>Aplicações&lt;/li>
&lt;/ul>
&lt;h1 id="definição---matemática-e-arte">Definição - &amp;ldquo;Matemática e arte&amp;rdquo; &lt;a href="#defini%c3%a7%c3%a3o---matem%c3%a1tica-e-arte" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Segundo a ISO/IEC de 1998 é um conjunto de ferramentas e técnicas com normas e procedimentos usados para converter dados de ou para um dispositivo gráfico.&lt;/p></description></item><item><title>Memórias</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/mem%C3%B3rias/mem%C3%B3rias/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/mem%C3%B3rias/mem%C3%B3rias/</guid><description>&lt;h1 id="definição">Definição &lt;a href="#defini%c3%a7%c3%a3o" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>CARACTERISTICAS&lt;/th>
 &lt;th>&lt;/th>
 &lt;th>&lt;/th>
 &lt;th>&lt;/th>
 &lt;th>&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>Localização&lt;/td>
 &lt;td>Na CPU&lt;/td>
 &lt;td>Interna ao circuito integrado&lt;/td>
 &lt;td>Externa ao circuito integrado&lt;/td>
 &lt;td>&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Capacidade de armazenamento&lt;/td>
 &lt;td>Tamanho de uma palavra&lt;/td>
 &lt;td>Numero de Palavras&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Unidade de transferência&lt;/td>
 &lt;td>Palavra (tamanho do barramento)&lt;/td>
 &lt;td>Bloco (muitas palavras)&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Método de acesso&lt;/td>
 &lt;td>Sequencial&lt;/td>
 &lt;td>Direto&lt;/td>
 &lt;td>Aleatório&lt;/td>
 &lt;td>Associativo&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Desempenho&lt;/td>
 &lt;td>Tempo de acesso&lt;/td>
 &lt;td>Tempo de ciclo&lt;/td>
 &lt;td>Taxa de transferência&lt;/td>
 &lt;td>&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Tipo físico&lt;/td>
 &lt;td>Semicondutor&lt;/td>
 &lt;td>Magnético&lt;/td>
 &lt;td>Óptico&lt;/td>
 &lt;td>Magneto-óptico&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Detalhes físicos&lt;/td>
 &lt;td>Volátil/não volátil&lt;/td>
 &lt;td>Volátil/não volátil&lt;/td>
 &lt;td>&lt;/td>
 &lt;td>&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;h2 id="métodos-de-acesso">Métodos de acesso &lt;a href="#m%c3%a9todos-de-acesso" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>
&lt;p>Sequencial&lt;/p></description></item><item><title>monitores</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/programa%C3%A7%C3%A3o-concorrente-e-paralela/aula-2-monitores/monitores/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/programa%C3%A7%C3%A3o-concorrente-e-paralela/aula-2-monitores/monitores/</guid><description>&lt;h1 id="monitores">Monitores &lt;a href="#monitores" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>É um TAD utilizado para sincronismo, exclusão mutua e etc.
Um monitor exporta $n$ funções através de requisições diretamente à um processo, ou seja, somente um processo é capaz de acessar o monitor por vez.&lt;/p>
&lt;p>&lt;code>Sintaxe&lt;/code>:&lt;/p>


 
 &lt;div class="highlight">&lt;pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;">&lt;code class="language-c" data-lang="c">&lt;span style="display:flex;">&lt;span>monitor mname {
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#75715e">// Declaração de variáveis permanentes
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">&lt;/span> &lt;span style="color:#75715e">// comandos de inicialização
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">&lt;/span> &lt;span style="color:#75715e">// procedimentos do monitor
&lt;/span>&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#75715e">&lt;/span>};&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;ul>
&lt;li>Apenas os &lt;strong>nomes&lt;/strong> e args dos procedimentos são visíveis externamente.&lt;/li>
&lt;li>Comandos de inicialização dos procedimentos não podem acessar variáveis externas ao monitor.&lt;/li>
&lt;li>Variáveis permanentes são inicializadas antes de executar a primeira chamada ao monitor.&lt;/li>
&lt;/ul>
&lt;p>Os procedimentos do monitor são chamadas assim:&lt;/p></description></item><item><title>notas</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/programa%C3%A7%C3%A3o-concorrente-e-paralela/aula-13-hpc/notas/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/programa%C3%A7%C3%A3o-concorrente-e-paralela/aula-13-hpc/notas/</guid><description>&lt;h1 id="hpc-em-sistemas-paralelos-e-distribuídos">HPC em Sistemas Paralelos e Distribuídos &lt;a href="#hpc-em-sistemas-paralelos-e-distribu%c3%addos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Como se pode introduzir computação de alto desempenho (HPC):
- Uso de supercomputadores
- Clusters de computadores
- Uso de grids
- Uso de processadores paralelos massivos (multicores e GPUs) híbridos&lt;/p>
&lt;p>Cada um dos sistemas anteriores se diferenciam por terem arquiteturas diferentes. Cada qual apresenta recursos de hardware e desempenho distintos.&lt;/p>
&lt;p>Possiveis mitigações para o gargalo de Von Neumann:
- Uso de cache
- Uso de pipelines
- Uso de arquiteturas paralelas&lt;/p></description></item><item><title>opengl</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/computa%C3%A7%C3%A3o-gr%C3%A1fica/aula-1-intro/opengl/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/computa%C3%A7%C3%A3o-gr%C3%A1fica/aula-1-intro/opengl/</guid><description>&lt;p>Começaremos com OpenGL (Open Graphics Library). A interface entre o software e o hardware gráfico é feita através de procedimentos disponíveis pela API.&lt;/p>
&lt;p>Opengl é um pacote de um sistema gráfico e usa rotinas de baixo nivel, como:&lt;/p>
&lt;ul>
&lt;li>&amp;lt;GL/freeglut.h&amp;gt;&lt;/li>
&lt;li>glutMainLoop()&lt;/li>
&lt;/ul>
&lt;p>Carrega comandos no buffer de comandos OpenGL, ao inves da ordem imperativa.&lt;/p>
&lt;p>Definicoes:&lt;/p>
&lt;ul>
&lt;li>
&lt;p>glVertex3f(10.0, 8.0, 5.0);&lt;/p>
&lt;ul>
&lt;li>gl: biblioteca&lt;/li>
&lt;li>vertex: nome da funcao&lt;/li>
&lt;li>3: quantidade de variaveis (ou 2 -&amp;gt; 2d)&lt;/li>
&lt;li>f: tipo (float)&lt;/li>
&lt;/ul>
&lt;/li>
&lt;li>
&lt;p>glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);&lt;/p></description></item><item><title>trabalho</title><link>http://docs.codingferpa.org/docs/cs/6-semestre/computa%C3%A7%C3%A3o-gr%C3%A1fica/aula-5/trabalho/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/6-semestre/computa%C3%A7%C3%A3o-gr%C3%A1fica/aula-5/trabalho/</guid><description>&lt;h1 id="trabalho">Trabalho &lt;a href="#trabalho" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>Renderizar em opengl a Central de laboratorio. 27/11&lt;/p></description></item><item><title>Cache</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/mem%C3%B3rias/cache/cache/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/mem%C3%B3rias/cache/cache/</guid><description>&lt;p>Memoria mais rapida existente, usa o tipo fisico SRAM e metodo de acesso associativo.&lt;/p>
&lt;h3 id="localizacao">Localizacao &lt;a href="#localizacao" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;p>Entre a CPU e a memoria principal, separado em L1, L2 e L3&lt;/p>
&lt;p>![[/Untitled 13.png|Untitled 13.png]]&lt;/p>
&lt;h1 id="operacao">Operacao &lt;a href="#operacao" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h1>&lt;p>CPU → solicita conteudo → verifica na cache (se tiver retorna) → (se nao) avanca para principal (por blocos) e o tras por completo a cache → de novo para a CPU&lt;/p>
&lt;p>![[/Untitled 1 6.png|Untitled 1 6.png]]&lt;/p></description></item><item><title>Memoria Interna</title><link>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/mem%C3%B3rias/memoria-interna/memoria-interna/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/cs/3-semestre/arquitetura-de-computadores/mem%C3%B3rias/memoria-interna/memoria-interna/</guid><description>&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>&lt;/th>
 &lt;th>&lt;/th>
 &lt;th>&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>RAM&lt;/td>
 &lt;td>Volatil&lt;/td>
 &lt;td>Acesso aleatorio&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>ROM&lt;/td>
 &lt;td>Nao Volatil&lt;/td>
 &lt;td>Read-only&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>PROM&lt;/td>
 &lt;td>Nao Volatil&lt;/td>
 &lt;td>Read-only (programavel uma vez&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>EPROM&lt;/td>
 &lt;td>Nao Volatil&lt;/td>
 &lt;td>Read-only (programavel e apagavel&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>EEPROM&lt;/td>
 &lt;td>Nao Volatil&lt;/td>
 &lt;td>Read-only (apagavel eletricamente&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Flash&lt;/td>
 &lt;td>Nao Volatil&lt;/td>
 &lt;td>&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;h2 id="dynamic-random-access-memory-dram">Dynamic Random Access Memory (DRAM) &lt;a href="#dynamic-random-access-memory-dram" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Precisa de renovacao energetica&lt;/li>
&lt;li>so funciona ligada / volatil&lt;/li>
&lt;li>Memoria Principal&lt;/li>
&lt;/ul>
&lt;h2 id="static-random-access-memory-sram">Static Random Access Memory (SRAM) &lt;a href="#static-random-access-memory-sram" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;ul>
&lt;li>Nao perde a carga e eh mais rapida&lt;/li>
&lt;li>Mais caro&lt;/li>
&lt;li>cache&lt;/li>
&lt;/ul>
&lt;h2 id="read-only-memory-rom">Read-Only Memory (ROM) &lt;a href="#read-only-memory-rom" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Armazenamento permanente;&lt;/p></description></item><item><title>About</title><link>http://docs.codingferpa.org/docs/about/</link><pubDate>Sun, 23 Mar 2025 11:53:09 -0300</pubDate><guid>http://docs.codingferpa.org/docs/about/</guid><description>&lt;p>&lt;strong>CodingPedia&lt;/strong> é um repositório colaborativo que reúne materiais gratuitos sobre programação, com o objetivo de ajudar desenvolvedores de todos os níveis a aprimorar suas habilidades. Este projeto faz parte da comunidade &lt;strong>&lt;a href="https://codingferpa.org" rel="external" target="_blank">Coding Ferpa&lt;svg width="16" height="16" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">&lt;path fill="currentColor" d="M14 5c-.552 0-1-.448-1-1s.448-1 1-1h6c.552 0 1 .448 1 1v6c0 .552-.448 1-1 1s-1-.448-1-1v-3.586l-7.293 7.293c-.391.39-1.024.39-1.414 0-.391-.391-.391-1.024 0-1.414l7.293-7.293h-3.586zm-9 2c-.552 0-1 .448-1 1v11c0 .552.448 1 1 1h11c.552 0 1-.448 1-1v-4.563c0-.552.448-1 1-1s1 .448 1 1v4.563c0 1.657-1.343 3-3 3h-11c-1.657 0-3-1.343-3-3v-11c0-1.657 1.343-3 3-3h4.563c.552 0 1 .448 1 1s-.448 1-1 1h-4.563z"/>&lt;/svg>&lt;/a>&lt;/strong> e visa compartilhar conhecimento, promover a inclusão digital e fomentar a inovação na área de tecnologia.&lt;/p></description></item><item><title>HowTo</title><link>http://docs.codingferpa.org/docs/howto/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/howto/</guid><description>&lt;p>Contribuir com este projeto é simples e muito bem-vindo! Siga o passo a passo abaixo para começar.&lt;/p>
&lt;h2 id="1-faça-um-fork-do-repositório">1. Faça um Fork do Repositório &lt;a href="#1-fa%c3%a7a-um-fork-do-reposit%c3%b3rio" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Acesse o repositório principal no GitHub e clique em &lt;strong>Fork&lt;/strong> no canto superior direito para criar uma cópia em sua conta.
Se precisar de ajuda com esse processo, confira o &lt;a href="https://docs.github.com/pt/pull-requests/collaborating-with-pull-requests/working-with-forks/fork-a-repo" rel="external" target="_blank">guia oficial do GitHub sobre forks&lt;svg width="16" height="16" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">&lt;path fill="currentColor" d="M14 5c-.552 0-1-.448-1-1s.448-1 1-1h6c.552 0 1 .448 1 1v6c0 .552-.448 1-1 1s-1-.448-1-1v-3.586l-7.293 7.293c-.391.39-1.024.39-1.414 0-.391-.391-.391-1.024 0-1.414l7.293-7.293h-3.586zm-9 2c-.552 0-1 .448-1 1v11c0 .552.448 1 1 1h11c.552 0 1-.448 1-1v-4.563c0-.552.448-1 1-1s1 .448 1 1v4.563c0 1.657-1.343 3-3 3h-11c-1.657 0-3-1.343-3-3v-11c0-1.657 1.343-3 3-3h4.563c.552 0 1 .448 1 1s-.448 1-1 1h-4.563z"/>&lt;/svg>&lt;/a>.&lt;/p></description></item><item><title>RodandoLocalmente</title><link>http://docs.codingferpa.org/docs/rodandolocalmente/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>http://docs.codingferpa.org/docs/rodandolocalmente/</guid><description>&lt;h2 id="rodando-o-projeto-localmente">Rodando o Projeto Localmente &lt;a href="#rodando-o-projeto-localmente" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h2>&lt;p>Se você quer visualizar suas alterações antes de enviar uma contribuição, pode rodar o projeto localmente com apenas um comando.&lt;/p>
&lt;h3 id="pré-requisitos">Pré-requisitos &lt;a href="#pr%c3%a9-requisitos" class="anchor" aria-hidden="true">&lt;i class="material-icons align-middle">link&lt;/i>&lt;/a>&lt;/h3>&lt;p>Antes de começar, certifique-se de que você tem o &lt;a href="https://gohugo.io/getting-started/installing/" rel="external" target="_blank">Hugo&lt;svg width="16" height="16" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">&lt;path fill="currentColor" d="M14 5c-.552 0-1-.448-1-1s.448-1 1-1h6c.552 0 1 .448 1 1v6c0 .552-.448 1-1 1s-1-.448-1-1v-3.586l-7.293 7.293c-.391.39-1.024.39-1.414 0-.391-.391-.391-1.024 0-1.414l7.293-7.293h-3.586zm-9 2c-.552 0-1 .448-1 1v11c0 .552.448 1 1 1h11c.552 0 1-.448 1-1v-4.563c0-.552.448-1 1-1s1 .448 1 1v4.563c0 1.657-1.343 3-3 3h-11c-1.657 0-3-1.343-3-3v-11c0-1.657 1.343-3 3-3h4.563c.552 0 1 .448 1 1s-.448 1-1 1h-4.563z"/>&lt;/svg>&lt;/a> instalado em sua máquina.
Você pode verificar com:&lt;/p></description></item></channel></rss>