Eu experimentei um pouco com os eventos enviados para um controle de botão JavaFX dependendo do que acontece com o ponteiro do mouse e gerei um diagrama de máquina de estado hierárquico (aproximado, já que meu editor não tem nenhuma noção de semântica) a partir disto:

Tudo isso é bem direto, basta rastrear o comportamento do estado inicial e ver o que acontece. Há uma sutileza aqui, pois o rótulo dentro do controle do botão também tem um papel a desempenhar, e ele gera MOUSE_ENTERED_TARGETeventos MOUSE_EXITED_TARGET(eu perguntei ao ChatGPT sobre isso e ele imprimiu uma resposta linda que estava bem errada 😂)

A única questão que me deixa curioso é: por que sempre recebo dois MOUSE_ENTEREDou dois MOUSE_EXITEDeventos, um com consumed = falsee outro com consumed = true?

Código de exemplo

Aqui está o exemplo (quase mínimo). Ele apenas cria um botão que podemos pressionar manualmente para ver quais eventos são gerados:

Arquivocom.example.stack_overflow.Main.java

package com.example.stack_overflow;

import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.event.Event;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Pane;
import javafx.scene.layout.StackPane;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

import java.util.Objects;

class PaneBuilder {

    private final StackPane stackPane;

    private static void log(String text) {
        System.out.println(text);
    }

    public PaneBuilder() {
        stackPane = buildCenteringStackPaneAroundButton(buildButton());
    }

    private static Button buildButton() {
        final var button = new Button("Click Me!");
        button.setMinWidth(120); // I think these are "120pt", why is there no "unit"?
        final var desc = "Button";
        button.addEventHandler(ActionEvent.ACTION, event -> {
            handleActionEvent(desc, event);
        });
        button.addEventHandler(MouseEvent.MOUSE_PRESSED, event -> {
            handleMouseEvent(desc, event);
        });
        button.addEventHandler(MouseEvent.MOUSE_RELEASED, event -> {
            handleMouseEvent(desc, event);
        });
        button.addEventHandler(MouseEvent.MOUSE_CLICKED, event -> {
            handleMouseEvent(desc, event);
        });
        button.addEventHandler(MouseEvent.MOUSE_ENTERED, event -> {
            handleMouseEvent(desc, event);
        });
        button.addEventHandler(MouseEvent.MOUSE_EXITED, event -> {
            handleMouseEvent(desc, event);
        });
        button.addEventHandler(MouseEvent.MOUSE_ENTERED_TARGET, event -> {
            handleMouseEvent(desc, event);
        });
        button.addEventHandler(MouseEvent.MOUSE_EXITED_TARGET, event -> {
            handleMouseEvent(desc, event);
        });
        button.armedProperty().addListener((obs, oldVal, newVal) -> log(desc + ": armed status changes: " + oldVal + " -> " + newVal));
        return button;
    }

    public Pane getPane() {
        return stackPane;
    }

    private static StackPane buildCenteringStackPaneAroundButton(Button button) {
        final var stackPane = new StackPane();
        stackPane.setAlignment(Pos.CENTER);
        final var hbox = buildHBoxAroundVBoxAroundButton(button);
        final var insets = new Insets(20, 20, 20, 20); // I guess those are "20points"
        StackPane.setMargin(hbox, insets);
        stackPane.getChildren().add(hbox);
        return stackPane;
    }

    private static HBox buildHBoxAroundVBoxAroundButton(Button button) {
        final var hbox = new HBox();
        hbox.setAlignment(Pos.CENTER);
        hbox.getChildren().add(buildVBoxAroundButton(button));
        return hbox;
    }

    private static VBox buildVBoxAroundButton(Button button) {
        final var vbox = new VBox();
        vbox.setAlignment(Pos.CENTER);
        vbox.getChildren().add(button);
        return vbox;
    }

    private static void appendEventDesc(StringBuilder buf, Event event) {
        buf.append("\n   Type          : " + event.getEventType());
        buf.append("\n   Class         : " + event.getClass().getName());
        buf.append("\n   Consumed      : " + event.isConsumed());
        buf.append("\n   Source class  : " + event.getSource().getClass().getName());
        buf.append("\n   Event         : " + Objects.toIdentityString(event));
    }

    public static void handleMouseEvent(String desc, MouseEvent event) {
        final var buf = new StringBuilder("Mouse event in " + desc);
        appendEventDesc(buf, event);
        log(buf.toString());
    }

    public static void handleActionEvent(String desc, ActionEvent event) {
        final var buf = new StringBuilder("Action event in " + desc);
        appendEventDesc(buf, event);
        log(buf.toString());
    }
}

public class Main extends Application {

    @Override
    public void start(Stage stage) {
        stage.setTitle("Button Example");
        stage.setScene(new Scene(new PaneBuilder().getPane()));
        stage.sizeToScene();
        stage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }

}

E o POM para construir e executar o acima. O programa deve ser executado com o objetivo Maven javafx:rundo plugin JavaFX Maven

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>stack_overflow</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- RUNNING VIA MAVEN + JAVAFX PLUGIN IN IDE: -->
    <!--   'Main Menu' > 'Run' > 'Run Maven Goal' > 'Plugins' > 'JavaFx Maven Plugin' > 'javafx:run' -->
    <!--   This will invoke the goal "javafx:run" of the "javafx-maven-plugin". -->
    <!--   With the 'Run New Maven Goal' menu entry, you can define that goal, and it will appear in the -->
    <!--   context menu as 'right-mouse-button menu' > 'run maven' > 'javafx:run' -->

    <!-- RUNNING VIA MAVEN IN COMMAND LINE w/o leaving the IDE (no need for OpenJDX SDK): -->
    <!-- Right-click on the project window and select "Open Terminal at the current Maven module path". -->
    <!-- Enter the command "mvn javafx:run" or for debugging output "mvn -X javafx:run". -->
    <!-- This will invoke the goal "javafx:run" of the "javafx-maven-plugin". -->

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <!-- This is the latest OpenJavaFX version on 2024-09-26 (version of 2024-09-16) -->
        <!-- https://mvnrepository.com/artifact/org.openjfx/javafx-controls -->

        <javafx.version>23</javafx.version>

        <javafx.plugin.version>0.0.8</javafx.plugin.version>
        <compiler.plugin.version>3.13.0</compiler.plugin.version>
        <exec.plugin.version>3.4.1</exec.plugin.version>
        <dependency.plugin.version>3.8.0</dependency.plugin.version>
        <main.class>com.example.stack_overflow.Main</main.class>

        <java.compiler.source.version>21</java.compiler.source.version>
        <java.compiler.target.version>21</java.compiler.target.version>

    </properties>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.openjfx/javafx-controls -->
        <dependency>
            <groupId>org.openjfx</groupId>
            <artifactId>javafx-controls</artifactId>
            <version>${javafx.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.openjfx/javafx-fxml -->
        <dependency>
            <groupId>org.openjfx</groupId>
            <artifactId>javafx-fxml</artifactId>
            <version>${javafx.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>

            <!-- Standard Java Compiler Plugin -->
            <!-- https://maven.apache.org/plugins/maven-compiler-plugin/ -->
            <!-- https://mvnrepository.com/artifact/org.apache.maven.plugins/maven-compiler-plugin -->

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${compiler.plugin.version}</version>
                <configuration>
                    <source>${java.compiler.source.version}</source>
                    <target>${java.compiler.target.version}</target>
                </configuration>
            </plugin>

            <!-- Special Plugin to run JavaFX programs -->
            <!-- https://github.com/openjfx/javafx-maven-plugin -->
            <!-- https://mvnrepository.com/artifact/org.openjfx/javafx-maven-plugin -->
            <!-- If you run the plugin's goal on the command line with the '-X' option like so: -->
            <!-- mvn -X javafx:run -->
            <!-- you will see the command line the plugin builds, which looks as follows, with ++ replaced by double dash -->

            <plugin>
                <groupId>org.openjfx</groupId>
                <artifactId>javafx-maven-plugin</artifactId>
                <version>${javafx.plugin.version}</version>
                <configuration>
                    <mainClass>${main.class}</mainClass>
                    <options>
                        <option>-ea</option>
                    </options>
                </configuration>
            </plugin>

        </plugins>
    </build>
</project>

Executar este programa abre esta janela:

Se agora seguirmos o caminho vermelho indicado com o ponteiro do mouse, clicarmos com o mouse e movermos o ponteiro do mouse para fora do botão novamente:

obtemos as seguintes alterações no valor do armedatributo e eventos emitidos pelo botão. Note o double MOUSE_ENTEREDcom consumed= false, então true.

Entrando no controle do botão:

Mouse event in Button
   Type          : MOUSE_ENTERED
   Class         : javafx.scene.input.MouseEvent
   Consumed      : false
   Source class  : javafx.scene.control.Button
   Event         : javafx.scene.input.MouseEvent@2ebee20a
Mouse event in Button
   Type          : MOUSE_ENTERED
   Class         : javafx.scene.input.MouseEvent
   Consumed      : true
   Source class  : javafx.scene.control.Button
   Event         : javafx.scene.input.MouseEvent@2ebee20a

Inserindo o rótulo do controle do botão:

Mouse event in Button
   Type          : MOUSE_ENTERED_TARGET
   Class         : javafx.scene.input.MouseEvent
   Consumed      : false
   Source class  : javafx.scene.control.Button
   Event         : javafx.scene.input.MouseEvent@5d41df9f

Ao clicar, observe a mudança no status de armed.

Mouse event in Button
   Type          : MOUSE_PRESSED
   Class         : javafx.scene.input.MouseEvent
   Consumed      : false
   Source class  : javafx.scene.control.Button
   Event         : javafx.scene.input.MouseEvent@3df998ed
Button: armed status changes: false -> true
Mouse event in Button
   Type          : MOUSE_RELEASED
   Class         : javafx.scene.input.MouseEvent
   Consumed      : false
   Source class  : javafx.scene.control.Button
   Event         : javafx.scene.input.MouseEvent@241a11d5
Action event in Button
   Type          : ACTION
   Class         : javafx.event.ActionEvent
   Consumed      : false
   Source class  : javafx.scene.control.Button
   Event         : javafx.event.ActionEvent@3d8fce01
Button: armed status changes: true -> false
Mouse event in Button
   Type          : MOUSE_CLICKED
   Class         : javafx.scene.input.MouseEvent
   Consumed      : false
   Source class  : javafx.scene.control.Button
   Event         : javafx.scene.input.MouseEvent@505036ef

Saindo do rótulo do controle do botão:

Mouse event in Button
   Type          : MOUSE_EXITED_TARGET
   Class         : javafx.scene.input.MouseEvent
   Consumed      : false
   Source class  : javafx.scene.control.Button
   Event         : javafx.scene.input.MouseEvent@2d496725

Saindo do controle de botão:

Mouse event in Button
   Type          : MOUSE_EXITED
   Class         : javafx.scene.input.MouseEvent
   Consumed      : false
   Source class  : javafx.scene.control.Button
   Event         : javafx.scene.input.MouseEvent@59a94fe0
Mouse event in Button
   Type          : MOUSE_EXITED
   Class         : javafx.scene.input.MouseEvent
   Consumed      : true
   Source class  : javafx.scene.control.Button
   Event         : javafx.scene.input.MouseEvent@59a94fe0

Tenho um conjunto de dados em R que se parece com isto:

data = structure(list(quarter = c("Q1 2005", "Q2 2005", "Q3 2005", "Q4 2005", 
"Q1 2006"), value = c(128.76, 178.83, 140.9, 188.3, 194.05)), class = "data.frame", row.names = c(NA, 
-5L))

Quero expandir esse conjunto de dados para ter uma coluna extra chamada "mês" (por exemplo, jan, fev, mar...) ... e quero dividir a diferença entre todos os meses entre trimestres sucessivos para que os números ainda somem entre os trimestres.

Tentei fazer assim:

library(dplyr)

expand_dataset <- function(data) {
quarter_to_months <- list(
    "Q1" = c("Jan", "Feb", "Mar"),
    "Q2" = c("Apr", "May", "Jun"),
    "Q3" = c("Jul", "Aug", "Sep"),
    "Q4" = c("Oct", "Nov", "Dec")
    )

expanded_data <- data.frame()

for (i in 1:(nrow(data) - 1)) {
    current_value <- data$value[i]
    next_value <- data$value[i + 1]
    
    diff <- (next_value - current_value) / 3
    
    quarter <- substr(data$quarter[i], 1, 2)
    year <- substr(data$quarter[i], 4, 7)
    months <- quarter_to_months[[quarter]]
    
    for (j in 1:3) {
        month_value <- current_value + (j - 1) * diff
        expanded_data <- rbind(expanded_data, data.frame(
            quarter = data$quarter[i],
            month = months[j],
            year = year,
            value = month_value
        ))
    }
    }

return(expanded_data)
}

expanded_data <- expand_dataset(data)
print(expanded_data)

Essa é a maneira correta de fazer isso? Existe uma maneira mais fácil de fazer isso?

Estou tentando obter todas as propriedades de uma classe que tem um setter privado. Isso parece muito simples, no entanto, me deparo com um comportamento estranho, mas provavelmente normal.

Esta é a solução que implementei

public static IEnumerable<PropertyInfo> InstanceProperties(this Type type) {
    List<PropertyInfo> results = new();
    var allProperties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
    foreach (var property in allProperties) {
        var setMethod = property.GetSetMethod(true);
        if (setMethod != null && setMethod.IsPrivate) {
            results.Add(property);
        }
    }
    return results;
}

Criei algumas classes simples para teste também

public class BaseClass {
    public string Name { get; private set; }
    public BaseClass(string name) {
        Name = name;
    }
}

public class DerivedClass : BaseClass {
    public string Description { get; private set; }
    public DerivedClass(string name, string description) : base(name) {
        Description = description;
    }
}

Para testar isso estou usando

[Fact]
public void InstanceProperties_WithBaseType_ReturnsAllProperties() {
    // Arrange
    Type baseEntityType = typeof(BaseClass);
    // Act
    var result = baseEntityType.InstanceProperties();
    // Assert
    result.Should().NotBeNullOrEmpty();
    result.Count().Should().Be(1);
}

[Fact]
public void InstanceProperties_WithDerivedType_ReturnsAllProperties() {
    // Arrange
    Type baseEntityType = typeof(DerivedClass);
    // Act
    var result = baseEntityType.InstanceProperties();
    // Assert
    result.Should().NotBeNullOrEmpty();
    result.Count().Should().Be(2);
}

O primeiro teste é bem-sucedido enquanto o segundo falha. Mais especificamente no segundo teste, o código var allProperties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);retorna duas propriedades, porém a propriedade da classe base não tem um método setter. Isso não é propriamente coerente com o primeiro teste, pois nesse caso a propriedade tem um método set que é definido como privado.

Alguma sugestão/explicação sobre esse comportamento?

EDIT Conforme sugestões dos comentários, explico melhor o escopo da questão. O objetivo final é construir alguns tipos de objetos que tenham as seguintes características:

• Podem ser classes que herdam diretamente de uma classe base bem conhecida (por exemplo Entity) que têm uma única propriedade de instância exclusiva do tipo Guid com um setter privado
• Podem ser classes que herdam de uma classe base abstrata que por sua vez herda deEntity
• Todas as propriedades de instância têm um setter privado
• Todas as classes têm um único método de fábrica estático público chamado Createcom, é claro, parâmetros diferentes para cada classe

Gostaria de entender como essa técnica de construção é manipulada pelo Entity Framework, que usa um construtor privado sem parâmetros para criar instâncias de objetos.

EDITAR 2

Acabei escrevendo uma solução que é muito parecida com as duas apresentadas por Jamiec e Gert Arnold. Estou escrevendo aqui para referência. Obrigado a todos!

public static IEnumerable<PropertyInfo> InstanceProperties(this Type type) {
    List<PropertyInfo> results = new();
    Type? leafType = type;
    while (leafType != null) {
        var allProperties = leafType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
        foreach (var property in allProperties) {
            var accessors = property
                .GetAccessors(true)
                .Where(a => a.ReturnType == typeof(void) && a.IsPrivate)
                .ToArray();
            foreach (var accessor in accessors) {
                results.Add(property);
            }
        }
        leafType = leafType.BaseType;
    }
    return results;
}

Tenho um conjunto de dados que contém várias variáveis ​​de interesse. O que eu gostaria de fazer é calcular uma média móvel com a rollapplyr()função do zoopacote para cada uma delas como colunas adicionais, mas a ressalva é que eu gostaria de usar uma largura de janela diferente ( width =) dependendo da coluna. Também desejo evitar pivotar meus dados para o formato longo.

library(tidyverse)
library(zoo)

rolling_f <- function(x, wdw, fun){ rollapplyr(x, wdw, fun, partial = TRUE) }

set.seed(1)
ex <- data.frame(
  var1 = rnorm(20, 8000, 500),
  var2 = rnorm(20, 8000, 500),
  var3 = rnorm(20, 8000, 500),
  var4 = rnorm(20, 8000, 500),
  var5 = rnorm(20, 8000, 500),
  var6 = rnorm(20, 8000, 500),
  var7 = rnorm(20, 8000, 500),
  var8 = rnorm(20, 8000, 500)
  ) %>%
  mutate(
    across(
      .cols = starts_with("var"),
      .fns = ~rolling_f(.x, 5, mean),
      .names = "{.col}_roll"
      )
    )

Meu código até agora calcula a mesma largura de janela (5) para cada coluna, mas espero que alguém possa me ajudar a definir minha função personalizada melhor para que a janela possa ser 3 para var1:var3, 5 para var4:var5, e 6 para var6:var8, como um exemplo. Presumo que isso simplesmente exigirá algum código adicional na rolling_f()função personalizada que comecei.

Como um experimento mental, estou tentando descobrir qual é a maneira mais eficiente de executar o bit a bit ou em máscaras de bits de tamanho relativamente grande (~1M elementos u64) em um único thread.

Estou executando-o no meu laptop com CPU i7-8750H a 2,2 GHz, que suporta AVX2, mas não AVX-512. Como mencionei antes, estou tentando descobrir o que posso extrair de um único thread. Além disso, tenho quase certeza de que compactar minhas máscaras de bits em algo como bitmaps rugindo provavelmente produzirá acelerações adicionais, pois eu teria que ingerir menos bytes na CPU. Mas gostaria de entender primeiro se há algo obviamente errado com o que estou fazendo na minha implementação atual bastante simples. Estou mirando x86-64.

Tentei estimar qual é o teto de velocidade dessa operação. Vamos começar com a suposição obviamente muito errada de que todos os dados já estão nos registradores. _mm256_or_si256pode executar uma operação bit a bit ou em 4x u64s. Vou assumir que posso executar apenas uma operação desse tipo por ciclo, o que provavelmente também está errado e posso fazer 2-3. Vamos usar u64vetores de 1M s para nossos testes. Isso nos dá 1M / 4 per cycle = 250K cycles. Sob carga, a taxa de clock da minha CPU fica em ~3GHz. Isso nos dá 250K cycles / 3Ghz ~ 0.00008(3)sec ~ 83µs. Esse é o nosso teto ingenuamente rápido que usaremos como valor de referência.

Vamos transformá-lo em código. Usei o ChatGPT para gerar um grande pedaço dele, desculpe antecipadamente, não sou um desenvolvedor C++ e sou relativamente ignorante em desenvolvimento de baixo nível.

#include <iostream>
#include <vector>
#include <random>
#include <chrono>
#include <cstdint>
#include <immintrin.h>

std::vector<uint64_t> generate_random_u64s(size_t amount) {
    std::vector<uint64_t> random_u64s;
    random_u64s.reserve(amount);
    std::random_device rd; // Obtain a random number from hardware
    std::mt19937_64 eng(rd()); // Seed the generator
    std::uniform_int_distribution<uint64_t> distr; // Define the range

    for (size_t i = 0; i < amount; ++i) {
        random_u64s.push_back(distr(eng));
    }
    return random_u64s;
}

void avx_bitwise_or(
    const std::vector<uint64_t>& vector1, 
    const std::vector<uint64_t>& vector2, 
    std::vector<uint64_t>& result
) {
    size_t size = vector1.size();
    
    // Ensure result has enough space
    if (result.size() != size) {
        result.resize(size);
    }

    size_t i = 0;
    for (; i + 4 <= size; i += 4) {
        // Prefetch data into CPU cache
        _mm_prefetch(reinterpret_cast<const char*>(&vector1[i + 256]), _MM_HINT_T0);
        _mm_prefetch(reinterpret_cast<const char*>(&vector2[i + 256]), _MM_HINT_T0);

        // Load vectors using AVX
        __m256i vec1 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&vector1[i]));
        __m256i vec2 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&vector2[i]));

        // Perform bitwise OR operation
        __m256i vec_result = _mm256_or_si256(vec1, vec2);

        // Use non-temporal store to write result back to memory bypassing CPU cache
        _mm256_stream_si256(reinterpret_cast<__m256i*>(&result[i]), vec_result);
    }

    // Handle remaining elements that don't fit in AVX registers
    for (; i < size; ++i) {
        result[i] = vector1[i] | vector2[i];
    }
}

int main() {
    std::cout << "Starting" << std::endl;
    const size_t size = 1'000'000;
    auto vector1 = generate_random_u64s(size);
    auto vector2 = generate_random_u64s(size);

    auto result = std::vector<uint64_t>(size);

    auto start = std::chrono::high_resolution_clock::now();
    const int repetitions = 10000;

    for (int i = 0; i < repetitions; ++i) {
        avx_bitwise_or(vector1, vector2, result);
    }

    auto duration = std::chrono::high_resolution_clock::now() - start;

    uint32_t popcnt = 0;
    for (const auto& x : result) {
        popcnt += __builtin_popcountll(x); // Count the number of set bits (1s)
    }

    std::cout << "Popcnt is: " << popcnt << std::endl;
    std::cout << "Time elapsed is: " << std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() << " ms" << std::endl;

    return 0;
}

Eu o construo com g++ -O3 -mavx2 -o experiment main.cpp. Quando estou executando, leva cerca de 9 segundos para executar 10.000 iterações, o que é 900 µs por iteração. Isso é ~10+ vezes mais lento do que nossos cálculos ingênuos de trás do envelope. Tentei desenrolar os loops, mas não me deu nenhum resultado de desempenho tangível. Talvez eu tenha feito errado de alguma forma.

Vamos contrastar com o código que evita a leitura da memória:

uint64_t single_register_test (
    const std::vector<uint64_t>& vector1, 
    const std::vector<uint64_t>& vector2
) {
    size_t size = vector1.size();

    // Load vectors using AVX, use only first 4 elements and ignore everything else
    __m256i vec1 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&vector1[0]));
    __m256i vec_result = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&vector2[0]));

    // Perform bitwise OR operation on the same data over and over again
    for (size_t i = 0; i + 4 <= size; i += 4) {
        vec_result = _mm256_or_si256(vec1, vec_result);
    }

    // Get first u64 from the result
    auto result = _mm256_extract_epi64(vec_result, 0);

    return result;
}

// ...........

    auto start = std::chrono::high_resolution_clock::now();
    const int repetitions = 100'000;

    uint32_t popcnt_single = 0;
    for (int i = 0; i < repetitions; ++i) {
        auto x = single_register_test(vector1, vector2);
        popcnt_single += __builtin_popcountll(x);
    }
    std::cout << "Popcnt single is: " << popcnt_single << std::endl;
    auto duration = std::chrono::high_resolution_clock::now() - start;

Foram necessários cerca de 9 segundos para uma iteração de 100K para o mesmo 1M x u64vetor, o que equivale a 90 µs por iteração, muito próximo do nosso valor de referência ingênuo de 83 µs.

Então, eu me pergunto o que posso fazer para aumentar ainda mais o desempenho do meu código que lê da memória? Há algo que eu possa fazer?

Considere o código de exemplo de brinquedo abaixo. Ele tem uma estrutura de dados muito grande para copiar MyDataStructuree uma pequena classe iteradora MyDataIteratorque o chamador pode instanciar para iterar sobre os dados na estrutura.

Na versão de brinquedo do código, a estrutura de dados contém apenas 10 inteiros (1000-1009) e a WORKING CODEseção main()itera sobre eles corretamente, como esperado.

Entretanto, a segunda BROKEN CODEseção ( ) main()não itera sobre eles corretamente; ela invoca um comportamento indefinido porque chama GetDataStructureByValue()em vez de GetDataStructureByReference(), o que significa que a MyDataStructurereferência iterarmazenada em sua _dsvariável membro privada se torna uma referência pendente antes da primeira iteração do loop.

Este é um problema um tanto insidioso, porque em código não-de-brinquedo nem sempre é fácil dizer/lembrar pelo nome de uma função se ela está retornando por valor ou por referência, mas o primeiro caso resulta em um bug de tempo de execução não óbvio, enquanto o último caso funciona bem.

Minha pergunta é: existe alguma maneira razoável de fazer um compilador C++ moderno dar erro ou pelo menos avisar sobre o caso problemático? Suspeito que não, mas estou perguntando mesmo assim porque me sentiria mais seguro se instâncias desse problema pudessem ser sinalizadas automaticamente para mim de alguma forma.

O código-fonte do programa de brinquedo está abaixo, seguido por um exemplo de sua saída no meu Mac executando o XCode:

#include <stdio.h>

class MyDataStructure
{
public:
   MyDataStructure()
   {
      printf("MyDataStructure CTOR %p\n", this);
      for (int i=0; i<10; i++) _data[i] = i+1000;
   }

   ~MyDataStructure()
   {
      printf("MyDataStructure DTOR %p\n", this);
      for (int i=0; i<10; i++) _data[i] = -1;  // just to make the symptoms more obvious
   }

   bool IsPositionValid(int pos) const {return ((pos >= 0)&&(pos < 10));}

   int GetValueAt(int pos) const {return _data[pos];}

private:
   int _data[10];
};

const MyDataStructure & GetDataStructureByReference()
{
   static MyDataStructure _ds;
   return _ds;
}

MyDataStructure GetDataStructureByValue()
{
   MyDataStructure _ds;
   return _ds;
}

class MyDataIterator
{
public:
   MyDataIterator(const MyDataStructure & ds) : _ds(ds), _idx(0) {/* empty */}

   bool HasValue() const {return _ds.IsPositionValid(_idx);}
   int  GetValue() const {return _ds.GetValueAt(_idx);}

   void operator++(int) {_idx++;}

   const MyDataStructure & GetDataStructure() const {return _ds;}

private:
   const MyDataStructure & _ds;
   int _idx;
};

int main(int, char **)
{
   {
      // The following line of code is okay; it counts from 1000 to 10009, as expected
      printf("WORKING CODE:\n");
      for (MyDataIterator iter(GetDataStructureByReference()); iter.HasValue(); iter++) printf("iter returned %i from %p\n", iter.GetValue(), &iter.GetDataStructure());
   }

   {
      // The following line of code is buggy because, the MyDataStructure object that (iter) keeps a reference to
      // gets destroyed before the first iteration of the loop.
      printf("\nBROKEN CODE:\n");
      for (MyDataIterator iter(GetDataStructureByValue()); iter.HasValue(); iter++) printf("iter returned %i from %p\n", iter.GetValue(), &iter.GetDataStructure());
   }

   printf("\nEND OF PROGRAM\n");
   return 0;
}

... exemplo de saída:

$ ./a.out
WORKING CODE:
MyDataStructure CTOR 0x1015c4000
iter returned 1000 from 0x1015c4000
iter returned 1001 from 0x1015c4000
iter returned 1002 from 0x1015c4000
iter returned 1003 from 0x1015c4000
iter returned 1004 from 0x1015c4000
iter returned 1005 from 0x1015c4000
iter returned 1006 from 0x1015c4000
iter returned 1007 from 0x1015c4000
iter returned 1008 from 0x1015c4000
iter returned 1009 from 0x1015c4000

BROKEN CODE:
MyDataStructure CTOR 0x7ff7be93d198
MyDataStructure DTOR 0x7ff7be93d198
iter returned -1 from 0x7ff7be93d198
iter returned -1 from 0x7ff7be93d198
iter returned -1 from 0x7ff7be93d198
iter returned -1 from 0x7ff7be93d198
iter returned -1 from 0x7ff7be93d198
iter returned -1 from 0x7ff7be93d198
iter returned -1 from 0x7ff7be93d198
iter returned -1 from 0x7ff7be93d198
iter returned -1 from 0x7ff7be93d198
iter returned -1 from 0x7ff7be93d198

END OF PROGRAM
MyDataStructure DTOR 0x1015c4000

Tenho usado try-with-resourcesmuito. Uso para tipos de recursos de banco de dados ou Filecoisas assim o tempo todo para fechar o recurso.

Agora, estou usando POI para arquivos grandes do Excel e estou percebendo que devo chamar workbook.dispose(). O try-with-resources chamará o dispose()método? Tudo o que pesquisei abrange apenas close().

Não estou convencido de que a duplicata seja a mesma pergunta. Minha pergunta pergunta especificamente se Disposeis handled by try-with-resource. Nenhuma das outras perguntas menciona Dispose.

Estou tentando aprender intervalos em C++. Até onde posso ver, a maneira mais simples (e a única, além de implementar uma classe de visualização de intervalo personalizada) de criar um objeto de visualização de intervalo que gere uma sequência personalizada é usar C++23' std::generator<>:

std::generator<char> letters_gen(char start)
{
    for (;;) co_yield start++;
}

Como eu uso um std::generatorobjeto (como criado ao invocar letters_gen()) em múltiplas expressões envolvendo operações de intervalo? Por exemplo, se eu quiser coletar 10 letras em um vetor e, então, mais 15 letras em outro vetor:

int main()
{
    auto letters = letters_gen('a');
    auto x = letters | std::views::take(10) | std::ranges::to<std::vector>();
    auto y = letters | std::views::take(15) | std::ranges::to<std::vector>();
}

Isto não compila:

main.cc:150:26: error: no match for ‘operator|’ (operand types are ‘std::generator<char>’ and ‘std::ranges::views::__adaptor::_Partial<std::ranges::views::_Take, int>’)

Qual é a maneira correta, se houver, de obter o efeito desejado?

Abaixo está minha solução para a Semana 4 do CS50: Volume . O problema que eu estava tentando resolver era ler um arquivo .wav e alterar seu volume com base em um argumento de linha de comando 'factor'.

Problema: Quando eu estava testando este código, usei inicialmente fread(header, HEADER_SIZE, 1, input); Meu código seria compilado sem erros e um arquivo de saída seria produzido para o seguinte: ./volume input.wav output.wav 1.0

Mas um arquivo de saída corrompido seria produzido se eu alterasse o fator de volume para qualquer valor diferente de 1,0.

// Modifies the volume of an audio file

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

// Number of bytes in .wav header
const int HEADER_SIZE = 44;

void copy_header(FILE *input, FILE *output);
void copy_samples(FILE *input, FILE *output, float factor);

int main(int argc, char *argv[])
{
    // Check command-line arguments
    if (argc != 4)
    {
        printf("Usage: ./volume input.wav output.wav factor\n");
        return 1;
    }

    // Open files and determine scaling factor
    FILE *input = fopen(argv[1], "r");
    if (input == NULL)
    {
        printf("Could not open file.\n");
        return 1;
    }

    FILE *output = fopen(argv[2], "w");
    if (output == NULL)
    {
        printf("Could not open file.\n");
        return 1;
    }

    float factor = atof(argv[3]);

    copy_header(input, output);
    copy_samples(input, output, factor);

    // Close files
    fclose(input);
    fclose(output);
}

void copy_header(FILE *input, FILE *output)
    {
        uint8_t header[HEADER_SIZE];

        fread(header, sizeof(HEADER_SIZE), 1, input);
        fwrite(header, sizeof(HEADER_SIZE), 1, output);
        printf("header: %s; header_size: %lu; HEADER_s: %lu\n", header, sizeof(header), sizeof(HEADER_SIZE));
    }

void copy_samples(FILE *input, FILE *output, float factor)
{
    int16_t buffer;

    while (fread(&buffer, sizeof(int16_t), 1, input) != 0)
    {
        buffer = buffer * factor;
        fwrite(&buffer, sizeof(int16_t), 1, output);
    }
}

Depois de muita pesquisa, descobri que a saída para:

printf("header: %s; header_size: %lu; HEADER_s: %lu\n", header, sizeof(header), sizeof(HEADER_SIZE)); Seria:

header: RIFFDb; header_size: 44; HEADER_s: 4

Por que o valor de sizeof(HEADER_SIZE) mudou para 4? Estou perdendo completamente alguma coisa aqui? Abordei esse problema corretamente?

Corrigi o erro no meu código usando: fread(header, sizeof(header), 1, input);

Mas eu quero saber por que e como eu estraguei esse código. Obrigado antecipadamente!

Quero gerar um subconjunto de uma lista de nomes de caminho, condicional a caracteres nos elementos da lista (prefixo no nome do arquivo). Posso fazer um for loop funcionar, mas quero fazer isso usando sapplyporque acho que é uma abordagem melhor.

Funciona for loop; o resultado é uma lista de nomes de caminho com nomes de arquivo começando com 500 ou mais. SapplyNão funciona; inão itera como eu esperava, mas pode haver outros problemas ao anexar o elemento à nova lista.

# -----------------------------------------
# add pathnames to files that have a prefix of less than 500,
# to a new list
# -----------------------------------------

# make list
# myList <- list.files(path = "D:/test", pattern = "*.txt")
myList <- list("D:/test/472_a.txt", "D:/test/303_b.txt", "D:/test/500_a.txt", "D:/test/505_b.txt", "D:/test/700_a.txt")
# preallocate subsetted list
myListSubset <- vector("list", length = length(myList))


# -----------------------------------------
# for loop - this works
# -----------------------------------------
for (i in 1:length(myList)) {
  print(paste("i is", i))
  print(paste(i, "element of myList is", myList[i]))
  swath <- str_sub(basename(paste(myList[i], collapse = "")), 1, 3)
  # only add swaths ge to 500 to the subsetted list
  if (swath >= 500) {
    print(paste("swath #", swath))
    myListSubset[[i]] <- paste(myList[i], collapse = "")
  }
} 
# remove Null elements
print(myListSubset)
myListSubset[sapply(myListSubset, is.null)] <- NULL
print(myListSubset)
# -----------------------------------------



# -----------------------------------------
# sapply - this does not work
# -----------------------------------------
i <- 1
sapply(myList, function(s){
  swath <- str_sub(basename(s), 1, 3) # swath is the 1st 3 digits in file name
  print(paste("swath #", swath))
  if (swath >= 500) {
    print(paste("list element is", s, "and the class is", class(s)))
    print(paste("i is", i, "and the class is", class(i)))
    myListSubset[[i]] <- s
    i <- (i + 1)
    print(paste("i is", i))
  }
}
)
# remove Null elements
print(myListSubset)
myListSubset[sapply(myListSubset, is.null)] <- NULL
print(myListSubset)
# -----------------------------------------