All perguntas(coding)

Usando ggplot2, gostaria de ter duas legendas na mesma linha, abaixo do título, mas uma alinhada à esquerda e outra alinhada à direita para um gráfico facetado como o abaixo.

Posso ter uma legenda alinhada à esquerda:

p <- ggplot(mtcars, aes(mpg, hp)) + 
  geom_point() +
  facet_grid(am~.) +
  theme(plot.title=element_text(hjust=0.5))

p + labs(title="Data: mtcars", subtitle="Subtitle (left-aligned)")

ou alinhado à direita,

p + labs(title="Data: mtcars", subtitle="Subtitle (right-aligned)") +
  theme(plot.subtitle=element_text(hjust=1))

Mas parece que não consigo ter os dois, a menos que eu os combine com um número arbitrariamente grande de espaços entre eles (que é como eu fiz o gráfico acima). Mas não gosto dessa solução. Existe outra maneira?

Visão geral: Estou executando o knitr em um grande número de arquivos R/Markdown (na verdade, exercícios R/examssetTimeLimit() para ser mais específico), alguns dos quais levam muito tempo para serem concluídos. Portanto, quero definir um limite de tempo para isso, que pode ser feito a partir do R base. No entanto, em algumas situações, isso pode levar a um arquivo não fechado sink(); veja o exemplo reproduzível abaixo.

Pergunta: Posso fazer algo para evitar isso? É um bug no knitr(ou em uma de suas dependências, como evaluate)? Ou no R base?

Exemplo: configurei um arquivo mínimo timeout.Rmdque calcula a resposta 42, espera 2 segundos e então o insere na saída do Markdown.

writeLines("
```{r}
ans <- 6 * 7
Sys.sleep(2)
```

Answer: `r ans`
", "timeout.Rmd")

Então, defini o limite de tempo para 1 segundo.

setTimeLimit(elapsed = 1)

Depois disso, a execução knitrno timeout.Rmdarquivo falha no {r}trecho de código (como esperado):

knitr::knit("timeout.Rmd")
## 
## processing file: timeout.Rmd
##   |...................................                 |  67% [unnamed-chunk-1]
## 
## Error in `remove_hooks()`:
## ! reached elapsed time limit
## Backtrace:
##      ▆
##   1. ├─knitr::knit("timeout.Rmd")
##   2. │ └─knitr:::process_file(text, output)
##   3. │   ├─xfun:::handle_error(...)
##   4. │   ├─base::withCallingHandlers(...)
##   5. │   └─knitr:::process_group(group)
##   6. │     └─knitr:::call_block(x)
##   7. │       └─knitr:::block_exec(params)
##   8. │         └─knitr:::eng_r(options)
##   9. │           ├─knitr:::in_input_dir(...)
##  10. │           │ └─knitr:::in_dir(input_dir(), expr)
##  11. │           └─knitr (local) evaluate(...)
##  12. │             └─evaluate::evaluate(...)
##  13. │               └─evaluate (local) `<fn>`()
##  14. └─evaluate::remove_hooks(hook_list)
## 
## Quitting from timeout.Rmd:2-5 [unnamed-chunk-1]

Depois dessa falha, tudo continua ok e podemos obter uma saída impressa como:

print(1)
## [1] 1

Mas depois de abrir um novo enredo como

plot(1)

não temos mais saída impressa

print(1)

porque agora existe uma abertura sink()que captura toda a saída impressa. Somente após fechá-la, a impressão volta a funcionar

sink()
print(1)
## [1] 1

Consegui replicar esse problema em algumas máquinas Linux executando o R 4.5.0 ou 4.4.x diretamente no shell. (No RStudio, o tempo limite não parece ser detectado por algum motivo.)

Vejo uma pergunta semelhante Construtor de movimento padrão recebendo um parâmetro constante , que tem 8 anos, com a resposta Não .

Mas, ao mesmo tempo, um programa ligeiramente modificado com o construtor padrão após a definição da classe:

struct A {
    A(const A&&);
};
A::A(const A&&) = default;

aceito pelo EDG 6.7 e lançado recentemente pelo GCC 15.1. Demonstração online: https://gcc.godbolt.org/z/E4qT3sTEq

E um exemplo ainda mais complexo parece funcionar corretamente com estes dois compiladores:

struct A {
    int i;
    constexpr A(int v) : i(v) {}
    constexpr A(const A&&);
};

constexpr int f() {
    A a(1);
    A b = static_cast<const A&&>( a );
    return b.i;
}

constexpr A::A(const A&&) = default;
static_assert( f() == 1 );

Mas o MSVC ainda não gosta disso:

error C2610: 'A::A(const A &&)': is not a special member function or comparison operator which can be defaulted
<source>(13): note: the argument must be a non-const rvalue reference

assim como Clang:

error: the parameter for an explicitly-defaulted move constructor may not be const

Demonstração online: https://gcc.godbolt.org/z/6W9W865vG

Alguma coisa mudou nos últimos 8 anos nessa relação? Qual implementação está correta agora?

Depois de executar este programa

std::future<int> f() {
    std::cout << "enter f on thread " << std::this_thread::get_id() << std::endl;
    co_return 1;
}
std::future<void> g() {
    std::future<int> i = co_await std::async(f);
    std::cout << "resume g on thread: " << std::this_thread::get_id() << std::endl;
    co_return;
}
int main() {
    std::future<void> f;
    while (true) {
        f = g();
        std::this_thread::sleep_for(1s);
    }
    return 0;
}

que foi compilado com MSVC 19.43 usando a /awaitopção, observei que a função festá sempre sendo executada na mesma thread, enquanto a continuação na função gé sempre executada em uma thread recém-criada. Também tentei chamar std::asynccom std::launch::asynca opção para forçar a criação de uma nova thread, mas ainda assim a mesma thread seria usada para executar f. Alguém pode explicar o porquê?

Tenho um binário que eu mesmo criei, mas não lembro qual versão rustcusei para criá-lo.

Parece que ele vinculou a biblioteca padrão estaticamente (como é típico), então não consigo usar readelf -desse método para descobrir qual versão da biblioteca padrão está vinculada.

Eu construí o binário usando cargo-auditable, mas o json incorporado parece não mencionar a versão do compilador Rust ou a biblioteca padrão:

❯ rust-audit-info bin/jaq
{"packages":[{"name":"aho-corasick","version":"1.1.3","source":"crates.io","dependencies":[28]},{"name":"autocfg","version":"1.4.0","source":"crates.io","kind":"build"},{"name":"base64","version":"0.22.1","source":"crates.io"},{"name":"bitflags","version":"2.7.0","source":"crates.io"},{"name":"cc","version":"1.2.9","source":"crates.io","kind":"build","dependencies":[35]},{"name":"cfg-if","version":"1.0.0","source":"crates.io"},{"name":"chrono","version":"0.4.39","source":"crates.io","dependencies":[31]},{"name":"codesnake","version":"0.2.1","source":"crates.io"},{"name":"dyn-clone","version":"1.0.17","source":"crates.io"},{"name":"env_logger","version":"0.10.2","source":"crates.io","dependencies":[27]},{"name":"equivalent","version":"1.0.1","source":"crates.io"},{"name":"errno","version":"0.3.10","source":"crates.io","dependencies":[23]},{"name":"fastrand","version":"2.3.0","source":"crates.io"},{"name":"foldhash","version":"0.1.4","source":"crates.io"},{"name":"getrandom","version":"0.2.15","source":"crates.io","dependencies":[5,23]},{"name":"hashbrown","version":"0.15.2","source":"crates.io"},{"name":"hifijson","version":"0.2.2","source":"crates.io"},{"name":"indexmap","version":"2.7.0","source":"crates.io","dependencies":[10,15]},{"name":"is-terminal","version":"0.4.13","source":"crates.io","dependencies":[23]},{"name":"jaq","version":"2.1.1","source":"local","dependencies":[7,9,16,18,20,21,22,27,29,30,36,38,40],"root":true},{"name":"jaq-core","version":"2.1.1","source":"crates.io","dependencies":[8,32,37]},{"name":"jaq-json","version":"1.1.1","source":"crates.io","dependencies":[13,16,17,20,22]},{"name":"jaq-std","version":"2.1.0","source":"crates.io","dependencies":[0,2,6,20,24,27,33,39]},{"name":"libc","version":"0.2.169","source":"crates.io"},{"name":"libm","version":"0.2.11","source":"crates.io"},{"name":"libmimalloc-sys","version":"0.1.39","source":"crates.io","dependencies":[4,23]},{"name":"linux-raw-sys","version":"0.4.15","source":"crates.io"},{"name":"log","version":"0.4.25","source":"crates.io"},{"name":"memchr","version":"2.7.4","source":"crates.io"},{"name":"memmap2","version":"0.9.5","source":"crates.io","dependencies":[23]},{"name":"mimalloc","version":"0.1.43","source":"crates.io","dependencies":[25]},{"name":"num-traits","version":"0.2.19","source":"crates.io","dependencies":[1]},{"name":"once_cell","version":"1.20.2","source":"crates.io"},{"name":"regex-lite","version":"0.1.6","source":"crates.io"},{"name":"rustix","version":"0.38.43","source":"crates.io","dependencies":[3,11,23,26]},{"name":"shlex","version":"1.3.0","source":"crates.io","kind":"build"},{"name":"tempfile","version":"3.15.0","source":"crates.io","dependencies":[5,12,14,32,34]},{"name":"typed-arena","version":"2.0.2","source":"crates.io"},{"name":"unicode-width","version":"0.1.13","source":"crates.io"},{"name":"urlencoding","version":"2.1.3","source":"crates.io"},{"name":"yansi","version":"1.0.1","source":"crates.io"}]}

Ele foi construído com --release, então parece que os símbolos de depuração foram removidos:

❯ rust-gdb -q bin/jaq -ex quit
Reading symbols from bin/jaq...
(No debugging symbols found in bin/jaq)

Como posso descobrir qual versão do rustc (ou, equivalentemente, qual versão da biblioteca padrão) foi usada para construir este binário?

Primeiro, suponha que eu tenha

int16_t a;
int8_t b;

. Gostaria de fazer isso b=a;descartando todos os MSBs, incluindo o bit de sinal, que anão se encaixam em b. Qual seria uma maneira correta de fazer isso?

Não consigo encontrar nenhuma informação útil e recente sobre este tópico. Este link diz que a conversão de estreitamento de sinal depende do compilador, mas isso acontece em C, não em C++. Também não quero comportamentos dependentes do compilador. Aqui diz que a conversão de estreitamento deveria ser um erro. Estou bastante confuso sobre o que fazer.

Segundo, se ambos ae bfossem suas contrapartes sem sinal, então seria b=a;uma abordagem adequada? De acordo com o primeiro link, isso é definido pelo menos em C.

Criei um conjunto usando Collections.synchronizedSet<T>(mutableSetOf<T>()).
SynchronizedSetque tem sua própria implementação de forEach(synchronized) que difere daquela fornecida por Iterable.forEach(not synchronized), no entanto, o do Kotlin Iterable.forEaché anotado com @HidesMembers, então ele é chamado em vez do synchronized.

Como faço para recuperar a versão sincronizada do forEach?

Estou fazendo uma análise exploratória básica de tópicos de duas respostas a perguntas diferentes e tentando visualizar os resultados por pergunta. Estou trabalhando no RStudio e usando um arquivo RMarkdown. O conjunto de dados de exemplo que criei aqui é bem menor do que o que estou usando, o que não deve ser um problema para descrever o problema. Abaixo está todo o código para obter a matriz e a tabela gama, mas tudo funciona bem.

library(tidyverse)
library(tidytext)
library(stm)

#here is a representative example of my data
Term <- c("y57","t44","y57","t44","y57","t44","t44","y57")
Question <- c(1,1,1,1,2,2,2,2)
Id <- c(1,2,1,2,3,4,4,3)
Text <- c("words that are all here in this dataframe", "other sorts of things to meet the needs of the data", "stuff and the like about such and such and this that and the other", "et cetera and so on and so forth and on ad nauseum", "bla bla shockablooey the hooey is newey to youey", "wooly sheep are superior to all other sheep", "come together in this hour of great trial", "right words are different from wrong ones")

df_data <- data.frame(term = Term, question = Question, id = Id, text = Text)

#unnesting the words into a new dataframe
df_tidy <- 
  df_data %>% 
  unnest_tokens(word,text)

#setting up the necessary pieces for the topic analysis plot
df_sparse <-
  df_tidy %>% 
  count(id,word) %>% 
  filter(n > 1) %>% 
  cast_sparse(id,word,n)

set.seed(216)
topic_model_5 <- stm(df_sparse, K = 5)

df_gamma_5 <-
  tidy(topic_model_5,
       matrix = "gamma",
       document_names = rownames(df_sparse))

Meu problema está na preparação final para a plotagem, na qual quero ordenar os tópicos por uma variável (pergunta) para obter dois gráficos. Estou tentando usar a função left_join entre "df_data" e "df_gamma_5". Pelo menos é isso que acho que este segmento está tentando fazer...

#object type troubleshooting that made sense to me
df_data$question <- as.factor(df_data$question)
df_data$id <- as.character(df_data$id)

#what I can't get unstuck, which I think has to be from the left_join somehow
df_gamma_5 %>% 
  left_join(
    df_data %>% 
      select(question, document = id) %>% 
      mutate(question, fct_inorder(question)),
    relationship = "many-to-many"
  ) %>% 
  mutate(topic = factor(topic)) +
  ggplot(aes(gamma, topic, fill = topic)) +
  geom_boxplot(alpha = 0.7, show.legend = TRUE) +
  ggtitle("topics by question") +
  facet_wrap(vars(term)) %>% 
  print()

A mensagem de erro que recebo dessa linha é:

Joining with `by = join_by(document) `Warning: Detected an unexpected many-to-many relationship between `x` and `y`. Error in `fortify()`:
! `data` must be a <data.frame>, or an object coercible by
  `fortify()`, or a valid <data.frame>-like object coercible by
  `as.data.frame()`, not a <uneval> object.
ℹ Did you accidentally pass `aes()` to the `data` argument?
Run `rlang::last_trace()` to see where the error occurred.

Isso está me deixando louco porque segui um exemplo online usando dados de letras de Taylor Swift ( https://www.youtube.com/watch?v=rXDv0ZuX0Fc&t=216s ) e o código que escrevi para esse exemplo funcionou perfeitamente. O gráfico que quero é essencialmente o mesmo do vídeo, exceto que em vez de gráficos por álbum (n=11) quero gráficos por pergunta (n=2). Em uma análise mais complexa, gostaria de um 2x2 com cada amostra de gráfico selecionada por termo e pergunta, mas isso é para outro dia. Suspeito que o problema tenha algo a ver com o fato de que, ao contrário do catálogo de Taylor Swift, onde as letras de cada música são uma observação distinta, tenho duas observações de texto diferentes para cada variável id. Não sei se esse é o problema, e mesmo se soubesse, não sei como resolvê-lo.

Estou aprendendo R (e programação em geral) há dez dias, então qualquer ajuda será muito mais difícil do que eu tentar me agarrar a qualquer coisa. Obrigado!

Estou desenvolvendo um explorador fractal em C++ usando SFML e std::threadrenderizando o conjunto de Mandelbrot na CPU com exibição progressiva. O objetivo é aproveitar múltiplos núcleos, dividindo a imagem em faixas horizontais, com cada faixa renderizada por uma thread separada. A responsividade do usuário é importante, o que significa que interações como zoom ou panorâmica devem, idealmente, interromper a renderização atual e iniciar uma nova.

Ao implementar a lógica de renderização progressiva, encontrei um artefato visual que é consistentemente reproduzível em um exemplo mínimo.

O Artefato Observado:

Durante o processo de renderização, que visa preencher a imagem faixa por faixa, a saída não mostra faixas sólidas de pixels computados. Em vez disso, dentro da região horizontal atribuída a cada thread, a estrutura fractal aparece como linhas horizontais finas e desconexas, separadas por espaços pretos.

Este não é o preenchimento suave esperado da área de trabalho horizontal. Uma captura de tela ilustrando esse artefato específico e consistente pode ser vista aqui:

https://isstatic.askoverflow.dev/82LBOVUT.png

O que considero particularmente intrigante é a consistência com que esse artefato se manifesta. Não parece ser um "rasgo" transitório ou uma condição de corrida típica; o padrão está presente de forma confiável sempre que executo o código com os mesmos parâmetros.

#include <SFML/Graphics.hpp>
#include <iostream>
#include <vector>
#include <thread>
#include <chrono>
#include <cstring>

struct render_target {
    unsigned int x_start, y_start, x_end, y_end;
    render_target(unsigned int xs, unsigned int ys, unsigned int xe, unsigned int ye)
            : x_start(xs), y_start(ys), x_end(xe), y_end(ye) {}
};

unsigned char* pixels = nullptr;

const unsigned int render_width = 800;
const unsigned int render_height = 600;

const unsigned int buffer_width = render_width;
const unsigned int buffer_height = render_height;

const double zoom_x = 240.0;
const double zoom_y = 240.0;
const double x_offset = 2.25;
const double y_offset = 1.25;
const unsigned int max_iterations = 300;

std::vector<unsigned char> thread_stop_flags; // 0: running, 1: stop requested, 2: stopped

sf::Texture texture;
sf::Sprite sprite(texture);
sf::Image image;

void cpu_render_minimal(render_target target, unsigned char* pixels, unsigned int width_param, unsigned int height_param,
                        double zoom_x, double zoom_y, double x_offset, double y_offset,
                        unsigned int max_iterations,
                        unsigned char& finish_flag)
{
    finish_flag = 0;

    for(unsigned int y = target.y_start; y < target.y_end; ++y){
        for(unsigned int x = target.x_start; x < target.x_end; ++x){
            double zr = 0.0;
            double zi = 0.0;
            double cr = x / zoom_x - x_offset;
            double ci = y / zoom_y - y_offset;

            unsigned int curr_iter = 0;
            while (curr_iter < max_iterations && zr * zr + zi * zi < 4.0) {
                double tmp_zr = zr;
                zr = zr * zr - zi * zi + cr;
                zi = 2.0 * tmp_zr * zi + ci;
                ++curr_iter;

                if(finish_flag == 1) {
                    finish_flag = 2;
                    return;
                }
            }

            unsigned char color_val;
            if (curr_iter == max_iterations) {
                color_val = 255;
            } else {
                color_val = static_cast<unsigned char>((curr_iter % 255) + 1);
            }

            const unsigned int index = (y * width_param + x) * 4;

            if (index + 3 < buffer_width * buffer_height * 4) {
                pixels[index] = color_val;
                pixels[index + 1] = color_val;
                pixels[index + 2] = color_val;
                pixels[index + 3] = 255;
            }
        }
    }
    finish_flag = 1;
}

void post_processing_minimal() {
    if (!pixels) return;

    image = sf::Image({render_width, render_height}, pixels);
    texture = sf::Texture(image, true);
    sprite = sf::Sprite(texture);
}

void start_render_job()
{
    if (pixels != nullptr) {
        delete[] pixels;
        pixels = nullptr;
    }

    pixels = new unsigned char[buffer_width * buffer_height * 4];
    if (!pixels) {
        std::cerr << "Error: Could not allocate pixel buffer!" << std::endl;
        return;
    }
    memset(pixels, 0, buffer_width * buffer_height * 4);

    unsigned int max_threads = std::thread::hardware_concurrency();
    if (max_threads == 0) max_threads = 1;
    thread_stop_flags.assign(max_threads, 0);
    std::vector<render_target> render_targets;

    unsigned int strip_height = render_height / max_threads;
    for(unsigned int i = 0; i < max_threads; ++i) {
        unsigned int x_start = 0;
        unsigned int x_end = render_width;
        unsigned int y_start = strip_height * i;
        unsigned int y_end = (i == max_threads - 1) ? render_height : strip_height * (i + 1);
        if (y_start >= y_end) continue;

        render_targets.emplace_back(x_start, y_start, x_end, y_end);
    }

    for(size_t i = 0; i < render_targets.size(); ++i) {
        std::thread t(cpu_render_minimal, render_targets[i], pixels,
                      render_width, render_height,
                      zoom_x, zoom_y, x_offset, y_offset,
                      max_iterations, std::ref(thread_stop_flags[i]));
        t.detach();
    }

    std::cout << "Started render job with " << render_targets.size() << " threads." << std::endl;
    std::cout << "Buffer dimensions: " << buffer_width << "x" << buffer_height << std::endl;
    std::cout << "Render dimensions passed to threads: " << render_width << "x" << render_height << std::endl;
}

int main() {
    sf::RenderWindow window(sf::VideoMode({render_width, render_height}), "Mandelbrot MRE");
    window.setFramerateLimit(60);

    image = sf::Image({render_width, render_height}, sf::Color::Black);
    texture = sf::Texture(image);
    sprite.setTexture(texture);

    start_render_job();

    while(window.isOpen()){
        while(const auto event = window.pollEvent()) {
            if(event->is<sf::Event::Closed>())
                window.close();
            if (event->is<sf::Event::KeyPressed>() && event->getIf<sf::Event::KeyPressed>()->scancode == sf::Keyboard::Scancode::Space) {
                std::cout << "Space pressed. Simulating render restart attempt..." << std::endl;
                start_render_job();

                if (pixels) memset(pixels, 0, buffer_width * buffer_height * 4);
            }
        }

        post_processing_minimal();

        window.clear(sf::Color::Black);
        window.draw(sprite);
        window.display();

        static bool render_finished = false;
        if (!render_finished && !thread_stop_flags.empty() &&
            std::all_of(thread_stop_flags.begin(), thread_stop_flags.end(),
                        [](unsigned char state){ return state == 1 || state == 2; }))
        {
            std::cout << "All threads finished (or stopped)." << std::endl;
            render_finished = true;
        }
    }
    if (pixels) {
        delete[] pixels;
        pixels = nullptr;
    }

    return 0;
}

CMakeLists.txt associado:

cmake_minimum_required(VERSION 3.20)
project(MandelbrotMRE LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

set(CMAKE_TOOLCHAIN_FILE "$ENV{HOME}/vcpkg/scripts/buildsystems/vcpkg.cmake" CACHE STRING "Vcpkg toolchain file")

find_package(SFML 3 COMPONENTS Graphics Window System REQUIRED)

if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
    add_compile_options(-Wall -Wextra -pedantic -fPIE)
elseif(MSVC)
    add_compile_options(/W4 /MP /std:c++latest)
endif()

set(CPP_SOURCES main.cpp)

add_executable(${PROJECT_NAME} ${CPP_SOURCES})

target_link_libraries(${PROJECT_NAME} PRIVATE
        SFML::Graphics
        SFML::Window
        SFML::System
)

Detalhes do ambiente:

• SO: Arch Linux
• Compilador C++: G++
• Versão SFML: 3
• Versão do CMake: 3.20+

Perguntas específicas:

• Por que esse artefato fragmentado específico e consistente aparece durante a renderização progressiva neste código de CPU multithread?

• Como esse artefato pode ser corrigido de forma confiável?

Estou criando um valor float usando bits inteiros brutos, onde a mantissa tem todos os bits definidos como 1. No entanto, converter para double inverte o bit final para 0. Por que isso acontece? Pelo que tenho visto online, a conversão de float para double supostamente preserva a mantissa e o expoente, já que double pode acomodar todos os floats.

class Main {
    public static void main(String[] args) {
        float f = Float.intBitsToFloat((1 << 23) - 1);
        // The following line gives 23 consecutive 1s representing a mantissa with all bits set to 1.
        System.out.println(Integer.toBinaryString(Float.floatToIntBits(f)));
        double d = f;
        // The following line gives 11100000001111111111111111111111000000000000000000000000000000.
        // The mantissa has 22 consecutive 1s not 23 like in the original float
        System.out.println(Long.toBinaryString(Double.doubleToLongBits(d)));
    }
}

Estou usando o JDK 17 e adicionar strictfp à função mantém esse comportamento. Recebo um aviso informando que strictfp não é mais necessário.