All perguntas(coding)

Criei 2 migrações laravel, a primeira roda perfeitamente, a segunda me dá um erro:

SQLSTATE[23000]: Violação de restrição de integridade: 1452 Não é possível adicionar ou atualizar uma linha filho: uma restrição de chave estrangeira falha

Não tenho certeza do que há de errado na minha chave estrangeira, alguém pode me ajudar?

Aqui está meu primeiro esquema:

    Schema::create('cryptocurrencies', function (Blueprint $table) {
        $table->id('id');
        $table->string('name');
        $table->string('symbol')->unique();
        $table->string('slug');
        $table->longtext('description');
    });

Aqui está meu segundo esquema:

Schema::create('cryptocurrencies_quotes', function (Blueprint $table) {
    $table->id('id');
    $table->string('name');
    $table->string('symbol');
    $table->string('slug');
    $table->integer('cryptocurrency_id');
    $table->bigInteger('circulating_supply');
    $table->bigInteger('total_supply');
    $table->double('price');
    $table->double('volume_24h');
    $table->timestamps();
});

Schema::table('cryptocurrencies_quotes', function (Blueprint $table) {
    $table->foreign('cryptocurrency_id')->references('id')->on('cryptocurrencies')->onUpdate('cascade')->onDelete('cascade');
});

Dado o código a seguir, por que o capacityde cada um dos vetores é 0 em vez de chunk_size?

#[test]
fn test() {
    let chunk_size = 1024;
    let data: Vec<Vec<u8>> = vec![Vec::with_capacity(chunk_size); 2];

    assert_eq!(data[0].capacity(), chunk_size);
    assert_eq!(data[1].capacity(), chunk_size);
}

Link do parque infantil: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=0c40515b164044621c369adef1090c6e

Dadas duas grandes matrizes,

A = np.random.randint(10,size=(10000,2))
B = np.random.randint(10,size=(10000,2))

Gostaria de determinar se algum dos vetores tem um produto vetorial igual a zero. Nós poderíamos fazer

C = np.cross(A[:,None,:],B[None,:,:])

e então verifique se C contém 0 ou não.

not C.all()

No entanto, este processo requer o cálculo de todos os produtos cruzados, o que pode ser demorado. Em vez disso, eu preferiria deixar numpy realizar o produto vetorial, mas SE um zero for alcançado em qualquer ponto, simplesmente corte toda a operação e termine mais cedo. O numpy tem uma operação de "rescisão antecipada" que interromperá as operações numpy antecipadamente se elas atingirem uma condição? Algo como,

np.allfunc()
np.anyfunc()

O exemplo acima é um caso em que A e B têm uma probabilidade extremamente alta de ter um produto vetorial zero em algum ponto (na verdade, é muito provável que ocorra perto do início), tanto que a execução de um python-for-loop (eca!) é muito mais rápido do que usar o código altamente otimizado do numpy.

Em geral, qual é a maneira mais rápida de determinar se A e B têm produto vetorial zero?

Depois de atualizar Microsoft.IdentityModel.Tokense System.IdentityModel.Tokens.Jwtpara 7.0.0, recebo este erro:

IDX20803: Não é possível obter a configuração de: 'https://example.com/realms/Development/.well-known/openid-configuration'.

Não foi possível carregar o tipo 'Microsoft.IdentityModel.Json.JsonConvert' do assembly 'Microsoft.IdentityModel.Tokens, versão=7.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35'. Não foi possível carregar o tipo 'Microsoft.IdentityModel.Json.JsonConvert' do assembly 'Microsoft.IdentityModel.Tokens, versão=7.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35'. => Microsoft.IdentityModel.Json.JsonConvert

Antes da atualização, minhas referências de pacote eram:

<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="7.0.10" />
<PackageReference Include="Microsoft.IdentityModel.Tokens" Version="6.32.3" />
<PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="6.32.3" />
<PackageReference Include="System.Text.Json" Version="7.0.3" />

Após a atualização, minhas referências de pacote são agora:

<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="7.0.11" />
<PackageReference Include="Microsoft.IdentityModel.Tokens" Version="7.0.0" />
<PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="7.0.0" />
<PackageReference Include="System.Text.Json" Version="7.0.3" />

Qual é o problema?

Entendo que uma das características/objetivos dos módulos é que variáveis/funções definidas dentro não são acessíveis de fora do script. Porém, se eu quiser exportar uma função específica para ser usada globalmente, como farei isso? Apenas atribuir à janela como li em outras postagens não parece funcionar:

emindex.html

<script type="module">
   const add = (a, b) => a + b;
   window.add = add;
</script>
<script>
   console.log(window.add(1, 2));
</script>

Resulta emUncaught TypeError: window.add is not a function

Eu criei um par de funções:

void destroy_foo(void *ptr);
void *create_foo(void);

Como os nomes sugerem, estes funcionam de forma semelhante a malloce free. Eu gostaria de usar o malloc atributo de função gcc para informar o compilador sobre esse relacionamento para que esse código gerasse um aviso com -fanalyzer:

void *ptr = create_foo();
destroy_foo(ptr);
destroy_foo(ptr);

Seguindo os exemplos do link mencionado acima, fiz

void *create_foo(void) __attribute__ ((malloc (destroy_foo)));

Embora o gcc (11.4.0) esteja bem com isso, o clang (14.0.0) reclama

error: 'malloc' attribute takes no arguments
void *create_foo(void) __attribute__ ((malloc (destroy_foo)));
                                       ^

Meu entendimento foi que os atributos do gcc funcionaram bem com o clang.

Encontrei uma instrução T-SQL que não consegue tornar uma string NULL, se for uma string vazia. É como:

SELECT NULLIF(N'ធ្វើឱ្យ', '') -- NULL

De acordo com o Google Tradutor, a palavra significa "fazer" na língua Khmer . Se eu tentar:

SELECT IIF(N'ធ្វើឱ្យ' = '', 1, 0) -- 1

Então, o mecanismo diz que esta string está vazia.

Não tenho certeza se este é um problema de idioma de suporte, pois aqui tenho:

ou algum tipo de conversão de precedência de tipo de dados, pois temos duas strings. É estranho como então o motor não consegue entender que a string não está vazia?

Depois de tudo isso SELECT LEN(N'ធ្វើឱ្យ')me dá sete, só me pergunto qual é o motivo exato.

Considere o seguinte código:

#include <memory>
#include <optional>

template <typename T>
constexpr T * arg_to_pointer(T & arg) noexcept {
    return std::addressof(arg);
}

int main() {
    std::optional<int> foo;

    auto * test = foo.transform(arg_to_pointer<int>).value_or(nullptr);
    //auto * test = foo.transform(std::addressof<int>).value_or(nullptr);

    return 0;
}

A linha que não está comentada (que passa um wrapper idiota std::addressofcomo parâmetro de função para std::optional::transform) compila e funciona perfeitamente. A linha comentada (aquela que tenta usar std::addressofdiretamente) não - recebo um erro indicando que a dedução do argumento do modelo falhou (exemplo ao vivo aqui usando o GCC 13.2, embora um comportamento semelhante seja observado com o Clang 16.0). Por que é isso? Qual é a diferença entre o padrão std::addressofe meu invólucro idiota?

Recentemente, encontrei esta pergunta no Stack Overflow, perguntando sobre como o método then realmente funciona em JavaScript. O respondente, Trincot, fez o seguinte comentário:

O host verificará quais filas de trabalhos possuem entradas, dando preferência às filas de trabalhos com alta prioridade. Uma fila de tarefas do Promise tem uma prioridade muito alta, normalmente mais alta do que a fila de eventos que lida com a interação do usuário ou outros eventos externos. Portanto, o trabalho que foi colocado na fila na etapa 4 acima é retirado da fila Promise Job. Este trabalho chamará sequencialmente as funções de retorno de chamada que foram registradas como retornos de chamada (como o registrado na etapa 7) no objeto myPromise.

Se entendi sua explicação corretamente, sempre que a função resolve é invocada, o JavaScript agendará uma microtarefa (ou um job) na fila de jobs, que executará todos os callbacks passados ​​para eles, incluindo o encadeamento, quando a pilha de chamadas estiver vazia. Por exemplo:

Promise.resolve("Hi")
    .then(() => {
        console.log("Hi");
    })
    .then(() => {
        console.log("World");
    });

Nesse caso, a promessa é resolvida imediatamente, o que significa que uma microtarefa será agendada imediatamente. Quando os retornos de chamada terminarem a execução, o mecanismo JS verificará se há microtarefas na fila. Como a promessa foi resolvida imediatamente, ele executará a microtarefa, que por sua vez executa todos os manipuladores passados ​​para o método then. Como resultado, o código produzirá "Hi" e "World".

No entanto, por que esse código gera "1 3 2 4" em vez de "1 2 3 4"?

const p1 = Promise.resolve();
const p2 = Promise.resolve();
p1.then(() => {
    console.log(1);
}).then(() => {
    console.log(2);
});
p2.then(() => {
    console.log(3);
}).then(() => {
    console.log(4);
});

Acredito que o código deve gerar "1 2 3 4" em vez de "1 3 2 4". Isso ocorre porque, quando p1 e p2 são resolvidos, duas microtarefas são enfileiradas. À medida que os retornos de chamada terminam a execução, eles adicionam esses retornos de chamada às suas listas internas. Assim que a pilha de chamadas estiver vazia, o mecanismo JS seleciona a tarefa mais antiga da fila e a executa. Essa tarefa deve executar todos os manipuladores passados ​​para essa instância específica do Promise. No entanto, não parece estar acontecendo como o esperado. Alguém poderia me explicar o motivo desse comportamento?

Obrigado pelo seu tempo e tenha um ótimo dia!

Como você faz com que o flex inline seja agrupado na mesma linha que a última linha de uma tag de várias linhas? Eu acredito que ele vê a tag h1 de 100% de largura, então está quebrando para passar por baixo dela, mas existe uma maneira de fazê-la fluir para o espaço em branco ao lado de h1?

.post {
  display: inline-flex;
  flex-direction: row;
  flex-wrap: wrap;
  align-content: flex-start;
  column-gap: 10px;
}

.post-title {
  display: block;
  flex-grow: 0;
  flex-shrink: 1;
  flex-basis: auto;
  align-self: auto;
  order: 0;
}

.post-meta {
  display: block;
  flex-grow: 0;
  flex-shrink: 1;
  flex-basis: auto;
  align-self: auto;
  order: 0;
}

<div class="post">
  <h1 class="post-title"><a href="#">A Long Post Title but not too long to be obnoxious</a></h1>
  <div class="post-meta">
    <div class="post-date">11 November 2022</div>
    <div class="post-category"><a href="#">Writing, Religion</a></div>
  </div>
</div>

Em telas onde o tem que quebrar para uma segunda linha, o .post-meta aparece na linha logo após o ao invés de quebrar para ficar próximo ao texto.

Obrigado!