Tadalafil zeigt eine konstante Resorption im Gastrointestinaltrakt, mit maximalen Plasmaspiegeln nach rund zwei Stunden. Der Wirkstoff verteilt sich gut im Gewebe und weist eine hohe Plasmaproteinbindung auf. Seine lange Halbwertszeit erlaubt eine verlängerte Wirkphase. Der Metabolismus erfolgt über das hepatische Enzymsystem CYP3A4, mit der Bildung inaktiver Metaboliten. Exkretion geschieht primär über den Stuhl. Die Häufigkeit von Nebenwirkungen steigt mit der Dosis, wobei vor allem vasodilatatorische Effekte dominieren. Ein gängiger Bezugspunkt in pharmakologischen Analysen ist cialis ohne rezept, das mit dieser Wirkstoffklasse assoziiert ist.

Fabiomascarenhas.github.io

• Em uma linguagem funcional, uma função é um valor como qualquer outro • Isso quer dizer que funções podem ser passadas como parâmetros para outras funções e retornadas de outras funções • Passagem e retorno de funções nos dá uma ferramenta poderosa para • Funções que recebem ou retornam outras funções são chamadas de funções • Seja uma função que calcula a soma dos inteiros entre a e b: • def somaInt(a: Int, b: Int): Int = if (a > b) 0 else a + • Seja agora uma função que calcula a soma dos quadrados dos inteiros entre a • def somaQuad(a: Int, b: Int): Int = if (a > b) 0 else • Seja agora uma função que soma os fatoriais dos inteiros entre a e b: • def somaFat(a: Int, b: Int): Int = if (a > b) 0 else • Todas essas funções são muito parecidas! Elas são casos especiais de: • def soma(f: Int => Int, a: Int, b: Int): Int = if (a > b) 0 • def somaInt(a: Int, b: Int) = soma(id, a, b) • def somaQuad(a: Int, b: Int) = soma(quadrado, a, b) • def somaFat(a: Int, b: Int) = soma(fat, a, b) • Um tipo A => B é o tipo de uma função que recebe um argumento do tipo A e retorna um resultado de tipo B, logo Int => Int é uma função que recebe um inteiro e retorna um inteiro • Passar funções como parâmetros leva à criação de muitas funções pequenas • Às vezes queremos denotar uma função sem precisar dar um nome para ela • Do mesmo jeito que usamos literais como 2, 3, “foo” e expressões como • Scala fornece uma sintaxe de funções anônimas para isso • Exemplo: uma função que eleva seu argumento ao quadrado: • O termo (x: Int) dá a lista de parâmetros da função anônima, e x * x é o • Em algumas ocasiões o tipo do parâmetro pode ser omitido! • Funções anônimas com vários parâmetros são possíveis: • Podemos definir as funções de somatório usando soma e funções anônimas: • def somaInt(a: Int, b: Int) = soma(x => x, a, b) • def somaQuad(a: Int, b: Int) = soma(x => x * x, a, b) • def somaFat(a: Int, b: Int) = soma(fat, a, b) • Repare que não precisamos dizer o tipo do parâmetro x das funções anônimas, pois o compilador sabe que soma precisa de uma função Int => Int • Se não precisamos dizer o tipo, e a função anônima tem apenas um parâmetro, então podemos omitir os parênteses também • Escreva uma função produto que calcula o produto dos valores de uma função de inteiros para inteiros em determinado intervalo • Escreva a função que calcula o fatorial em termos de produto • É possível generalizar tanto soma quanto produto? • Relembrem as funções de somatório: • def somaInt(a: Int, b: Int) = soma(x => x, a, b) • def somaQuad(a: Int, b: Int) = soma(x => x * x, a, b) • def somaFat(a: Int, b: Int) = soma(fat, a, b) • Reparem que os parâmetros a e b são passados sem mudanças para a função • Podemos nos livrar deles fazendo soma retornar uma função! def soma(f: Int => Int): (Int, Int) => Int = { • Ela agora é uma função que retorna outra função: repare no seu tipo de • Agora podemos redefinir os somatórios como: • def somaInt(a: Int, b: Int) = soma(x => x) • def somaQuad(a: Int, b: Int) = soma(x => x * x) • def somaFat(a: Int, b: Int) = soma(fat) • Podemos até usar soma diretamente: soma(quadrado)(1, 10) • Funções retornando funções são tão comuns em programação funcional que def soma(f: Int => Int)(a: Int, b: Int): Int = if (a > b) 0 else f(a) + soma(f)(a + 1, b) • Esse estilo de uso de funções é chamado de currying, é a maneira normal de definir funções com múltiplos argumentos em algumas linguagens funcionais • Existem linguagens funcionais em que todas as funções recebem apenas um • O tipo de soma é (Int => Int) => (Int, Int) => Int • Em matemática, x é um ponto fixo da função f se f(x) = x • Para algumas funções, uma maneira de achar um ponto fixo é começando com uma estimativa e repetidamente aplicando f: • x, f(x), f(f(x)), f(f(f(x))), f(f(f(f(x)))), .
• Até que a variação entre um valor e o próximo seja pequena o suficiente • A definição do slide anterior nos dá uma receita para escrever uma função Scala que acha um ponto fixo de outra função: def pontoFixo(f: Double => Double)(est: Double): Double = { def suficiente(est1: Double, est2: Double) = • Vamos pensar na especificação da função raiz: • raiz(x) = um número y tal que y * y = x • Dividindo ambos os lados da equação y * y = x por y: • raiz(x) = um número y tal que y = x / y • Ou seja uma raiz quadrada de x é um ponto fixo para a função f(y) = x / y! • def raiz(x: Double) = pontoFixo(y => x / y)(1.0) • def raiz(x: Double) = pontoFixo(y => x / y)(1.0) • Vamos debugar com println e ver o que está acontecendo • A raiz(x) é um número y tal que y = x / y • Se adicionarmos y a ambos os lados da equação e simplificarmos temos: • raiz(x) = um número y tal que y = (y + x / y)/2 • O que acontece se tentamos achar o ponto fixo dessa segunda função em y? • Uma terceira maneira de achar uma raiz quadrada de um número x é achando uma solução da equação y2 - x = 0 • Um método numérico de achar raízes de funções é o método de Newton, que consiste em, para uma equação dada por g(x) = 0, achar o ponto fixo da função: • f(x) = x - g(x)/g’(x), onde g’(x) é a primeira derivada de g(x) • Já temos quase todas as ferramentas, só precisamos da derivada! Mas isso é • g’(x) = (g(x + dx) - g(x)) / dx, para um dx pequeno o bastante

Source: http://fabiomascarenhas.github.io/lp/Aula5.pdf