All perguntas(coding)

Estou com problemas para usar importmap-railspara gerenciar pacotes npm. Eu gostaria que ele funcionasse como o yarn, onde ele mantém o controle de versões, dependências e baixa tudo para você com um comando como yarn install.

Mas parece que ele importmap-railssó está configurado para usar um cdn quando você fixa algo. Isso é verdade? Ou ele pode baixar pacotes e suas dependências com um comando como o yarn?

Se não puder fazer isso, posso usar importmap-railso yarn como meu gerenciador de pacotes? Tentei isso com underscore.js e tive alguns problemas.

1. Executei yarn add underscore, vi que foi baixado corretamente e então adicionado node_modulesaos caminhos de ativos para que propshafteu importmap-railssoubesse como procurar lá:

config/application.rb
config.assets.paths << Rails.root.join('node_modules')

Em seguida, fixei a pasta sublinhada:

# config/importmap.rb
pin_all_from 'node_modules/underscore', under: 'underscore'

Em seguida, importei a funcionalidade que eu precisava:

// from a custom js file
import debounce from 'underscore/modules/debounce';

A execução ./bin/importmap jsonmostrou que o arquivo debounce.js foi encontrado:

{
  "imports": {
    "application": "/assets/application-bd82d6ab.js",
    "underscore/amd/_baseCreate": "/assets/underscore/amd/_baseCreate-7eccab16.js",
    "underscore/amd/_baseIteratee": "/assets/underscore/amd/_baseIteratee-5f781255.js",
    "underscore/amd/_cb": "/assets/underscore/amd/_cb-dd403ec6.js",
    "underscore/amd/_chainResult": "/assets/underscore/amd/_chainResult-4b98e265.js",
    "underscore/amd/_collectNonEnumProps": "/assets/underscore/amd/_collectNonEnumProps-ed4c206f.
...
    "underscore/modules/debounce": "/assets/underscore/modules/debounce-decaec4e.js",

E no navegador não obtive nenhum erro para debounce.js, ele foi identificado e encontrado, mas dentro desse arquivo ele estava usando caminhos relativos para importar outras funções que causaram erros 404. Também havia uma solicitação get indo para cada arquivo em underscore, o que também não é bom.

15:41:34 web.1  | Completed 200 OK in 5482ms (Views: 2431.0ms | ActiveRecord: 557.1ms (24 queries, 6 cached) | GC: 368.1ms)
15:41:34 web.1  | 
15:41:34 web.1  | 
15:41:34 web.1  | Started GET "/assets/underscore/amd/_baseCreate-7eccab16.js" for ::1 at 2024-12-20 15:41:34 -0500
15:41:35 web.1  | Started GET "/assets/underscore/amd/_baseIteratee-5f781255.js" for ::1 at 2024-12-20 15:41:35 -0500
15:41:35 web.1  | Started GET "/assets/underscore/amd/_cb-dd403ec6.js" for ::1 at 2024-12-20 15:41:35 -0500
15:41:35 web.1  | Started GET "/assets/underscore/amd/_chainResult-4b98e265.js" for ::1 at 2024-12-20 15:41:35 -0500
15:41:35 web.1  | Started GET "/assets/underscore/amd/_collectNonEnumProps-ed4c206f.js" for ::1 at 2024-12-20 15:41:35 -0500
15:41:35 web.1  | Started GET "/assets/underscore/amd/_createAssigner-aa588b74.js" for ::1 at 2024-12-20 15:41:35 -0500
15:41:36 web.1  | Started GET "/assets/underscore/amd/_createEscaper-3ea6026c.js" for ::1 at 2024-12-20 15:41:36 -0500
15:41:36 web.1  | Started GET "/assets/underscore/amd/_createPredicateIndexFinder-f577fa32.js" for ::1 at 2024-12-20 15:41:36 -0500
...

debounce-decaec4e.js:1 
GET http://localhost:3000/assets/underscore/modules/restArguments.js 404 (Not Found)

debounce-decaec4e.js:2 
GET http://localhost:3000/assets/underscore/modules/now.js net::ERR_ABORTED 404 (Not Found)

debounce-decaec4e.js
import restArguments from './restArguments.js';
import now from './now.js';

Então, posso usar importmap-rails com o yarn ou em vez do yarn para pacotes npm?

Pesquisei no Google e examinei a documentação e só encontrei esta breve descrição: https://github.com/rails/importmap-rails/blob/main/README.md#using-npm-packages-via-javascript-cdns

Para contexto extra, acabei de atualizar nosso aplicativo rails 7 para rails 8, então fomos de sprockets, yarn, webpacker para propshaft com importmap-rails. Feliz por estar sem webpacker, mas sentindo falta da funcionalidade yarn.

Estou investigando um bloco de código (que não escrevi) que se parece com:

customType foo::bar(void) const const {
    // baz
}

Até onde eu entendo, o const constdeveria ser apenas const. Não consigo encontrar nenhuma referência a um uso válido de constque tenha duas const palavras-chave após a declaração do nome da função.

Estou esquecendo de algum uso válido e esotérico de constaqui? Isso me parece inválido.

Estou considerando um projeto de análise de dados envolvendo informações sobre transmissões de TV japonesas. Os dados relevantes incluirão horários de transmissão, e alguns deles serão de programas que foram ao ar tarde da noite.

A programação da TV japonesa de fim de noite segue um formato de tempo não padrão chamado sistema de 30 horas (breve explicação em inglês aqui ). A maioria dos horários é dada no horário padrão do Japão, formatado como %H:%M. Os horários da meia-noite às 6 da manhã, no entanto, são tratados como uma extensão do dia anterior e numerados de acordo, sob a lógica de que é assim que as pessoas que ficam acordadas até tarde os vivenciam. Por exemplo, Macross Frontier foi transmitido em Kansai à 1:25 da manhã, mas foi escrito como 25:25.

Quero usar esses dados em um Pandas ou Polars DataFrame. Teoricamente, eles poderiam ser deixados como uma string, mas seria mais útil convertê-los para um formato padrão para datetimes -- seja o tipo interno do Python ou os tipos usados ​​no NumPy ou Polars. Uma abordagem simples poderia ser:

from datetime import date, time, datetime
from zoneinfo import ZoneInfo

def process_30hour(d: date, t: str):
    h, m = [int(n) for n in t.split(':')] # assumes format 'HH:MM' for t
    if h > 23:
        h -= 24
        d += 1
    return datetime.combine(d, time(h, m), ZoneInfo('Japan'))

Isso poderia então ser aplicado a um DataFrame inteiro com DataFrame.apply(). Pode haver uma maneira mais performática, no entanto, especialmente considerando os recursos de vetorização de DataFrames -- ambas as bibliotecas recomendam evitar DataFrame.apply()se houver uma alternativa.

Estou tentando criar um novo aplicativo vue 3, mas tenho um problema com a criação.

Versão do nó: 22.10.0 Versão do Npm: 10.9.0

Eu crio meu projeto com: npm create vue@latest como na documentação

E quando tento executar o código comnpm run dev

Eu recebi esse erro

X [ERROR] Expected identifier but found "import"

    (define name):1:0:
      1 │ import.meta.url
        ╵ ~~~~~~

failed to load config from C:\Apache24\htdocs\testvue3\vite.config.mjs
error when starting dev server:
Error: Build failed with 3 errors:
(define name):1:0: ERROR: Expected identifier but found "import"

Ainda não toquei em nenhuma linha de código e o problema parece vir do arquivo vite.config.ts abaixo

import { fileURLToPath, URL } from 'node:url'

import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
import vueDevTools from 'vite-plugin-vue-devtools'

// https://vite.dev/config/
export default defineConfig({
  plugins: [
    vue(),
    vueDevTools(),
  ],
  resolve: {
    alias: {
      '@': fileURLToPath(new URL('./src', import.meta.url))
    },
  },
})

Em uma proposta padrão C++ , encontro um trecho de código estranho como o seguinte:

template <input_iterator I, sentinel_for<I> S, nothrow_forward_iterator I2>
constexpr auto uninitialized_copy(I first, S last, I2 d_first) -> I2 {
    using T = iter_value_t<I2>;
    I2 current = d_first;
    try {
        for (; first != last; ++first, (void)++current) {
            ::new (std::addressof(*current)) T(*first);
        }
    } catch (...) {
        std::destroy(d_first, current);
        throw;
    }
}

Por que usar (void)++current em vez de apenas ++current aqui?

Como o C++20 nos deu lambdas em contexto não avaliado, posso escrever o seguinte código.

template <class = decltype([]{})>
class MyType {};

Se eu incluísse essa definição em várias TUs, isso seria uma violação do ODR?

Estou analisando em particular o §6.3(13.13) do N4860:

Em cada uma dessas definições, [...] um argumento de modelo padrão usado por um template-id (implícito ou explícito) ou simple-template-id é tratado como se sua sequência de tokens estivesse presente na definição de D; ou seja, o argumento padrão ou argumento de modelo padrão está sujeito aos requisitos descritos neste parágrafo (recursivamente).

que eu li como, decltype([]{})é parte do tipo declarado, que é então um exemplo explicitamente rotulado como inválido pelo artigo original (§4). Estou lendo isso corretamente?

Edição 1: aqui está outra citação do mesmo parágrafo do padrão que considero muito confusa:

Pode haver mais de uma definição de uma
[...]
(13.4) — entidade modelo (13.1),
[...]
(13.6) — argumento modelo padrão
em um programa, desde que cada definição apareça em uma unidade de tradução diferente e as definições satisfaçam os seguintes requisitos. Dada tal entidade D definida em mais de uma unidade de tradução, para todas as definições de D, [...] os seguintes requisitos devem ser satisfeitos.
[...]
(13.10) — Em cada uma dessas definições, exceto dentro dos argumentos padrão e argumentos modelo padrão de D, as expressões lambda correspondentes devem ter o mesmo tipo de fechamento (veja abaixo).

Agora, podemos aplicar este parágrafo ao meu trecho de código acima
a) tomando D como o modelo de classe (que é uma entidade modelo), em cujo caso (13.10) parece dizer que o argumento de modelo padrão está isento desta regra, ou
b) tomando D como o argumento de modelo padrão, ao qual esta regra deve ser aplicada. O "veja abaixo" no final da citação se refere, presumo, ao ponto 14:

Se D for um modelo e for definido em mais de uma unidade de tradução, os requisitos precedentes devem ser aplicados tanto aos nomes do escopo envolvente do modelo usados ​​na definição do modelo (13.8.3), quanto aos nomes dependentes no ponto de instanciação (13.8.2). Esses requisitos também se aplicam às entidades correspondentes definidas dentro de cada definição de D (incluindo os tipos de fechamento de expressões lambda, mas excluindo entidades definidas dentro de argumentos padrão ou argumentos de modelo padrão de D ou uma entidade não definida dentro de D). Para cada uma dessas entidades e para o próprio D, o comportamento é como se houvesse uma única entidade com uma única definição, incluindo na aplicação desses requisitos a outras entidades. [Nota: A entidade ainda é declarada em várias unidades de tradução, e 6.6 ainda se aplica a essas declarações. Em particular, as expressões lambda (7.5.5) que aparecem no tipo de D podem resultar em diferentes declarações tendo tipos distintos, e as expressões lambda que aparecem em um argumento padrão de D ainda podem denotar tipos diferentes em diferentes unidades de tradução. — nota final]

do qual eu entendo: se D é minha classe de modelo, o argumento de modelo padrão está isento desta regra. Mas então a nota no final continua especificando que a expressão lambda no argumento de modelo padrão pode ter tipos diferentes em TUs diferentes, portanto, presumo, quebrando ODR.

Edição 2: muito relacionado, mas ainda não consigo chegar a uma conclusão final:
Significado da observação sobre itens definidos várias vezes
As expressões lambda que aparecem em diferentes definições de uma mesma entidade produzem o mesmo tipo de fechamento?

O seguinte programa simples compila e funciona:

std::generator<int> get_ints(int n)
{
    for (int i{0}; i < n; ++i)
        co_yield i;
}

int main(int argc, char* argv[])
{
    std::vector<float> floats { 0.0f, 1.0f, 2.0f, 3.0f };

    for (auto [i, f] : std::views::zip(get_ints(4), floats))
        std::println("{}: {}", i, f);
}

Entretanto, se eu armazenar o gerador em uma variável e tentar fazer o mesmo, ele não compila:

std::generator<int> get_ints(int n)
{
    for (int i{0}; i < n; ++i)
        co_yield i;
}

int main(int argc, char* argv[])
{
    std::vector<float> floats { 0.0f, 1.0f, 2.0f, 3.0f };
    auto ints = get_ints(4);

    for (auto [i, f] : std::views::zip(ints, floats))
        std::println("{}: {}", i, f);
}

Pelo que entendi, isso falha, porque std::ranges::viewable_range<std::generator<int>&>avalia para false, enquanto std::ranges::viewable_range<std::generator<int>&&>avalia para true. Mas por que o primeiro caso é proibido? Eu sei que generatornão é um intervalo, mas ele se comporta como um e todos os outros tipos de intervalo que testei (embora eu tenha testado apenas alguns) satisfazem essa restrição quando passados ​​como uma referência lvalue. Então por que makes generatorspecial nesse caso?

Estou com dificuldade para aplicar uma função a cada elemento de uma matriz, uma matriz de similaridade de Jaccard triangular inferior.

A função deve retornar valores da matriz com valores > .7, e reatribuir outros elementos como NA, facilitando a identificação de variáveis ​​binárias altamente similares. Idealmente, a estrutura da matriz é preservada.

Criei uma matriz de amostra simples 3x3 preenchida com valores aleatórios para teste:

N <- 3 # Observations
N_vec <- 3 # Number of vectors
set.seed(123)
x1 <- runif(N * N_vec)
mat_x1 <- matrix(x1, ncol = N_vec)
mat_x1[upper.tri(mat_x1)] <- NA
diag(mat_x1) <- NA
mat_x1
              [,1]      [,2] [,3]
    [1,]        NA        NA   NA
    [2,] 0.7883051        NA   NA
    [3,] 0.4089769 0.0455565   NA

Como aplico a seguinte função a cada elemento da matriz que retorna valores > 0,7?

y = (function(x) if (x > .7) { return(x) } else { return(NA) })

Gostaria de ver o seguinte depois de aplicar a função:

mat_x2
              [,1] [,2] [,3]
    [1,]        NA   NA   NA
    [2,] 0.7883051   NA   NA
    [3,]        NA   NA   NA

Como forçar o compilador gcc a lançar erro quando int main() não tem nenhuma instrução return. Este código compila sem erros

#include<stdio.h>

int main(){
   printf("Hi");
}

Eu estou usando

gcc  -Wall -Wextra -std=c99 -Wreturn-type -Werror -pedantic-errors a.c

comando para compilação

Tenho o seguinte main.c:

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

extern unsigned short addsub(int op1, int op2, char what, int *res, int *bit_count);

void print_flags(unsigned short flags) {
    printf("Flags:\n");
    printf("%s", "O D I T S Z   A   P   C\n");

    int bits_to_display = 12; // Significant bits only (0 included)

    for (int i = bits_to_display - 1; i >= 0; --i) {
        printf("%d ", (flags >> i) & 1);
    }
    printf("\n\n");
}

void print_result(int op1, int op2, int result, unsigned short flags, char operation, int bit_count) {
    // Signed interpretation
    printf("Ergebnis und Operanden Signed:\n");
    printf("%d %c %d = %d ", (signed char)op1, operation, (signed char)op2, (signed char)result);
    if ((flags & 0x0800) != 0) { // Overflow flag (OF)
        printf("(Ergebnis ist falsch!)\n");
    } else {
        printf("(Ergebnis ist richtig!)\n");
    }

    // Unsigned interpretation
    printf("\nErgebnis und Operanden Unsigned:\n");
    printf("%u %c %u = %u ", (unsigned char)op1, operation, (unsigned char)op2, (unsigned char)result);
    if ((flags & 0x0001) != 0) { // Carry flag (CF)
        printf("(Ergebnis ist falsch!)\n");
    } else {
        printf("(Ergebnis ist richtig!)\n");
    }

    // Print POPCNT result
    printf("\nDie Anzahl der gesetzten Bits im Ergebnis beträgt: %d\n", bit_count);
}

int main(int argc, char *argv[]) {
    if (argc != 4) {
        fprintf(stderr, "Usage: %s <operand1> <+|-> <operand2>\n", argv[0]);
        return 1;
    }

    int op1 = atoi(argv[1]);
    int op2 = atoi(argv[3]);
    char op = argv[2][0];

    if (op != '+' && op != '-') {
        fprintf(stderr, "Error: Invalid operator. Use '+' or '-'.\n");
        return 1;
    }

    int res = 0;
    int bit_count = 0;
    unsigned short flags = addsub(op1, op2, op, &res, &bit_count);

    if (bit_count == -1) {
        printf("Diese CPU unterstützt den Befehl CPUID nicht!\n");
        return 1;
    } else if (bit_count == -2) {
        printf("Diese CPU unterstützt den Befehl POPCNT nicht!\n");
        return 1;
    }

    print_flags(flags);
    print_result(op1, op2, res, flags, op, bit_count);
    return 0;
}

que é combinado com o seguinte módulo de montagem:

section .text
global addsub

; CPUID function genutzt um cpu informationen auszulesen

; EAX = 1 provides feature information in ECX
; Bit 23 of ECX = 1 indicates POPCNT support

addsub:
    push ebp
    mov ebp, esp

    ; Load function arguments
    mov eax, [ebp+8]       ; Load op1
    mov ebx, [ebp+12]      ; Load op2
    mov ecx, [ebp+16]      ; Load operation ('+' or '-')
    mov edx, [ebp+20]      ; Load address of res
    mov esi, [ebp+24]      ; Load address of bit_count

    ; Save registers
    push eax
    push ebx
    push ecx
    push edx
    push esi

    ; CPUID for POPCNT support check
    pushfd
    pop eax
    mov ecx, eax
    xor eax, 0x00200000    ; Toggle ID bit in EFLAGS
    push eax               ; Save modified flags
    popfd                  ; Load modified flags
    pushfd                 ; Push modified flags to stack
    pop eax                ; Pop flags back into EAX
    xor eax, ecx           ; Check if ID bit was toggled
    jz no_cpuid            ; CPUID not supported

    ; CPUID supported, check POPCNT support (bit 23)
    mov eax, 1             ; Set EAX to 1 (feature information)
    cpuid
    test ecx, 1 << 23
    jz no_popcnt           ; POPCNT not supported

    ; Restore registers
    pop esi
    pop edx
    pop ecx
    pop ebx
    pop eax

    cmp cl, '+'
    je add
    cmp cl, '-'
    je sub

    ; Invalid operation
    xor eax, eax
    leave
    ret

add:
    add al, bl
    mov [edx], eax         ; Store result
    pushfd
    pop eax
    jmp count_bits

sub:
    sub al, bl
    mov [edx], eax         ; Store result
    pushfd
    pop eax
    jmp count_bits

count_bits:
    push ebx
    push esi
    mov ebx, [edx]
    and ebx, 0xFF        ; Hardcoded 8-bit limit
    popcnt ecx, ebx        ; Count the number of set bits in result
    mov [esi], ecx         ; Store bit count in variable
    pop ebx
    pop esi
    jmp fin

no_cpuid:
    mov dword [esi], -1             ; CPUID not supported flag for C program
    jmp fin

no_popcnt:
    mov dword [esi], -2             ; POPCNT not supported flag for C program
    jmp fin

fin:
    leave                  ; Restore stack frame (includes pop ebp)
    ret 

O propósito do programa é ler os flags da CPU e retorná-los. Quando tento ler a variável flags depois que o addsub()método termina, o programa trava, e não consigo descobrir o motivo. No gdb, o valor correto é armazenado na variável flags. Quando removo a instrução print, o programa funciona conforme o esperado.

Talvez alguém possa ajudar porque estou ficando louco!