All perguntas(coding)

Tenho alguns problemas com which.mina função dentro de um pipe dplyr. Tenho um problema solution (*)e estou procurando uma maneira mais compacta e elegante de fazer isso.

1. exemplo reproduzível

library(dplyr)

data=data.frame(s1=c(10,NA,5,NA,NA),s2=c(8,NA,NA,4,20),s3=c(NA,NA,2,NA,10))
data
#>   s1 s2 s3
#> 1 10  8 NA
#> 2 NA NA NA
#> 3  5 NA  2
#> 4 NA  4 NA
#> 5 NA 20 10

2. Valor mínimo:

aqui com min(x,na.rm=TRUE)eu poderia extrair o valor mínimo

data%>%
  rowwise()%>%
  mutate(Min_s=min(c(s1,s2,s3),na.rm=TRUE))
#> Warning: There was 1 warning in `mutate()`.
#> ℹ In argument: `Min_s = min(c(s1, s2, s3), na.rm = TRUE)`.
#> ℹ In row 2.
#> Caused by warning in `min()`:
#> ! no non-missing arguments to min; returning Inf
#> # A tibble: 5 × 4
#> # Rowwise: 
#>      s1    s2    s3 Min_s
#>   <dbl> <dbl> <dbl> <dbl>
#> 1    10     8    NA     8
#> 2    NA    NA    NA   Inf
#> 3     5    NA     2     2
#> 4    NA     4    NA     4
#> 5    NA    20    10    10

3. extraindo variável contendo min val:

Aqui estou tendo problemas para extrair qual variável contém o valor mínimo

data%>%
  rowwise()%>%
  mutate(which_s=which.min(c(s1,s2,s3)))
#> Error in `mutate()`:
#> ℹ In argument: `which_s = which.min(c(s1, s2, s3))`.
#> ℹ In row 2.
#> Caused by error:
#> ! `which_s` must be size 1, not 0.
#> ℹ Did you mean: `which_s = list(which.min(c(s1, s2, s3)))` ?

# Solution (*)
data%>%
  rowwise()%>%
  mutate(which_s=if(!is.na(s1)|!is.na(s2)|!is.na(s3)) {which.min(c(s1,s2,s3))} else NA )
#> # A tibble: 5 × 4
#> # Rowwise: 
#>      s1    s2    s3 which_s
#>   <dbl> <dbl> <dbl>   <int>
#> 1    10     8    NA       2
#> 2    NA    NA    NA      NA
#> 3     5    NA     2       3
#> 4    NA     4    NA       2
#> 5    NA    20    10       3

^{Criado em 2024-11-07 com reprex v2.1.0}

Eu uso polarsdataframes (novo neste módulo) e estou usando alguma tipagem estática, para manter meu código arrumado e limpo para fins de depuração, e para permitir a conclusão automática de métodos e atributos no meu editor. Tudo vai bem.

No entanto, ao plotar coisas a partir de dataframes com a altairAPI, conforme mostrado no documento, não consigo encontrar o tipo do objeto retornado em polars.

import polars as pl
import typing as tp
data = {"a": [0,0,0,0,1,1,1,2,2,3]}

df = pl.DataFrame(data)


def my_plot(df: pl.DataFrame, col: str) -> tp.Any:
    """Plot an histogram of the distribution of values of df[col]"""
    return df[col].value_counts(
        ).plot.bar(
            y="count",
            x=col
        ).properties(
            width=400,
        )

u = my_plot(df, "a")

u.show()

Como eu digito a saída dessa função? O documento afirma que a saída de (...).ploté um DataFramePlotobjeto, mas não há informações sobre esse tipo, e de qualquer forma eu estou usando a saída de (...).plot.bar(...)que tem um tipo diferente.

Se eu executar type(u), obtenho altair.vegalite.v5.api.Chart, mas parece duvidoso usar isso para tipagem estática, e não quero importar altairno meu código, pois os altairmétodos que preciso já estão incluídos em polars.

Não consegui encontrar nenhuma informação sobre isso, então qualquer ajuda é bem-vinda

Obrigado!

Tenho um conjunto de hashes que quero tornar anônimos. Usando o GNU sed (v4.9), como posso substituir apenas partes do hash por outra coisa? Especificamente para o meu caso, quero preservar o $símbolo se ele existir, mas apenas se estiver diretamente na frente do :.

Exemplo:

USER:1234:aad3b435b:abcdef:::
COMPUTER$:4321:aad3b435b:abcdef:::
DOMAIN\bleh:5678:eaad3b4:fedcba:::
DOMAIN\$why:5678:eaad3b4:fedcba:::

Usando o seguinte comando, quase consigo obter o que quero

sed 's/[^$:]\+/REDACTED/1'

REDACTED:1234:aad3b435b:abcdef:::
REDACTED$:4321:aad3b435b:abcdef:::
REDACTED:5678:eaad3b4:fedcba:::
REDACTED$why:5678:eaad3b4:fedcba:::

No entanto, como pode ser visto, esta expressão regular sed corresponde à última entrada incorretamente. Em vez disso, deveria ser

REDACTED:5678:eaad3b4:fedcba:::

O comando sed deve substituir qualquer coisa entre o início da linha ^e $:OR :.

Não sei o que estou fazendo errado. Tentei e tentei fazer a cláusula "or" funcionar corretamente usando agrupamento e lookahead/behind e caracteres de escape, mas não consigo obter o resultado que quero. Pelo que entendi, o sed usa regex básico por padrão, mas não consigo encontrar a solução usando -Eor -rtambém...

Fiquei me perguntando por que isso acontecia, já que ia contra o que eu esperava. Isso tem a ver com como os tipos Nullable Genéricos são interpretados em C#.

  public static int? MyFunction(){
    return default;
  }

  public static T MyFunctionGeneric<T>() {
    return default;
  }

  public static T? MyFunctionGenericNullable<T>(){
    return default;
  }

  public static void main(string[] args){
    Console.WriteLine(MyFunction());
    Console.WriteLine(MyFunctionGeneric<int?>());
    Console.WriteLine(MyFunctionGenericNullable<int>());
  }

Como esperado, quando defino o tipo de retorno, int?o valor retornado padrão é null.

Este também é o caso quando defino um genérico que retorna seu próprio tipo, porque int?quando é passado, o valor retornado padrão é null.

No entanto, no terceiro caso, embora o tipo de retorno seja tecnicamente int?, o valor padrão retornado é 0. Eu teria que passar in int?como meu parâmetro de tipo para obter uma nullresposta. Note que isso acontece mesmo quando eu declaro explicitamentereturn default(T?)

Isso é um pouco inesperado. Alguém tem uma explicação para isso?

Tenho trabalhado em uma implementação Future em Rust, e encontrei um comportamento que não entendo completamente. Especificamente, estou usando std::sync::mpsc::Receiverdentro do pollmétodo, e estou tentando decidir entre while lete if letpara receber mensagens.

Aqui está a versão simplificada do meu método de enquete:

fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
    let this = self.get_mut();

    // Option 1: Using `while let`
    while let Ok(new_attributes) = this.receiver.try_recv() {
        // Process the message
    }

    // Option 2: Using `if let`
    if let Ok(new_attributes) = this.receiver.try_recv() {
        // Process the message
    }

    Poll::Pending
}

O que eu observei

Quando uso while let, tudo parece funcionar como esperado: o Future é re-polled quando novas mensagens chegam. No entanto, quando uso if let, o Future parece travar e nunca mais acorda, mesmo quando novas mensagens estão disponíveis.

Meu Entendimento

Eu sei que o Waker deve ser usado para notificar o executor de que o Future deve ser re-pesquisado. Dado que minha função de pesquisa sempre retorna Poll::Pending, eu esperaria que o Future continuasse sendo pesquisado repetidamente, a menos que o próprio processo pare. No entanto, não entendo por que while let garante que o Waker seja acionado corretamente, enquanto if let não parece fazer o mesmo.

Contexto adicional

O Futuro é gerado assim:

ctx.task_executor()
    .spawn_critical_blocking("transaction execution service", Box::pin(fut_struct));

A função spawn_critical_blocking funciona da seguinte maneira:

pub fn spawn_critical_blocking<F>(&self, name: &'static str, fut: F) -> JoinHandle<()>
where
    F: Future<Output = ()> + Send + 'static,
{
    self.spawn_critical_as(name, fut, TaskKind::Blocking)
}

E internamente:

fn spawn_critical_as<F>(
    &self,
    name: &'static str,
    fut: F,
    task_kind: TaskKind,
) -> JoinHandle<()>
where
    F: Future<Output = ()> + Send + 'static,
{
    // Wrapping the future and handling task errors
    let task = std::panic::AssertUnwindSafe(fut)
        .catch_unwind()
        .map_err(...);

    let task = async move {
        // Handling task shutdown and execution
        let task = pin!(task);
        let _ = select(on_shutdown, task).await;
    };

    self.spawn_on_rt(task, task_kind)
}

O spawn_on_rtmétodo então usa spawn_blocking.

Minha pergunta

• Por que usar while let garante que o Waker seja acionado, mas usar if let
• faz

não?

• Qual é o mecanismo subjacente que causa essa diferença de comportamento?

Quaisquer informações ou explicações serão muito apreciadas!

Seria possível, dado um array A, índices de linha e índices de coluna ruins, usar o fatiamento para criar um novo array que não tenha essas linhas ou colunas?

Isso pode ser feito com np.delete da seguinte maneira:

import numpy as np
A=np.random.rand(20,16)
bad_col=np.arange(0,A.shape[1],4)[1:]
bad_row=np.arange(0,A.shape[0],4)[1:]
Anew=np.delete(np.delete(A,bad_row,0),bad_col,1)
print('old shape ',A.shape)
print('new shape ',Anew.shape)

Eu também sei que você pode usar fatiamento para selecionar certas colunas e linhas de um array. Mas eu estou pensando se ele pode ser usado para excluir certas colunas e linhas? E se não, qual a melhor maneira além np.deletede fazer isso.

EDIT: Com base nos comentários, pode não ser possível com o slicing no lugar. Que tal criar um novo array com indexação avançada?

Pode ser feito com o seguinte código, mas é lento, procure uma alternativa mais rápida:

good_col = [i for i in range(A.shape[1]) if i==0 or i % 4 != 0]
good_row=[ i for i in range(A.shape[0]) if i==0 or i % 4 != 0]

Anew2=A[good_row,:][:,good_col]
print('new shape ',Anew2.shape)

Obrigado

Tenho um pequeno aplicativo que executa dois threads.

Um thread envia um pacote multicast UDP (para o grupo 239.0.0.1) e o outro lê o mesmo pacote multicast.

Quando executo isso no aplicativo no Windows usando o Visual Studio, funciona - o pacote é enviado e recebido com sucesso. Vejo isso no Wireshark. Também tenho um alvo incorporado onde esse aplicativo finalmente roda, executando o VxWorks RTOS, e funciona no VxWorks também.

Eu tentei no Linux usando WSL2. O sendto() é bem-sucedido, mas o recvfrom() falha. No entanto, eu vejo o pacote no Wireshark, e não há erros relatados no Wireshark.

Fiz o downgrade para WSL1 e funciona.

Há algo específico para WSL2 que pode fazer com que o multicast falhe, mas funcione em WSL1, Windows e VxWorks? Se eu mudar para unicast, funciona em WSL2.

Aqui estão alguns trechos de código:

Tópico de recebimento:

uint32_t  ip_addr_mgrp;
uint32_t  ip_addr_mifc;
inet_pton(AF_INET, (char*)"172.18.19.53", &ip_addr_mifc);
inet_pton(AF_INET, (char*)"239.0.0.1", &ip_addr_mgrp);

int fd = socket(AF_INET, SOCK_DGRAM, SOCKET_PROTOCOL);

struct sockaddr_in server_addr;

server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = ip_addr_mifc;
server_addr.sin_port = htons(45007);

bind(fd, (struct sockaddr*)&server_addr, sizeof(server_addr));

struct ip_mreq mreq;
mreq.imr_multiaddr.s_addr = ip_addr_mgrp;
mreq.imr_interface.s_addr = ip_addr_mifc;

setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mreq, sizeof(mreq));

// code to set to non-blocking

// Loop for reading

// Call select()
// Call FD_ISSET()
// Call recvfrom()

Tópico TX:

uint32_t  ip_addr_mgrp;
uint32_t  ip_addr_mifc;
inet_pton(AF_INET, (char*)"172.18.19.53", &ip_addr_mifc);
inet_pton(AF_INET, (char*)"239.0.0.1", &ip_addr_mgrp);

int fd = socket(AF_INET, SOCK_DGRAM, SOCKET_PROTOCOL);

struct ip_mreq mreq;
mreq.imr_multiaddr.s_addr = ip_addr_mgrp;
mreq.imr_interface.s_addr = ip_addr_mifc;

setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mreq, sizeof(mreq));

setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, (const char*)&mreq.imr_interface.s_addr, sizeof(struct in_addr));

char loop = 1;
setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP, (char*)&loop, sizeof(loop));

// code to set to non-blocking

// Loop for sending

// Call sendto() to 237.0.0.1:45007

Quando li a documentação do fflush, ela diz que retorna 0, se foi bem-sucedido e retorna EOF (EOF está na minha máquina -1) caso contrário. (veja https://man7.org/linux/man-pages/man3/fflush.3.html ou https://en.cppreference.com/w/c/io/fflush )

Então criei o seguinte exemplo:

#include<cstdio>
#include<iostream>

int main()
{
    FILE* fp = std::fopen("/tmp/test", "w+");
    std::fclose(fp);

    std::cout << std::fflush(fp) << std::endl;
    return 0;
}

Se eu compilar com g++ minimal.cppou g++ -O2 -DNDEBUG minimal.cpp, ele imprime -1. Que é o que eu esperava.

Entretanto, quando eu compilo com g++ minimal.cpp -fsanitize=addressou g++ minimal.cpp -fsanitize=thread, ele imprime apenas 0.

Também posso reproduzir o mesmo problema com o clang.

Como isso pode ser?

Usei g++-12 e clang-15 na minha máquina Debian 12 amd64. É sempre o mesmo resultado (ou seja, fflushretorna 0 em vez de -1).

Aqui: https://logging.apache.org/log4j/2.x/manual/getting-started.html#best-practice-concat

Eles dizem isso sobre o uso de concatenação de strings no log4j:

Mais importante, essa abordagem é propensa a ataques! Imagine userId sendo fornecido pelo usuário com o seguinte conteúdo: placeholders para argumentos não existentes para disparar falha: {} {} {dangerousLookup}

Alguém poderia explicar por que isso é perigoso? Não entendi o que a concatenação de strings tem a ver com essa coisa de "dangerousLookup".

Estou tentando transformar uma lista plana de saldos de contas em uma lista de árvores de contas hierárquicas com base em uma lista de códigos exclusivos. Estou com dificuldades para resolver isso, pois não consigo ver quais etapas tomar.

Se você pensar em uma planilha do Excel, então o saldo da conta seria uma linha e o campo codes denota as colunas para quantos níveis a linha foi dividida. Isso significa efetivamente que o primeiro codes[0] é o primeiro nível e codes[1] seria o próximo e assim por diante. Ao transformar os saldos da conta em uma árvore de contas, quero somar o amountOut corretamente para cada nível (codeType e code) e então adicioná-lo como uma árvore de contas na matriz subAccounts.

Abaixo adicionei todos os tipos usados ​​e também forneci um exemplo de entrada e saída.

interface AccountBalance {
    id: string
    codes: Code[]
    amountOut: number
}

type Code = {
    id: string
    codeType: CodeTypes
    code: string
    description: string
}

enum CodeTypes {
    account = "account",
    responsible = "responsible",
    project = "project",
    object = "object",
    counterPart = "counterPart",
    free = "free",
}

type AccountTree = {
    id: string
    name: string
    code: string
    amountOut: number
    subAccounts: AccountTree[]
}

Exemplo de entrada:

const accountBalances: AccountBalance[] = [
            {
                id: "671769fbd36fcd6c2c7f2d9b",
                codes: [
                    {
                        id: "671769fbd36fcd6c2c7f2c2d",
                        codeType: codeTypeEnum.account,
                        code: "1250",
                        description: "Column A",
                    },
                    {
                        id: "671769fbd36fcd6c2c7f2bd5",
                        codeType: codeTypeEnum.responsible,
                        code: "17",
                        description: "Column B",
                    },
                    {
                        id: "671769fbd36fcd6c2c7f2bf7",
                        codeType: codeTypeEnum.counterPart,
                        code: "20",
                        description: "Column C",
                    },
                ],
                amountOut: 24510549,
            },
            {
                id: "671769fbd36fcd6c2c7f2d9c",
                codes: [
                    {
                        id: "671769fbd36fcd6c2c7f2c2d",
                        codeType: codeTypeEnum.account,
                        code: "1250",
                        description: "Column A",
                    },
                    {
                        id: "671769fbd36fcd6c2c7f2bee",
                        codeType: codeTypeEnum.responsible,
                        code: "40",
                        description: "Column B",
                    },
                    {
                        id: "671769fbd36fcd6c2c7f2c08",
                        codeType: codeTypeEnum.counterPart,
                        code: "S3",
                        description: "Column C",
                    },
                ],
                amountOut: 0,
            },
            {
                id: "671769fbd36fcd6c2c7f2d9d",
                codes: [
                    {
                        id: "671769fbd36fcd6c2c7f2c2d",
                        codeType: codeTypeEnum.account,
                        code: "1250",
                        description: "Column A",
                    },
                    {
                        id: "671769fbd36fcd6c2c7f2bdb",
                        codeType: codeTypeEnum.responsible,
                        code: "80",
                        description: "Column B",
                    },
                    {
                        id: "671769fbd36fcd6c2c7f2bdc",
                        codeType: codeTypeEnum.counterPart,
                        code: "52",
                        description: "Column C",
                    },
                ],
                amountOut: 6381398,
            },
        ]

Saída que desejo, exemplo:

const expected: AccountTree = {
            id: "671769fbd36fcd6c2c7f2c2d",
            name: "Column A",
            code: "1250",
            amountOut: 30891947,
            subAccounts: [
                {
                    id: "671769fbd36fcd6c2c7f2bd5",
                    name: "Column B",
                    code: "17",
                    amountOut: 24510549,
                    subAccounts: [
                        {
                            id: "671769fbd36fcd6c2c7f2bf7",
                            name: "Column C",
                            code: "20",
                            amountOut: 24510549,
                            subAccounts: [],
                        },
                    ],
                },
                {
                    id: "671769fbd36fcd6c2c7f2bee",
                    name: "Column B",
                    code: "40",
                    amountOut: 0,
                    subAccounts: [
                        {
                            id: "671769fbd36fcd6c2c7f2c08",
                            name: "Column C",
                            code: "S3",
                            amountOut: 0,
                            subAccounts: [],
                        },
                    ],

                },
                {
                    id: "671769fbd36fcd6c2c7f2bdb",
                    name: "Column B",
                    code: "80",
                    amountOut: 6381398,
                    subAccounts: [
                        {
                            id: "671769fbd36fcd6c2c7f2bdc",
                            name: "Column C",
                            code: "52",
                            amountOut: 6381398,
                            subAccounts: [],
                        },
                    ],
                },
            ],
        }

O que consegui até agora é isso

const uniqueCodeTypes = [
        ...new Set(
            accountBalances.reduce<CodeTypes[]>(
                (acc, balance) => [
                    ...acc,
                    ...balance.codes.flatMap((code) => code.codeType),
                ],
                [],
            ),
        ),
    ]

    const uniqueCodesForCodeType = uniqueCodeTypes.map((codeType) => {
        const uniqueCodesForCodeType = [
            ...new Map(
                accountBalances.reduce<Code[]>((acc, balance) => {
                    const code = balance.codes.find(
                        (code) => code.codeType === codeType,
                    )
                    return code ? [...acc, code] : acc
                }, []).map((code) => [code.code, code])
            ).values(),
        ]
        return uniqueCodesForCodeType
    })

Mas não tenho certeza de como proceder depois disso.