All perguntas(coding)

Esta fonte C:

typedef struct {
  unsigned long one;
  unsigned long two;
} twin;

twin function( twin t ) {
  return (twin){ 0,0 };
}

gera esta montagem:

        .file   "p.c"
        .option nopic
        .attribute arch, "rv64i2p1_m2p0_a2p1_f2p2_d2p2_c2p0_zicsr2p0_zifencei2p0"
        .attribute unaligned_access, 0
        .attribute stack_align, 16
        .text
        .align  1
        .globl  function
        .type   function, @function
function:
        addi    sp,sp,-32  # <<< WHY?
        li      a0,0
        li      a1,0
        addi    sp,sp,32   # <<< WHY?
        jr      ra
        .size   function, .-function
        .ident  "GCC: (g04696df09) 14.2.0"
        .section        .note.GNU-stack,"",@progbits

quando executado riscv64-unknown-elf-gcc (g04696df09) 14.2.0com ou -O3ou -O2ou -O1mesmo -Os.

Então por que o código está criando espaço na pilha para coisas (32 bytes) que são e serão mantidas em registradores a0e a1?

Isso é um bug ou estou esquecendo de alguma coisa?

Gostaria de colorir células condicionalmente com base em uma coluna diferente usando gto pacote. Tentei usar o rowsargumento para colorir condicionalmente, mas não funcionou. Aqui, tentei um exemplo reproduzível:

library(gt)
library(dplyr)
head(mtcars) %>%
  gt() %>%
  data_color(
    columns = cyl,
    rows = vs == 0,
    palette = c("red", "green")
  )

Saída:

Como você pode ver, a cor não está correta, assim como os outros valores. Deveria ser vermelho se vs for 0 e verde se vs for 1. Alguém sabe como podemos colorir condicionalmente esses valores com base em uma coluna diferente no gt?

Estou explorando o recurso "deduzindo isso" e estou com dificuldades para entender como usá-lo corretamente com conceitos. Aqui está o que eu tenho:

#include <concepts>

struct X {
  X() = default;
  X& operator+=(int x) { value += x; return *this; }
  int value = 0;
};

struct Y {
  Y() = default;
  template<typename Self> Self& operator+=(this Self& self, int x) {
    self.value += x; return self;
  }
  int value = 0;
};

template<typename T, typename U>
concept has_addition_assignment =
  std::is_lvalue_reference_v<T>
  && requires(T a, U b) { { a += b } -> std::same_as<T>; };

static_assert(has_addition_assignment<X&,int>); // OK
static_assert(!has_addition_assignment<const X&,int>); // OK

static_assert(has_addition_assignment<Y&,int>); // OK
// static_assert(!has_addition_assignment<const Y&,int>); // Fails

int
main()
{
  // Not allowed.
  //  const Y y;
  //  y += 1;
}

O conceito é tentar garantir que X x; x += 1;funcione, mas const X x; x += 1não funciona. Isso funciona para, Xmas não funciona Y, apesar de const Y y; y += 1;falhar.

Acredito que meu conceito está escrito incorretamente ou talvez +=não Yexpresse minha intenção corretamente. Qual é a melhor maneira de verificar se não é aceitável adicionar algo a um objeto constante ao usar deducing this?

Estou portando um aplicativo de console que foi escrito em C visando Linux. Quero tornar o código o mais portátil possível, para que ele também possa ser usado no Windows e outros sistemas operacionais. Até agora, consegui substituir todo o código específico do Linux, como pthreads, semáforos e operações de sistema de arquivos, com cabeçalhos stdlib C++ correspondentes.

Um dos recursos que o aplicativo tem é executar como arquitetura cliente-servidor, para permitir cálculos em segundo plano e persistir e reutilizar o estado quando o cliente CLI sai. Eu li sobre vários métodos IPC, como sockets, pipes e memória compartilhada, mas eles sempre usam syscalls não portáveis.

Existe alguma maneira de fazer isso usando apenas C++ e stdlib? A única solução que consigo pensar é a comunicação baseada em arquivo, mas parece muito difícil manter a atomicidade, especialmente com vários clientes, e o servidor tem que pesquisar o arquivo para alterações, pois todos os métodos de notificação parecem ser específicos do SO também. A última pergunta no Stackoverflow sobre isso tem 15 anos, então talvez algo tenha sido proposto para resolver isso em C++23 e posteriores.

Esta é a minha primeira vez fazendo estatística espacial e estou aprendendo aos poucos. Já vi algumas outras pessoas aqui com problemas semelhantes, mas nenhuma das respostas pareceu funcionar para mim.

Estou tentando fazer um MCP, mas quando vejo os resultados, o tamanho da área é bem menor do que deveria. No entanto, quando ploto os polígonos sobre um mapa de satélite, parece correto.

Meus dados estão configurados assim:

set.seed(1)
animal_sp <- data.frame(ID = rep(c("S1", "S2"), each = 10),
                         Long = runif(20, 34.2002, 34.55328),
                         Lat = runif(20, -19.11998, -18.82139))

E o código que usei é o seguinte:

library(sp)

sp::coordinates(animal_sp) <- c("Long", "Lat") # define the variables

proj4string(animal_sp) <- CRS("+init=epsg:4326") # Set the projection




# Create the MCP using the adehabitatHR package:                                                

library(adehabitatHR)

animal_mcp <- mcp(animal_sp, 
                 percent = 100,
                 unout = "m2") # Make the MCP

animal_mcp # look at the results

Os resultados que obtenho são:

Object of class "SpatialPolygonsDataFrame" (package sp):

Number of SpatialPolygons:  2

Variables measured:
   id       area
S1 S1 0.02919310
S2 S2 0.03671279

Eu deveria obter uma área de ~260 km².

Qualquer ajuda será muito apreciada!

Me deparei com um exemplo que simula o acesso a um banco de dados lento para obter um fluxo de identificadores de usuários associados a um perfil que pode ser acessado por meio de um recurso de rede ainda mais lento:

fun getAllUserIds():Flow<Int>{
    return flow{
        repeat(3){
            delay(200.milliseconds)
            log("Emitting!")
            emit(it)
            }
         } 
      }

suspend fun getProfileFromNetwork(id:Int):String{
    delay(2.seconds)
    return "Profile[$id]"
  }

fun main(){
    val ids = getAllUserIds()
    runBlocking{
        ids
            .map{getProfileFromNetwork(it)}
            .collect{log("Got $it")}
        }
  }

a emissão dos IDs e a solicitação de perfis estão interligadas. Como eu otimizaria isso gerando novas coroutines para o processamento de cada elemento no fluxo?

Quero carregar uma imagem (PNG/JPEG) no RStudio e depois exibi-la. Mas quando executo

plot(load.image("solidblack.png"), ann = FALSE, axes = FALSE, mar = c(0,0,0,0))

Eu obtenho margens muito substanciais em torno da minha imagem, apesar do marargumento de plot:

Como posso consertar isso?

É seguro usar uma variável estática de escopo de namespace (ou seja, ligação interna) como parâmetro padrão para uma função declarada em um cabeçalho? E se sim, é garantido que ao fazer uma chamada padrão em uma determinada unidade de tradução, o valor definido naquela unidade de tradução seja usado como padrão?

Em código:

biblioteca.h:

#pragma once

#ifdef USE_ALTERNATE_DEFAULT
static const int defaultValue = 42;
#else
static const int defaultValue = 314;
#endif

void printValue(int value = defaultValue);

biblioteca.cpp:

#include "lib.h"

#include <print>

void printValue(const int value) {
  std::println("Value: {}", value);
}

a.cpp:

#include "lib.h"

void foo() {
  printValue(); // '314'
  printValue(0); // '0'
}

b.cpp:

#define USE_ALTERNATE_DEFAULT

#include "lib.h"

void bar() {
  printValue(); // '42'
  printValue(1); // '1'
}

O código acima está bem formado? E é garantido que cada uma das chamadas para printValueresulte no valor no comentário correspondente sendo impresso?

Tenha em mente que lib.cpp, a.cpp e b.cpp podem fazer parte de diferentes bibliotecas/binários compartilhados.

O objetivo aqui é tornar o comportamento padrão de uma função personalizável em um nível por TU alterando as diretivas do pré-processador.

Contexto para a pergunta

Dito isto, a solução parece um tanto complicada e este pode ser um problema XY.

Aqui está uma descrição mais completa do que estou tentando fazer:

• Estou usando algo semelhante para bin2cgerar vários arquivos de cabeçalho que definem várias strings longas diferentes.
• Tenho uma biblioteca vinculada estaticamente libque precisa executar alguma operação nessas strings geradas automaticamente ou retornar à operação em uma string padrão caso nenhum cabeçalho desse tipo esteja disponível.
• Estou compilando várias versões diferentes de vários binários diferentes, cada um com diferentes arquivos de cabeçalho gerados automaticamente, cada um vinculado à lib.

Então lib.hpode ser algo como:

#ifdef GENERATED_HEADER
// static const char* kMyString defined in the generated header
#include GENERATED_HEADER
#else
// Define fall-back default.
static const char* kMyString = "default";
#endif

void doStuff(int someArg, const char* str = kMyString);

E claro lib.cpptem a definição de doStuff. Suponha que esta seja uma função complexa.

Então my_app1.cpp:

#include "lib.h"

int main() {
  int someArg = foo();
  doStuff(someArg);
}

E my_app2.cpp:

#include "lib.h"

int main() {
  int someArg = bar();
  doStuff(someArg);
}

Então:

• Compilar lib.cppem lib.a.
• Gerar Doc1.husando doc1.txtbin2c-ish.
• Gerar Doc2.husando doc2.txtbin2c-ish.
• Gerar Doc3.husando doc3.txtbin2c-ish.
• Compilar my_app1.cppe my_app1_default.avincular com lib.ainto my_app1_default.
• Compilar my_app1.cppcom -DGENERATED_HEADER=\"Doc1.h\"into my_app2_doc1.ae vincular com lib.ainto my_app1_doc1.
• Compilar my_app1.cppcom -DGENERATED_HEADER=\"Doc2.h\"into my_app1_doc2.ae vincular com lib.ainto my_app1_doc2.
• Compilar my_app2.cppe my_app2_default.avincular com lib.ainto my_app2_default.
• Compilar my_app2.cppcom -DGENERATED_HEADER=\"Doc3.h\"into my_app2_doc3.ae vincular com lib.ainto my_app2_doc3.

O ponto é que o comportamento de libpode ser personalizado em um nível por binário com base no ambiente de construção, enquanto ainda mantém uma única implementação de lib. E, além disso, libpode ser usado em vários códigos-fonte de aplicativos diferentes com código boilerplate mínimo.

Claro, se a abordagem do argumento padrão for malformada, aproximadamente a mesma coisa ainda pode ser alcançada simplesmente passando explicitamente a variável estática para a função. Mas isso exigiria um pouco mais de boilerplate no local da chamada, o que estou tentando evitar. Daí a pergunta acima :)

Estou tentando ler várias tabelas compactadas com mais de 5 GB de tamanho em R e, como não tenho memória suficiente para lê-las todas de uma vez, preciso processá-las um pedaço de cada vez, por exemplo, as primeiras 1.000 linhas de cada arquivo, depois as próximas 1.000 linhas de cada arquivo, etc. Sei como manter um arquivo aberto com um cursor ou ponteiro de arquivo salvo basicamente em qualquer linguagem diferente de R. Como posso fazer isso aqui?

Atualmente estou fazendo algo parecido com isto:

library(data.table)
library(R.utils)

inFiles = c("file1.tsv.gz", "file2.tsv.gz", "file3.tsv.gz")
totallines <- 10000
chunksize <- 1000

iters          <- 1
skip_val       <- 0
max_iters      <- ceiling(totallines/chunksize)

while (iters <= max_iters) {

    
    data = lapply(inFiles,function(file) {
      data.table::fread(file, nrows=chunksize, skip=skip_val,
                        col.names=data_colnames, sep="\t")
    })

    # Process the data in omitted code here

    # Move on to the next chunk
    iters    = iters + 1
    skip_val = skip_val + chunksize
}

O problema é que esses arquivos são grandes e compactados, e quanto menor o chunksize ou maior o arquivo, o programa gasta mais e mais tempo apenas lendo por causa das linhas puladas. Toda vez que ele lê o próximo chunk, ele também tem que descompactar e pular todas as linhas anteriores.

Dei uma olhada em readr::read_delim_chunked , mas não tenho certeza de como poderia usá-lo para iterar por muitos arquivos de uma vez.

Contexto: Tenho escrito um programa multithread que usa atomics extensivamente. Percebi que esses atomics são muito lentos, especialmente no ARM, porque o compilador inseriu muitas fences, às vezes até dentro de loops. Então, quero eliminar as desnecessárias usando ordens de memória.

Eu tropecei neste caso, mas não tenho certeza se é seguro usar uma carga relaxada ou não. Veja este exemplo simples de leitura de parâmetros:

typedef struct {
    big_struct Data;
    _Atomic bool bDataReadDone;
} worker_thread_parameter;

static int WorkerThreadFunction(void* Parameter) {
    // Read Data
    worker_thread_parameter* pWorkerParameter = Parameter;
    big_struct Data = pWorkerParameter->Data;

    // Notify that reading Data is done
    // Use release store to ensure Data is read before this.
    atomic_store_explicit(&pWorkerParameter->bDataReadDone, true, memory_order_release);
        
    // Do something with Data
}

int main() {
    thrd_t aWorkerThread[8];
    for (size_t i = 0; i < 8; ++i) {
        worker_thread_parameter WorkerParameter = { /* Data = something */, false };
        thrd_create(&aWorkerThread[i], WorkerThreadFunction, &WorkerParameter);

        // Wait for Data to be read
        // Use relaxed load because this thread doesn't read Data anymore,
        // so we don't need to synchronize with the flag.
        while (!atomic_load_explicit(&WorkerParameter.bDataReadDone, memory_order_relaxed));
    }
}

Ou este exemplo:

// Initialized before the threads are started
_Atomic bool bUsingData = true;
big_struct* pData = malloc(sizeof(*pData));

static int WorkerThread() {
    Use(pData);

    // Notify the cleaner thread to free Data
    // Use release store to ensure Data is used before this.
    atomic_store_explicit(&bUsingData, false, memory_order_release);
}

static int CleanerThread() {
    // Use relaxed load because this thread doesn't read Data anymore,
    // so we don't need to synchronize with the flag.
    while (atomic_load_explicit(bUsingData, memory_order_relaxed));
    free(pData);
}

E este exemplo:

_Atomic int X = 0;
_Atomic int Y = 0;

// Thread 1

atomic_store_explicit(&X, 99, memory_order_relaxed);
atomic_store_explicit(&Y, 1, memory_order_release);

// Thread 2

if (atomic_load_explicit(&Y, memory_order_relaxed)) {
    atomic_store_explicit(&X, 100, memory_order_relaxed);
    printf("%i", atomic_load_explicit(&X, memory_order_relaxed));
}

// Does thread 2 always prints 100?