src/01-dplyr.html

<!DOCTYPE html>
<html lang="" xml:lang="">
  <head>
    <title>dplyr</title>
    <meta charset="utf-8" />
    <meta name="author" content="Alberto Torres Barrán" />
    <meta name="date" content="2020-12-09" />
    <link href="libs/remark-css-0.0.1/default.css" rel="stylesheet" />
    <link rel="stylesheet" href="custom.css" type="text/css" />
  </head>
  <body>
    <textarea id="source">
class: center, middle, inverse, title-slide

# dplyr
## Entornos de Análisis de Datos: R
### Alberto Torres Barrán
### 2020-12-09

---

<script type="text/x-mathjax-config">
MathJax.Hub.Config({
  TeX: {
    Macros: {
      Xcal: "{\\mathcal{X}}",
      Xbf: "{\\mathbf{X}}",
      Qbf: "{\\mathbf{Q}}",
      Zbf: "{\\mathbf{Z}}",
      Vbf: "{\\mathbf{V}}",
      Hbf: "{\\mathbf{H}}",
      Rbb: "{\\mathbb{R}}"
    },
    extensions: ["AMSmath.js","AMSsymbols.js"]
  }
});
</script>


## Introducción

- Implementa una gramática para realizar operaciones básicas con data frames

- Muy eficiente

- Operaciones principales: `slice`, `filter`, `select`, `arrange`, `mutate` y `summarize`

- Estas operaciones se pueden componer para realizar otras más complejas

---

## slice

Selecciona filas por su posición

```r
slice(mpg, 1:5)
## # A tibble: 5 x 11
##   manufacturer model displ  year   cyl trans      drv     cty   hwy fl    class 
##   &lt;chr&gt;        &lt;chr&gt; &lt;dbl&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt;      &lt;chr&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt; &lt;chr&gt; 
## 1 audi         a4      1.8  1999     4 auto(l5)   f        18    29 p     compa~
## 2 audi         a4      1.8  1999     4 manual(m5) f        21    29 p     compa~
## 3 audi         a4      2    2008     4 manual(m6) f        20    31 p     compa~
## 4 audi         a4      2    2008     4 auto(av)   f        21    30 p     compa~
## 5 audi         a4      2.8  1999     6 auto(l5)   f        16    26 p     compa~
```

---

## filter

Selecciona filas por condición

```r
filter(mpg, model == "a4")
## # A tibble: 7 x 11
##   manufacturer model displ  year   cyl trans      drv     cty   hwy fl    class 
##   &lt;chr&gt;        &lt;chr&gt; &lt;dbl&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt;      &lt;chr&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt; &lt;chr&gt; 
## 1 audi         a4      1.8  1999     4 auto(l5)   f        18    29 p     compa~
## 2 audi         a4      1.8  1999     4 manual(m5) f        21    29 p     compa~
## 3 audi         a4      2    2008     4 manual(m6) f        20    31 p     compa~
## 4 audi         a4      2    2008     4 auto(av)   f        21    30 p     compa~
## 5 audi         a4      2.8  1999     6 auto(l5)   f        16    26 p     compa~
## 6 audi         a4      2.8  1999     6 manual(m5) f        18    26 p     compa~
## 7 audi         a4      3.1  2008     6 auto(av)   f        18    27 p     compa~
```

---

## Operadores lógicos

- R implementa todos los operadores relacionales habituales `&gt;, &lt;, &gt;=, &lt;=, ==, !=`

- Los operadores lógicos son la negación `!`, and `&amp;` y or `|`

- El resultado de todas estas operaciones son valores lógicos `TRUE` (`T`) o `FALSE` (`F`)

---

## filter (cont.)

- Se pueden combinar multiples condiciones separadas por `,` (and lógico)
    
    ```r
    filter(mpg, model == "a4", cyl &gt;= 5)
    ```

- También se puede usar explicitamente el operador
    
    ```r
    filter(mpg, model == "a4" &amp; cyl &gt;= 5)
    ```

- En el caso del or lógico es obligatorio el uso del operador
    
    ```r
    filter(mpg, model == "a4" | model == "mustang")
    ```

---

## Variantes de slice

- [Referencia](https://dplyr.tidyverse.org/reference/slice.html)

- Seleccionar las 5 primeras filas
    
    ```r
    slice_head(mpg, n = 5)
    ## # A tibble: 5 x 11
    ##   manufacturer model displ  year   cyl trans      drv     cty   hwy fl    class 
    ##   &lt;chr&gt;        &lt;chr&gt; &lt;dbl&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt;      &lt;chr&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt; &lt;chr&gt; 
    ## 1 audi         a4      1.8  1999     4 auto(l5)   f        18    29 p     compa~
    ## 2 audi         a4      1.8  1999     4 manual(m5) f        21    29 p     compa~
    ## 3 audi         a4      2    2008     4 manual(m6) f        20    31 p     compa~
    ## 4 audi         a4      2    2008     4 auto(av)   f        21    30 p     compa~
    ## 5 audi         a4      2.8  1999     6 auto(l5)   f        16    26 p     compa~
    ```
    
- Seleccionar el top n de acuerdo al valor de una columna
    
    ```r
    slice_max(mpg, hwy, n = 1)
    ## # A tibble: 2 x 11
    ##   manufacturer model   displ  year   cyl trans   drv     cty   hwy fl    class  
    ##   &lt;chr&gt;        &lt;chr&gt;   &lt;dbl&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt;   &lt;chr&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt; &lt;chr&gt;  
    ## 1 volkswagen   jetta     1.9  1999     4 manual~ f        33    44 d     compact
    ## 2 volkswagen   new be~   1.9  1999     4 manual~ f        35    44 d     subcom~
    ```


---

## select

Seleccionar variables (columnas) de un data frame

```r
select(mpg, model, displ, cyl)
## # A tibble: 234 x 3
##    model      displ   cyl
##    &lt;chr&gt;      &lt;dbl&gt; &lt;int&gt;
##  1 a4           1.8     4
##  2 a4           1.8     4
##  3 a4           2       4
##  4 a4           2       4
##  5 a4           2.8     6
##  6 a4           2.8     6
##  7 a4           3.1     6
##  8 a4 quattro   1.8     4
##  9 a4 quattro   1.8     4
## 10 a4 quattro   2       4
## # ... with 224 more rows
```

---

## Ignorar variables

Con un `-` se ignoran variables

```r
select(mpg, -manufacturer)
## # A tibble: 234 x 10
##    model      displ  year   cyl trans      drv     cty   hwy fl    class  
##    &lt;chr&gt;      &lt;dbl&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt;      &lt;chr&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt; &lt;chr&gt;  
##  1 a4           1.8  1999     4 auto(l5)   f        18    29 p     compact
##  2 a4           1.8  1999     4 manual(m5) f        21    29 p     compact
##  3 a4           2    2008     4 manual(m6) f        20    31 p     compact
##  4 a4           2    2008     4 auto(av)   f        21    30 p     compact
##  5 a4           2.8  1999     6 auto(l5)   f        16    26 p     compact
##  6 a4           2.8  1999     6 manual(m5) f        18    26 p     compact
##  7 a4           3.1  2008     6 auto(av)   f        18    27 p     compact
##  8 a4 quattro   1.8  1999     4 manual(m5) 4        18    26 p     compact
##  9 a4 quattro   1.8  1999     4 auto(l5)   4        16    25 p     compact
## 10 a4 quattro   2    2008     4 manual(m6) 4        20    28 p     compact
## # ... with 224 more rows
```

---

## Rangos

Puesto que las variables están ordenadas, se puede seleccionar un rango con `:`


```r
select(mpg, model:trans)
## # A tibble: 234 x 5
##    model      displ  year   cyl trans     
##    &lt;chr&gt;      &lt;dbl&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt;     
##  1 a4           1.8  1999     4 auto(l5)  
##  2 a4           1.8  1999     4 manual(m5)
##  3 a4           2    2008     4 manual(m6)
##  4 a4           2    2008     4 auto(av)  
##  5 a4           2.8  1999     6 auto(l5)  
##  6 a4           2.8  1999     6 manual(m5)
##  7 a4           3.1  2008     6 auto(av)  
##  8 a4 quattro   1.8  1999     4 manual(m5)
##  9 a4 quattro   1.8  1999     4 auto(l5)  
## 10 a4 quattro   2    2008     4 manual(m6)
## # ... with 224 more rows
```

---

## Predicados lógicos en select

- A partir de la versión 1.0 de dplyr, [`select`](https://dplyr.tidyverse.org/dev/reference/select.html) también acepta predicados lógicos
    
    ```r
    select(mpg, is.numeric)
    ## # A tibble: 234 x 5
    ##    displ  year   cyl   cty   hwy
    ##    &lt;dbl&gt; &lt;int&gt; &lt;int&gt; &lt;int&gt; &lt;int&gt;
    ##  1   1.8  1999     4    18    29
    ##  2   1.8  1999     4    21    29
    ##  3   2    2008     4    20    31
    ##  4   2    2008     4    21    30
    ##  5   2.8  1999     6    16    26
    ##  6   2.8  1999     6    18    26
    ##  7   3.1  2008     6    18    27
    ##  8   1.8  1999     4    18    26
    ##  9   1.8  1999     4    16    25
    ## 10   2    2008     4    20    28
    ## # ... with 224 more rows
    ```

---

## Funciones auxiliares

Las siguientes funciones se pueden usar dentro de `select()`

- `starts_with()`: empiezan con un prefijo
- `ends_with()`: terminan con un sufijo
- `contains()`: contienen una string
- `matches()`: concuerdan con una expresión regular
- `num_range()`: rango numérico como "X01", "X02", "X03"
- `any_of`, selecciona las variables contenidas en un vector de cadenas
- `all_of`, igual que la anterior pero da un error si no están todas las variables


```r
vars &lt;- c("cyl", "cty", "mpg")
select(mpg, any_of(vars)) %&gt;%
  head(5)
## # A tibble: 5 x 2
##     cyl   cty
##   &lt;int&gt; &lt;int&gt;
## 1     4    18
## 2     4    21
## 3     4    20
## 4     4    21
## 5     6    16
```


```r
select(mpg, all_of(vars))
## Error: Can't subset columns that don't exist.
## [31mx[39m Column `mpg` doesn't exist.
```

---

## Combinar múltiples selecciones

* Se pueden utilizar los operadores `&amp;`, `|` y `!` para combinar múltiples selecciones:
    
    ```r
    # Variables numéricas excepto cyl y year
    select(mpg, is.numeric &amp; !c(cyl, year)) %&gt;%
      head(5)
    ## # A tibble: 5 x 3
    ##   displ   cty   hwy
    ##   &lt;dbl&gt; &lt;int&gt; &lt;int&gt;
    ## 1   1.8    18    29
    ## 2   1.8    21    29
    ## 3   2      20    31
    ## 4   2      21    30
    ## 5   2.8    16    26
    ```
    
    ```r
    # Contienen "y" o empiezan por "f"
    select(mpg, contains("y") | starts_with("f")) %&gt;%
      head(5)
    ## # A tibble: 5 x 5
    ##    year   cyl   cty   hwy fl   
    ##   &lt;int&gt; &lt;int&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt;
    ## 1  1999     4    18    29 p    
    ## 2  1999     4    21    29 p    
    ## 3  2008     4    20    31 p    
    ## 4  2008     4    21    30 p    
    ## 5  1999     6    16    26 p
    ```

---

## arrange

Ordena las filas de un data frame

```r
arrange(mpg, desc(year), cyl)
## # A tibble: 234 x 11
##    manufacturer model   displ  year   cyl trans   drv     cty   hwy fl    class 
##    &lt;chr&gt;        &lt;chr&gt;   &lt;dbl&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt;   &lt;chr&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt; &lt;chr&gt; 
##  1 audi         a4        2    2008     4 manual~ f        20    31 p     compa~
##  2 audi         a4        2    2008     4 auto(a~ f        21    30 p     compa~
##  3 audi         a4 qua~   2    2008     4 manual~ 4        20    28 p     compa~
##  4 audi         a4 qua~   2    2008     4 auto(s~ 4        19    27 p     compa~
##  5 chevrolet    malibu    2.4  2008     4 auto(l~ f        22    30 r     midsi~
##  6 honda        civic     1.8  2008     4 manual~ f        26    34 r     subco~
##  7 honda        civic     1.8  2008     4 auto(l~ f        25    36 r     subco~
##  8 honda        civic     1.8  2008     4 auto(l~ f        24    36 c     subco~
##  9 honda        civic     2    2008     4 manual~ f        21    29 p     subco~
## 10 hyundai      sonata    2.4  2008     4 auto(l~ f        21    30 r     midsi~
## # ... with 224 more rows
```

---

## mutate

Añade nuevas variables (columnas) al data frame como combinación de las ya existentes

```r
mutate(mpg, avg_mpg = (cty+hwy)/2)
## # A tibble: 234 x 12
##    manufacturer model displ  year   cyl trans drv     cty   hwy fl    class
##    &lt;chr&gt;        &lt;chr&gt; &lt;dbl&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt; &lt;chr&gt; &lt;int&gt; &lt;int&gt; &lt;chr&gt; &lt;chr&gt;
##  1 audi         a4      1.8  1999     4 auto~ f        18    29 p     comp~
##  2 audi         a4      1.8  1999     4 manu~ f        21    29 p     comp~
##  3 audi         a4      2    2008     4 manu~ f        20    31 p     comp~
##  4 audi         a4      2    2008     4 auto~ f        21    30 p     comp~
##  5 audi         a4      2.8  1999     6 auto~ f        16    26 p     comp~
##  6 audi         a4      2.8  1999     6 manu~ f        18    26 p     comp~
##  7 audi         a4      3.1  2008     6 auto~ f        18    27 p     comp~
##  8 audi         a4 q~   1.8  1999     4 manu~ 4        18    26 p     comp~
##  9 audi         a4 q~   1.8  1999     4 auto~ 4        16    25 p     comp~
## 10 audi         a4 q~   2    2008     4 manu~ 4        20    28 p     comp~
## # ... with 224 more rows, and 1 more variable: avg_mpg &lt;dbl&gt;
```

---

## Operadores y funciones aritméticas

- R implementa los operadores aritméticos habituales 
    + suma `+`
    + resta `-`
    + multiplicación `*`
    + división `/`
    + exponenciación `^`
    + división entera `%/%`
    + módulo (resto) `%%`

- También las funciones aritméticas comunes: `log()`, `exp()`, `sin()`, `cos()`, `tan()`, `cumsum()`, `cumprod()`, `abs()`, `sqrt()`, `round()`, `ceiling()`, `floor()`, `trunc()`, ...

- Operan sobre vectores (columnas de un data frame) elemento a elemento

---

## Funciones vectoriales

.center[
![:scale 70%](img/mutate_funciones2.png)
]

---

## summarize

- Reduce (resume) los valores de una columna en un único valor.

- Se pueden realizar múltiples operaciones separadas por ','
    
    ```r
    summarize(mpg, max_cyl = max(cyl), avg_cty = mean(cty), min_year = min(year))
    ## # A tibble: 1 x 3
    ##   max_cyl avg_cty min_year
    ##     &lt;int&gt;   &lt;dbl&gt;    &lt;int&gt;
    ## 1       8    16.9     1999
    ```

- Algunas de las funciones de agregacion pueden operar sobre varias columnas
    
    ```r
    summarize(mpg, pares_distintos = n_distinct(cyl, cty), maxim = max(cyl, cty))
    ## # A tibble: 1 x 2
    ##   pares_distintos maxim
    ##             &lt;int&gt; &lt;int&gt;
    ## 1              33    35
    ```

- El resultado es siempre un dataframe

---

## Funciones de agregación

- Las funciones más comunes para usar dentro de `summarize()` son: 
    + Aritméticas: `prod()`, `sum()`
    + Centralidad: `mean()`, `median()`
    + Dispersión: `sd()`, `var()`, `mad()`
    + Rango: `max()`, `min()`, `quantile()`
    + Posición: `first()`, `last()`, `nth()`
    + Lógicas: `any()`, `all()`
    + *Conteo*: `n()`, `n_distinct()`
      - Solo se pueden usar dentro de `summarize()`
      - `n()` no recibe argumentos, `n_distinct()` el nombre de la(s) columna(s).
    
- Todas reducen un vector de números a un único resultado.

.center[
![](img/summary_function.png)
]

---

## Comprobar versión paquetes

.center[
![:scale 90%](img/dplyr_version.png)

]

---

## Funciones que devuelven múltiples valores

- Desde la versión 1.0 de dplyr, `summarize` acepta funciones que devuelven más de un valor
    
    ```r
    summarize(mpg, rango = range(cty), cuant = quantile(displ, c(0.25, 0.75)))
    ## # A tibble: 2 x 2
    ##   rango cuant
    ##   &lt;int&gt; &lt;dbl&gt;
    ## 1     9   2.4
    ## 2    35   4.6
    ```

- Se crean tantas filas como valores devuelven las operaciones y tantas columnas como operaciones

- No confundir con las funciones vectoriales que se usan principalmente dentro de `mutate`

---

## Errores comunes

- Se pueden mezclar funciones que devuelven un valor con funciones que devuelven varios
    
    ```r
    summarize(mpg, min = min(cyl), qs = quantile(displ, c(0.25, 0.5, 0.75)))
    ## # A tibble: 3 x 2
    ##     min    qs
    ##   &lt;int&gt; &lt;dbl&gt;
    ## 1     4   2.4
    ## 2     4   3.3
    ## 3     4   4.6
    ```
    
- Ojo con mezclar funciones que devuelven distinto número de valores (aparte de 1)
    
    ```r
    summarize(mpg, rango = range(cyl), qs = quantile(displ, c(0.25, 0.5, 0.75)))
    ## Error: Problem with `summarise()` input `qs`.
    ## x Input `qs` must be size 2 or 1, not 3.
    ## i An earlier column had size 2.
    ## i Input `qs` is `quantile(displ, c(0.25, 0.5, 0.75))`.
    ```

---

## Concatenación de funciones

- Todas las funciónes de `dplyr` toman como primer argumento un data frame y devuelven otro data frame

- Se pueden aplicar de manera consecutiva:
    
    ```r
    arrange(select(filter(mpg, model == "a4"), model, year), year)
    
    arrange(
      select(
        filter(mpg, model == "a4"), 
        model, year
      ), 
      year
    )
    ```

---

## Concatenación de funciones (cont.)

- Otra opción:
    
    ```r
    df1 &lt;- filter(mpg, model == "a4")
    df2 &lt;- select(df1, model, year)
    df3 &lt;- arrange(df2, year)
    ```

- Habitualmente no nos interesan los valores intermedios, solo el resultado final

---

## Operador "tubería" (*pipe*)

- La sintaxis es `%&gt;%`

- El codigo `df %&gt;% foo()` es equivalente a `foo(df)`

- Esto permite concatenar funciones sin almacenar resultados intermedios y siguiendo el orden lógico

- Comparación:

.pull-left[

```r
# Opción 1
arrange(
  select(
    filter(mpg, model == "a4"), 
    model, year
  ), 
  year
)

# Opción 2
df1 &lt;- filter(mpg, model == "a4")
df2 &lt;- select(df1, model, year)
df3 &lt;- arrange(df2, year)
```
]
.pull-right[
    
    ```r
    # Operador tuberia
    mpg %&gt;%
      filter(model == "a4") %&gt;%
      select(model, year) %&gt;%
      arrange(year)
    ```
]
    </textarea>
<style data-target="print-only">@media screen {.remark-slide-container{display:block;}.remark-slide-scaler{box-shadow:none;}}</style>
<script src="https://remarkjs.com/downloads/remark-latest.min.js"></script>
<script src="macros.js"></script>
<script>var slideshow = remark.create({
"highlightStyle": "github",
"highlightLines": true,
"countIncrementalSlides": false
});
if (window.HTMLWidgets) slideshow.on('afterShowSlide', function (slide) {
  window.dispatchEvent(new Event('resize'));
});
(function(d) {
  var s = d.createElement("style"), r = d.querySelector(".remark-slide-scaler");
  if (!r) return;
  s.type = "text/css"; s.innerHTML = "@page {size: " + r.style.width + " " + r.style.height +"; }";
  d.head.appendChild(s);
})(document);

(function(d) {
  var el = d.getElementsByClassName("remark-slides-area");
  if (!el) return;
  var slide, slides = slideshow.getSlides(), els = el[0].children;
  for (var i = 1; i < slides.length; i++) {
    slide = slides[i];
    if (slide.properties.continued === "true" || slide.properties.count === "false") {
      els[i - 1].className += ' has-continuation';
    }
  }
  var s = d.createElement("style");
  s.type = "text/css"; s.innerHTML = "@media print { .has-continuation { display: none; } }";
  d.head.appendChild(s);
})(document);
// delete the temporary CSS (for displaying all slides initially) when the user
// starts to view slides
(function() {
  var deleted = false;
  slideshow.on('beforeShowSlide', function(slide) {
    if (deleted) return;
    var sheets = document.styleSheets, node;
    for (var i = 0; i < sheets.length; i++) {
      node = sheets[i].ownerNode;
      if (node.dataset["target"] !== "print-only") continue;
      node.parentNode.removeChild(node);
    }
    deleted = true;
  });
})();
(function() {
  "use strict"
  // Replace <script> tags in slides area to make them executable
  var scripts = document.querySelectorAll(
    '.remark-slides-area .remark-slide-container script'
  );
  if (!scripts.length) return;
  for (var i = 0; i < scripts.length; i++) {
    var s = document.createElement('script');
    var code = document.createTextNode(scripts[i].textContent);
    s.appendChild(code);
    var scriptAttrs = scripts[i].attributes;
    for (var j = 0; j < scriptAttrs.length; j++) {
      s.setAttribute(scriptAttrs[j].name, scriptAttrs[j].value);
    }
    scripts[i].parentElement.replaceChild(s, scripts[i]);
  }
})();
(function() {
  var links = document.getElementsByTagName('a');
  for (var i = 0; i < links.length; i++) {
    if (/^(https?:)?\/\//.test(links[i].getAttribute('href'))) {
      links[i].target = '_blank';
    }
  }
})();
// adds .remark-code-has-line-highlighted class to <pre> parent elements
// of code chunks containing highlighted lines with class .remark-code-line-highlighted
(function(d) {
  const hlines = d.querySelectorAll('.remark-code-line-highlighted');
  const preParents = [];
  const findPreParent = function(line, p = 0) {
    if (p > 1) return null; // traverse up no further than grandparent
    const el = line.parentElement;
    return el.tagName === "PRE" ? el : findPreParent(el, ++p);
  };

  for (let line of hlines) {
    let pre = findPreParent(line);
    if (pre && !preParents.includes(pre)) preParents.push(pre);
  }
  preParents.forEach(p => p.classList.add("remark-code-has-line-highlighted"));
})(document);</script>

<script>
slideshow._releaseMath = function(el) {
  var i, text, code, codes = el.getElementsByTagName('code');
  for (i = 0; i < codes.length;) {
    code = codes[i];
    if (code.parentNode.tagName !== 'PRE' && code.childElementCount === 0) {
      text = code.textContent;
      if (/^\\\((.|\s)+\\\)$/.test(text) || /^\\\[(.|\s)+\\\]$/.test(text) ||
          /^\$\$(.|\s)+\$\$$/.test(text) ||
          /^\\begin\{([^}]+)\}(.|\s)+\\end\{[^}]+\}$/.test(text)) {
        code.outerHTML = code.innerHTML;  // remove <code></code>
        continue;
      }
    }
    i++;
  }
};
slideshow._releaseMath(document);
</script>
<!-- dynamically load mathjax for compatibility with self-contained -->
<script>
(function () {
  var script = document.createElement('script');
  script.type = 'text/javascript';
  script.src  = 'https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-MML-AM_CHTML';
  if (location.protocol !== 'file:' && /^https?:/.test(script.src))
    script.src  = script.src.replace(/^https?:/, '');
  document.getElementsByTagName('head')[0].appendChild(script);
})();
</script>
  </body>
</html>