All perguntas(coding)

Quero poder filtrar um dado data.frame por uma lista dinâmica.

Digamos que eu tenha uma lista de filtros como esta

filter_list = list(filter_1 = list(vs = c(0), carb = c(1,4)),
                   filter_2 = list(cyl = c(4,6)))

Existe uma maneira de filtrar um data.framelike mtcarsde forma que fique equivalente também

library(dplyr)

mtcars %>%
  filter(vs %in% c(0) & carb %in% c(1,4) |
           cyl %in% c(4,6))

usando o formulário filter_list acima? Então, cada elemento do filter_listé avaliado como ore cada item do elemento da lista de filtros é avaliado como um and.

Tentei usar um loop, mas não está funcionando como esperado:

df = mtcars
for(f in filter_list){
  vars = names(f)
  i = 1
  for(n in f){
    df = filter(df, !!vars[[i]] %in% n)
    i = i +1
  }
}

Isso retorna apenas um data.frame. A orcondição também é violada com a loopabordagem -.

Dado um inteiro positivo N, podemos rotular todos os pontos da grade no quadrado N x N, começando em 1, o número total de pontos da grade é N x N, e os pontos da grade são list(itertools.product(range(1, N + 1), repeat=2)).

Agora, quero encontrar todas as tuplas (x, y)que satisfazem a condição x/y ser uma fração não reduzida. A seguir, uma implementação de força bruta que é garantidamente correta, mas é muito ineficiente:

import math
from itertools import product


def find_complex_points(lim: int) -> list[tuple[int, int]]:
    return [
        (x, y)
        for x, y in product(range(1, lim + 1), repeat=2)
        if math.gcd(x, y) > 1
    ]

Agora, a próxima função é um pouco mais inteligente, mas gera duplicatas e, como resultado, é apenas visivelmente mais rápida, mas não muito:

def find_complex_points_1(lim: int) -> set[tuple[int, int]]:
    lim += 1
    return {
        (x, y)
        for mult in range(2, lim)
        for x, y in product(range(mult, lim, mult), repeat=2)
    }

In [255]: %timeit find_complex_points(1024)
233 ms ± 4.44 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [256]: %timeit find_complex_points_1(1024)
194 ms ± 1.9 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Existe uma maneira melhor de fazer isso?

(Meu objetivo é simples, quero criar uma matriz NumPy 2D do tipo uint8 com a forma (N, N), preenchê-la com 255 e tornar todos os pixels (x, y) 0 se (x+1)/(y+1) for uma fração não reduzida)

Eu criei um método que é muito mais inteligente do que os meus dois anteriores, e também tremendamente mais rápido, mas ele ainda gera duplicatas. Optei por não usar setaqui para que você possa copiar e colar o código como está e executar alguns testes e ver a saída exata na ordem em que são gerados:

def find_complex_points_2(lim: int) -> set[tuple[int, int]]:
    stack = dict.fromkeys(range(lim, 1, -1))
    lim += 1
    points = []
    while stack:
        x, _ = stack.popitem()
        points.append((x, x))
        mults = []
        for y in range(x * 2, lim, x):
            stack.pop(y, None)
            mults.append(y)
            points.extend([(x, y), (y, x)])
        
        for i, x in enumerate(mults):
            points.append((x, x))
            for y in mults[i + 1:]:
                points.extend([(x, y), (y, x)])
    
    return points

In [292]: sorted(set(find_complex_points_2(1024))) == find_complex_points(1024)
Out[292]: True

In [293]: %timeit find_complex_points_2(1024)
58.9 ms ± 580 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [294]: %timeit find_complex_points(1024)
226 ms ± 3.24 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Para esclarecer, a saída de find_complex_points_2(10)é:

In [287]: find_complex_points_2(10)
Out[287]:
[(2, 2),
 (2, 4),
 (4, 2),
 (2, 6),
 (6, 2),
 (2, 8),
 (8, 2),
 (2, 10),
 (10, 2),
 (4, 4),
 (4, 6),
 (6, 4),
 (4, 8),
 (8, 4),
 (4, 10),
 (10, 4),
 (6, 6),
 (6, 8),
 (8, 6),
 (6, 10),
 (10, 6),
 (8, 8),
 (8, 10),
 (10, 8),
 (10, 10),
 (3, 3),
 (3, 6),
 (6, 3),
 (3, 9),
 (9, 3),
 (6, 6),
 (6, 9),
 (9, 6),
 (9, 9),
 (5, 5),
 (5, 10),
 (10, 5),
 (10, 10),
 (7, 7)]

Como você pode ver, (10, 10)aparece duas vezes. Quero evitar cálculos redundantes.

Isso também acontece em find_complex_points_1, se eu não usar um conjunto, muitas duplicatas serão incluídas, porque o método usado inevitavelmente as gerará repetidamente, ao usar um conjunto ainda há computação desnecessária, ele simplesmente não coleta as duplicatas.

E não, na verdade eu quero que as coordenadas sejam substituídas pela soma de todos os números anteriores, então N é substituído por (N ² + N) / 2.

Acabei de implementar a geração de imagens para ilustrar melhor o que quero:

import numpy as np
import numba as nb


@nb.njit(cache=True)
def resize_img(img: np.ndarray, h_scale: int, w_scale: int) -> np.ndarray:
    height, width = img.shape
    result = np.empty((height, h_scale, width, w_scale), np.uint8)
    result[...] = img[:, None, :, None]
    return result.reshape((height * h_scale, width * w_scale))


def find_composite_points(lim: int) -> set[tuple[int, int]]:
    stack = dict.fromkeys(range(lim, 1, -1))
    lim += 1
    points = set()
    while stack:
        x, _ = stack.popitem()
        points.add((x, x))
        mults = []
        for y in range(x * 2, lim, x):
            stack.pop(y, None)
            mults.append(y)
            points.update([(x, y), (y, x)])

        for i, x in enumerate(mults):
            points.add((x, x))
            for y in mults[i + 1 :]:
                points.update([(x, y), (y, x)])

    return points


def natural_sum(n: int) -> int:
    return (n + 1) * n // 2


def composite_image(lim: int, scale: int) -> np.ndarray:
    length = natural_sum(lim)
    img = np.full((length, length), 255, dtype=np.uint8)
    for x, y in find_composite_points(lim):
        x1, y1 = natural_sum(x - 1), natural_sum(y - 1)
        img[x1 : x1 + x, y1 : y1 + y] = 0

    return resize_img(img, scale, scale)

composite_image(12, 12)

Estou tentando o seguinte código para verificação de desempenho. Ele é puramente limitado pela CPU, faz muitos cálculos em doubletipos, single-threaded e não usa nenhum heap:

public class PerfTestSampleJ {
    private static final int MEASURE_COUNT = 5;
    private static final int ITERATIONS = 100_000_000;

    public static void main(String[] args) {
        var minTime = Long.MAX_VALUE;
        for (int i = 1; i <= MEASURE_COUNT; i++) {
            long start = System.nanoTime();
            double pi = calculatePi(ITERATIONS);
            long time = System.nanoTime() - start;
            System.out.printf("Iteration %2d took %8.3f ms%n", i, time / 1e6);
            if (time < minTime) {
                minTime = time;
            }
            if (Math.abs(pi - Math.PI) > 1e-14)
                throw new AssertionError(pi + " (" + (pi - Math.PI) + ")");
        }
        System.out.printf("Minimum time taken: %8.3f ms%n", minTime / 1e6);
    }

    private static double calculatePi(int iterations) {
        double pi = 0.0;
        double numerator = 4.0;
        for (int i = 1; i <= iterations; i++) {
            double n = i * 2.0;
            double denominator = n * (n + 1) * (n + 2);
            pi += numerator / denominator;
            numerator = -numerator;
        }
        return 3 + pi;
    }
}

Agora, usando o mesmo arquivo de classe compilado, compare os resultados ao executar no JRE 21 versus JRE 23:

/usr/lib/jvm/jdk-21.0.5-oracle-x64/bin/java PerfTestSampleJ
Iteration  1 took  801.058 ms
Iteration  2 took  798.392 ms
Iteration  3 took  414.688 ms
Iteration  4 took  413.959 ms
Iteration  5 took  416.867 ms
Minimum time taken:  413.959 ms

/usr/lib/jvm/jdk-23.0.1-oracle-x64/bin/java PerfTestSampleJ
Iteration  1 took  193.654 ms
Iteration  2 took  186.790 ms
Iteration  3 took  102.963 ms
Iteration  4 took  103.226 ms
Iteration  5 took  102.869 ms
Minimum time taken:  102.869 ms

Em cada execução, há uma fase de aquecimento nas duas primeiras iterações, mas a partir da iteração 3 é o mais rápido possível.

O que mudou no Java 23 para tornar isso mais rápido? Ao olhar as notas de lançamento, tudo o que consigo encontrar sobre desempenho são melhorias no coletor de lixo. Mas não estamos usando o heap aqui, então a melhoria do coletor de lixo é irrelevante.

PS Os resultados acima são no Ubuntu Linux x64 usando um processador i7. Obtenho os mesmos resultados usando versões Temurin. Além disso, tentei Oracle JRE 22 vs 23 no Windows x64 com resultados semelhantes, mostrando que a diferença de desempenho está entre 22 e 23.

Tentei usar ambos como padrão operator==em operator<=>uma classe simples que contém um membro de referência como este:

#include <iostream>
#include <string>

class Simple
{
public:
    Simple(const std::string& data)
     : data_(data)
    {
    }

    auto operator<=>(const Simple&) const = default;

private:
    const std::string& data_;
};

int main(int argc, char** argv)
{
    std::string str1 = "one";
    Simple s1(str1);
    std::string str2 = "two";
    Simple s2(str2);
    std::cout << (s1 < s2) << std::endl; // compiler error

    return 0;
}

O compilador clang afirma que

warning: explicitly defaulted three-way comparison operator is implicitly deleted
note: defaulted 'operator<=>' is implicitly deleted because class 'Simple' has a reference member

Não recebi nenhum aviso de outros compiladores (por exemplo, MSVC), mas quando tento usá-lo, recebo erros de compilação:

<source>(62): error C2280: 'auto Simple::operator <=>(const Simple &) const': attempting to reference a deleted function
<source>(49): note: see declaration of 'Simple::operator <=>'
<source>(49): note: 'auto Simple::operator <=>(const Simple &) const': function was implicitly deleted because 'Simple' data member 'Simple::data_' of type 'const std::string &' is a reference type
<source>(52): note: see declaration of 'Simple::data_'

Outras funções padrão, como atribuição de cópia, serão excluídas, porque não são possíveis com um membro de referência.

Mas por que o conteúdo de uma referência não pode ser comparado automaticamente?

E qual é o caminho mais curto para implementá-lo manualmente?

O único requisito para o parâmetro de tipo do std::optional<T>modelo de classe mencionado em [optional.optional.general] p3 é que o tipo Tseja Destructible .

Suponha que eu tenha uma classe muito restritiva que atenda a esse requisito:

class R
{
public:
    ~R() = default;

    // This works thanks to guaranteed copy elision since C++17.
    static R create()
    {
        return R();
    }

    void do_something()
    {
    }

private:
    R() = default;

    R(const R&) = delete;
    R& operator=(const R&) = delete;

    R(R&&) = delete;
    R& operator=(R&&) = delete;
};

Mas essa classe ainda é perfeitamente utilizável:

void test_1()
{
    R           obj = R::create();
    obj.do_something();
}

A questão é: eu realmente posso ter um objeto utilizável do tipostd::optional<R> ? Por "utilizável" eu quero dizer um objeto que contém valor. Se sim, então como eu construo esse valor ali?

O código a seguir obviamente falha porque cada construtor de Ré inacessível:

void test_2()
{
    std::optional<R>        o(R::create());   // Error: no matching constructor
}

Link de exemplo do Godbolt .

Editar:

Não seria legal se std::optionalhouvesse um construtor que aceitasse um construtor ?

template <typename Builder>
optional::optional(disabmiguating_tag, Builder f)
 : my_internal_union(f())
{
}

com construtor apropriado, é my_internal_unionclaro...

Então, a página man diz getopt()takes char * const argv[], que é um array de ponteiros constantes para char, até onde eu entendo. Ao mesmo tempo, getopt()permutes argv, para que eventualmente todas as não opções fiquem no final do array.

Acho muito confuso, porque agora ele tem que trocar strings caractere por caractere em vez de apenas trocar ponteiros, ou algo assim. Por que não pega apenas char * argv[]?

Estou usando 2 bibliotecas no meu projeto. Uma define uma Statusmacro e a outra tem uma classe nomeada Statusem um namespace.

Tenho problemas ao usar a classe Statusno meu código:

// first library
namespace Test {
    class Status {};
}

// second library
#define Status int

// my code
int main() {
    Test::Status test;
    return 0;
}

Erro:

error: expected unqualified-id before ‘int’
    8 | #define Status int

Como posso usar ambas as bibliotecas no meu projeto?

Estou lidando com uma API razoavelmente uniforme fornecida por um fornecedor e gostaria de verificar -- e lidar -- com quaisquer falhas de forma unificada também. Para esse fim, escrevi o seguinte wrapper:

template <typename Func, typename... Args>
auto awrap(Func &func, Args&&... args)
{
    auto code = func(args...);

    if (code >= 0)
        return code;

    ... handle the error ...
};
...
awrap(handlepath, handle, path, NULL, 0, coll, NULL);

O comando acima compila bem com clang, mas o g++13 e o Microsoft VC++ reclamam dos dois argumentos NULL:

... error: invalid conversion from 'int' to 'const char*' [-fpermissive]
   87 |                 auto code = func(args...

Substituir os dois NULLs por nullptrresolve o problema, mas por que isso importa?

Provavelmente, o NULLé transformado em 0x0ou mesmo 0em algum lugar pelo pré-processador, mas a chamada original nunca levantou uma "sobrancelha". Usar NULL era perfeitamente adequado em:

handlepath(handle, path, NULL, 0, coll, NULL);

Por que isso é um problema (para alguns compiladores) quando usado em um wrapper?

ATUALIZAÇÃO : /usr/include/sys/_null.hno meu sistema FreeBSD tem o seguinte código:

#ifndef NULL

#if !defined(__cplusplus)
#define NULL    ((void *)0)
#else
#if __cplusplus >= 201103L
#define NULL    nullptr
#elif defined(__GNUG__) && defined(__GNUC__) && __GNUC__ >= 4
#define NULL    __null
#else
#if defined(__LP64__)
#define NULL    (0L)
#else
#define NULL    0
#endif  /* __LP64__ */
#endif  /* __GNUG__ */
#endif  /* !__cplusplus */

#endif

Então:

1. para C, NULLé (void *)0;

2. para clang++ NULLe nullptrsão a mesma coisa, enquanto para GNU pode não ser...

código é mostrado:

const fn = (length, label, callback) => {
  console.time(label);
  for (let i = 0; i < length; i++) {
    callback && callback(i);
  }
  console.timeEnd(label);
};

const length = 100000000;
fn(length, "1", () => {})  // very few intervals
fn(length, "2", () => {})  // regular
fn(length, "3", () => {})  // regular

e então removi o terceiro argumento callback, e seus tempos de execução estão muito próximos.

const fn = (length, label, callback) => {
  console.time(label);
  for (let i = 0; i < length; i++) {
    callback && callback(i);
  }
  console.timeEnd(label);
};

const length = 100000000;
fn(length, "1")  // regular
fn(length, "2")  // regular
fn(length, "3")  // regular

por que???

Eu tenho o seguinte problema

library(tidyverse)
test <- tibble(A = c("1994:2020, 2021"), B = 1995)

Gostaria de verificar se o ano em B está nos anos indicados na coluna A. Os anos na coluna A são uma string (os dados são lidos de um arquivo Excel). O seguinte claramente não funciona (dá "Não", mas eu gostaria de ter "Sim"):

test %>%
  mutate(InA = ifelse(B %in% A, "Yes", "No"))

> test
# A tibble: 1 x 2
  A                   B
  <chr>           <dbl>
1 1994:2020, 2021  1995

Presumo que devo separar a string em A. No entanto, A pode conter mais de um intervalo e/ou mais de um ano (por exemplo, ("1994:2012, 2014, 2016:2020, 2021") e usando "separar" para estruturas diferentes fica complicado.Talvez haja uma maneira mais direta.