All perguntas(coding)

Tenho um conjunto de dados que descreve o número de dias (BedDays) que cada paciente permanece internado em um hospital:

my_df<-data.frame(RecordID=c("1","2","3","4","5","6","7","8","9","10"),
              StartDate=c("2020-03-02","2020-03-05"
                          ,"2020-03-08","2020-03-11"
                          ,"2020-03-14","2020-03-17"
                          ,"2020-03-20","2020-03-23"
                          ,"2020-03-26","2020-03-29"),
              BedDays=c(12,3,2,11,1,10,18,10,3,6))

E gostaria de contar o número de leitos usados ​​a cada dia. Eu gostaria que meus resultados fossem:

Até agora, só consigo pensar no uso de arrays e loops. Use o array para listar as datas em que cada paciente ficou no hospital e, em seguida, use o loop para examinar os arrays e contar os pacientes no hospital em um determinado dia. Esta será a contagem de leitos utilizados em um determinado dia. Isso parece complicado.

Existe alguma função/pacote inteligente que possa fazer essa transformação facilmente?

Como adicionar a barra verde dentro do triângulo como esta foto?

Tentei adicionar um triângulo css, mas não tenho ideia de como escrever a barra verde no triângulo css.

arquivo css:

.triangle {
    width: 0;
    height: 0;
    border-style: solid;
    border-width: 0 0 210px 100vw;
    border-color: transparent transparent #1a202c;
}

código de disposição:

<div className={styles.triangle} />

Problema

Resumindo: estou tentando implementar um structque contenha um retorno de chamada para um encerramento, que captura o estado de forma mutável. A ideia é que o usuário forneça callback (fechamento) e possa ser informado posteriormente quando um evento específico acontecer.

Eu tenho uma versão funcional de prova de conceito ( exemplo de código #1 ).

Este PoC funciona ( exemplo de código nº 1 ):

fn fun<F>(f: F) -> F
    where
        F: FnMut() -> (),
{
    f
}

fn main() {
    let mut abc = "abc".to_string();
    let mut f = fun(|| {
        abc.push_str(".");
        println!("closure: {:?}", abc);
    });
    f();
    f();
    f();
    println!("end: {:?}", abc);
}

Saída:

closure: "abc."
closure: "abc.."
closure: "abc..."
end: "abc..."

Isso falha ( exemplo de código nº 2 ):

A mesma ideia (um pouco diferente) da anterior, mas tentando conter o encerramento dentro Foo.

struct Foo<'a, T> {
    pub cb: Box<dyn FnMut(&T) + 'a>,
}

impl<'a, T> Foo<'a, T> {
    fn new(f: impl FnMut(&T) + 'a) -> Self {
        Self { cb: Box::new(f) }
    }
    fn on_change(&mut self, f: impl FnMut(&T) + 'a)
    {
        self.cb = Box::new(f);
    }
}

impl<'a, T> Default for Foo<'a, T>
{
    fn default() -> Self {
        Self::new(|_| {})
    }
}

fn main() {
    let mut abc = "abc".to_string();
    let mut f = Foo::default();
    f.on_change(|a| {
        abc.push_str("."); // PROBLEM HERE; uncomment and it works!
        println!("- param: {:?}", a);
    });
    let param = "a".to_string();
    (f.cb)(&param);
    (f.cb)(&param);
    (f.cb)(&param);
    println!("end: {:?}", abc);
}

Resultado esperado:

- param: "a"
- param: "a"
- param: "a"
end: "abc..."

Saída real (erro do compilador):

error[E0502]: cannot borrow `abc` as immutable because it is also borrowed as mutable
  --> src/main.rs:33:27
   |
25 |     f.on_change(|a| {
   |                 --- mutable borrow occurs here
26 |         abc.push_str("."); // PROBLEM HERE; uncomment and it works!
   |         --- first borrow occurs due to use of `abc` in closure
...
33 |     println!("end: {:?}", abc);
   |                           ^^^ immutable borrow occurs here
34 | }
   | - mutable borrow might be used here, when `f` is dropped and runs the destructor for type `Foo<'_, String>`

O erro do compilador é bastante claro e definitivamente tem algo a ver com o tempo de vida. Acho que meu problema é que preciso informar ao compilador sobre o fechamento e a vida útil de seus parâmetros - mas a questão é: como?

Como devo modificar o exemplo de código nº 2 para que o registro de retorno de chamada funcione como no exemplo de código nº 1 ?

REPL:

• exemplo de código nº 1
• exemplo de código nº 2

Tenho um dataframe nomeado plot_dfem R com a seguinte estrutura:

# Import the library
library(ggplot2)

# Create a sample data
set.seed(123)
plot_df <- data.frame(gene = rep(paste0("ENSG", 1:10, ".17"), each = 2),
                      mean = rnorm(20, 0.5, 0.1),
                      sd = rnorm(20, 0.02, 0.01),
                      group = rep(c("group_a", "group_b"), 10))

Estou tentando criar um ggplot com pontos e barras de erro, onde o eixo y representa os nomes dos genes (como rótulos discretos), o eixo x representa os valores médios e a cor representa o grupo (ou "group_a" ou " grupo_b"). Aqui está o código que estou usando:

ggplot(plot_df, aes(y=gene)) + 
    geom_point(aes(x=mean, color = group), position = position_dodge(width=0.9)) + 
    geom_errorbar(aes(xmin=mean-sd, xmax=mean+sd, color = group), width=.2,
                 position=position_dodge(.9)) + 
    geom_vline(aes(xintercept=0.5), linetype=2, color = 'gray') + 
    theme_bw() + 
    theme(panel.background = element_blank(),
          panel.grid.major = element_blank(), 
          panel.grid.minor = element_blank())

No entanto, quero alterar a cor de fundo do painel com base nos nomes dos genes no eixo y (cada gene tem uma cor diferente ou os genes vizinhos não têm a mesma cor). Como meus rótulos do eixo y são discretos, não sei como conseguir isso. Qualquer ajuda seria apreciada. Obrigado!

Eu tentei:

Altere a cor de fundo entre dia e noite no ggplot2 em R

Eu tenho um dataframe de dados de expressão onde os genes são linhas e as colunas são amostras. Também tenho um dataframe contendo metadados para cada amostra no dataframe da expressão. Na realidade, meu dataframe expr tem mais de 30.000 linhas e mais de 100 colunas. No entanto, abaixo está um exemplo com dados menores.

expr <- data.frame(sample1 = c(1,2,2,0,0), 
                   sample2 = c(5,2,4,4,0), 
                   sample3 = c(1,2,1,0,1), 
                   sample4 = c(6,5,6,6,7), 
                   sample5 = c(0,0,0,1,1))
rownames(expr) <- paste0("gene",1:5)
meta <- data.frame(sample = paste0("sample",1:5),
                   treatment = c("control","control",
                                 "treatment1", 
                                 "treatment2", "treatment2"))

Quero encontrar a média de cada gene por tratamento. Dos exemplos que vi com split() ou group_by() agrupar pessoas com base em uma coluna já presente no data.frame. No entanto, tenho um dataframe separado (meta) que classifica o agrupamento das colunas em outro dataframe (expr).

Gostaria que minha saída fosse um dataframe com genes como linhas, tratamento como colunas e valores como média.

#        control   treatment1   treatment2
#  gene1  mean        mean         mean
#  gene2  mean        mean         mean

Considere o seguinte código:

struct Foo
{
    typedef bool (*fptr_t)(int);

    operator fptr_t() const
    {
        return _func;
    }

    fptr_t _func;
};

class Wrapper
{
public:
    Wrapper(const Foo&) {}
};


void foo(bool b)
{
}

void foo(Wrapper w)
{
}

int main()
{
    Foo f;
    foo(f);
}

Que não compila com um erro de "chamada ambígua para função sobrecarregada". A meu ver, ambas fooas sobrecargas exigiriam uma conversão definida pelo usuário. Porém para a Wrapperversão, a conversão vai

Foo->(user-defined conversion)Wrapper = exact match

enquanto para a boolversão a conversão vai

Foo->(user-defined conversion)fptr_t->(implicit conversion)bool = exact match

o que requer uma etapa adicional. Além disso, cppreference afirma (embora eu não tenha conseguido encontrar o parágrafo exato do padrão)

Se duas sequências de conversão são indistinguíveis porque têm a mesma classificação, as seguintes regras adicionais se aplicam: 1) A conversão que não envolve ponteiro para bool ou ponteiro para membro para bool é melhor do que aquela que envolve.

o que também parece ser o caso aqui. Então, por que essa chamada ainda é ambígua?

Minha tabela com a calcIncomecoluna calculada:

CREATE TABLE foo
(
    id int, 
    name varchar(100),
    [other columns], 
    calcIncome AS dbo.fn_calcIncome() PERSISTED NOT NULL
)

Consulta:

select * 
from foo
where calcIncome > 100

Mesmo que eu tenha definido calcIncomecomo PERSISTED, esta consulta ainda fn_calcIncomeexige cada linha.

Então, qual é exatamente o propósito de definir uma coluna calculada PERSISTEDse ela se comporta da mesma forma que colunas calculadas não persistentes?

Construindo meu projeto no Alpine Linux (use o musl libc) e recebi um erro do compilador: <sys/unistd.h> não encontrado; musl libc não tem um <sys/unistd.h>. Alterei a linha de inclusão para #include <unistd.h> e ela compila com sucesso (ainda há recursos que não funcionam). Estou curioso sobre as diferenças entre <unistd.h> e <sys/unistd.h>, mas não consigo encontrar nenhuma resposta no Google; há uma pergunta do Stack Overflow sobre diferentes unistd.h, mas todas as respostas nem mencionam nada sobre unistd.h

Eu tenho uma variável fictícia assim:

df <- data.frame(year = seq(1990, 1997, 1),
                 x = c(1, 0, 0, 0, 1, 1, 0, 0))

year  x
1990  1
1991  0
1992  0
1993  0
1994  1
1995  1
1996  0
1997  0

Quero criar uma yigualdade fictícia 1se o valor de xem qualquer um dos três anos anteriores for diferente de zero. O resultado esperado:

year  x   y
1990  1  NA
1991  0  NA
1992  0   1
1993  0   0
1994  1   1
1995  1   1
1996  0   1
1997  0   1

Como eu faço isso? Uma dplyrsolução é preferida.

Dada uma expressão aritmétrica, por exemplo x + y*z, quero convertê-la para add(x, multiply(y, z)).

Encontrei uma função útil aqui :

> getAST <- function(ee) purrr::map_if(as.list(ee), is.call, getAST)
> getAST(quote(x + y*z)) 
[[1]]
`+`

[[2]]
x

[[3]]
[[3]][[1]]
`*`

[[3]][[2]]
y

[[3]][[3]]
z

Pode-se usar rapply(result, as.character, how = "list")para obter caracteres em vez de símbolos.

Como obter add(x, multiply(y, z))deste AST (o resultado)? Isso se torna mais complicado quando há alguns parênteses:

> getAST(quote((x + y) * z)) 
[[1]]
`*`

[[2]]
[[2]][[1]]
`(`

[[2]][[2]]
[[2]][[2]][[1]]
`+`

[[2]][[2]][[2]]
x

[[2]][[2]][[3]]
y



[[3]]
z

Não exijo a resposta, devo usar a getASTfunção. É apenas um caminho possível a seguir.

É claro que no meu caso de uso real as expressões são mais longas.

Aqui está uma solução (eu acho) para o caso em que não há parênteses:

getAST <- function(ee) purrr::map_if(as.list(ee), is.call, getAST)

ast <- rapply(getAST(quote(x + y*z)), as.character, how = "list")

convertAST <- function(ast) {
  op <- switch(
    ast[[1]],
    "+" = "add",
    "-" = "subtract",
    "*" = "multiply",
    "/" = "divide"
  )
  left <- ast[[2]]
  right <- ast[[3]]
  if(is.character(left) && is.character(right)) {
    return(sprintf("%s(%s, %s)", op, left, right))
  }
  if(is.character(left)) {
    return(sprintf("%s(%s, %s)", op, left, convertAST(right)))
  }
  if(is.character(right)) {
    return(sprintf("%s(%s, %s)", op, convertAST(left), right))
  }
  return(sprintf("%s(%s, %s)", op, convertAST(left), convertAST(right)))
}

convertAST(ast)