All perguntas(coding)

Tenho vários milhares de linhas como esta armazenadas em um objeto em R. Quero criar um novo df2 pareando elementos de duas colunas ($exonStarts e $exonEnds) do df abaixo

df <- structure(list(bin = c(0L, 0L, 0L, 0L, 0L, 0L), name = c("XM_011541469.2", 
"XM_017001276.2", "XM_011541467.2", "NM_001276352.2", "NM_001276351.2", 
"XM_011541465.3"), chr = c("chr1", "chr1", "chr1", "chr1", "chr1", 
"chr1"), strand = c("-", "-", "-", "-", "-", "-"), txStart = c(67092164L, 
67092164L, 67092164L, 67092164L, 67092164L, 67092164L), txEnd = c(67109072L, 
67131227L, 67131227L, 67134970L, 67134970L, 67134970L), cdsStart = c(67093004L, 
67093004L, 67093004L, 67093579L, 67093004L, 67093004L), cdsEnd = c(67103382L, 
67127240L, 67127240L, 67127240L, 67127240L, 67127240L), exonCount = c(5L, 
9L, 9L, 9L, 8L, 9L), exonStarts = c("67092164,67095234,67096251,67103237,67109028,", 
"67092164,67095234,67096251,67103237,67111576,67115351,67125751,67127165,67131141,", 
"67092164,67095234,67096251,67103237,67111576,67115351,67125751,67127165,67131141,", 
"67092164,67096251,67103237,67111576,67115351,67125751,67127165,67131141,67134929,", 
"67092164,67095234,67096251,67115351,67125751,67127165,67131141,67134929,", 
"67092164,67095234,67096251,67103237,67111576,67115351,67125751,67127165,67134929,"
), exonEnds = c("67093604,67095421,67096321,67103382,67109072,", 
"67093604,67095421,67096321,67103382,67111644,67115464,67125909,67127257,67131227,", 
"67093604,67095421,67096321,67103343,67111644,67115464,67125909,67127257,67131227,", 
"67093604,67096321,67103382,67111644,67115464,67125909,67127257,67131227,67134970,", 
"67093604,67095421,67096321,67115464,67125909,67127257,67131227,67134970,", 
"67093604,67095421,67096321,67103382,67111644,67115464,67125909,67127257,67134970,"
), score = c(0L, 0L, 0L, 0L, 0L, 0L), gene = c("C1orf141", "C1orf141", 
"C1orf141", "C1orf141", "C1orf141", "C1orf141"), cdsStartStat = c("cmpl", 
"cmpl", "cmpl", "cmpl", "cmpl", "cmpl"), cdsEndStat = c("cmpl", 
"cmpl", "cmpl", "cmpl", "cmpl", "cmpl"), exonFrames = c("0,2,1,0,-1,", 
"0,2,1,0,1,2,0,0,-1,", "0,2,1,0,1,2,0,0,-1,", "2,1,0,1,2,0,0,-1,-1,", 
"0,2,1,2,0,0,-1,-1,", "0,2,1,0,1,2,0,0,-1,")), row.names = c(NA, 
6L), class = "data.frame")
 

para produzir uma saída como abaixo. A primeira linha da entrada df deve produzir 5 linhas de df2 no ​​formato abaixo, pareando cada elemento de $exonStart com cada elemento de $exonEnd (as contagens de elementos serão idênticas e estão presentes na coluna $exonCount).

$chr    $exonStart  $exonEnd
chr1    67092164    67093604
chr1    67095234    67095421
chr1    67096251    67096321
chr1    67103237    67103382
chr1    67109028    67109072

Isso precisa iterar sobre todas as linhas de entrada df e todos os resultados combinados em df2. Então, no total, haveria sum(object$exonCount)linhas em df2.

Eu sei que haveria algum tipo de strsplitfunção aqui para dividir $exonStarts e $exonEnds e então combiná-los. Talvez uma applyfunção para fazer isso em todas as linhas? Eu tentei algo assim primeiro

map2(unlist(strsplit(df$exonStarts[1], ",")), unlist(strsplit(dft$exonEnds[1], ",")), c)

para produzir uma lista de elementos pareados

[[1]]
[1] "67092164" "67093604"

[[2]]
[1] "67095234" "67095421"

[[3]]
[1] "67096251" "67096321"

[[4]]
[1] "67103237" "67103382"

[[5]]
[1] "67109028" "67109072"

Mas não sei para onde ir a partir daqui. Qualquer ajuda seria apreciada.

Executar uma operação matemática em um realoperando e um numericoperando no PostgreSQL resulta em um double precisionvalor, mas acho isso surpreendente. Por que o resultado não seria um real, em vez disso?

Confirmei esse comportamento com o PostgreSQL 13 e 16.

SELECT 
   pg_typeof(0::numeric + 0::numeric), -- numeric
   pg_typeof(0::real    + 0::real),    -- real
   pg_typeof(0::numeric + 0::real),    -- double precision??
   pg_typeof(0::real    + 0::numeric); -- double precision??

Li partes substanciais da documentação do PostgreSQL, mais relevantes: 10.2. Conversão de tipo: operadores

E eu consultei pg_catalog.pg_cast(ou psql's \dC) para entender quais são as conversões implícitas relevantes:

> SET search_path = 'pg_catalog';
> SELECT format_type(castsource, NULL) AS source,
         format_type(casttarget, NULL) AS target
  FROM pg_cast
  WHERE castcontext = 'i' -- i.e. casts allowed implicitly
    AND ARRAY[format_type(castsource, NULL), format_type(casttarget, NULL)] 
        <@ '{numeric,real,double precision}'::text[];

O resultado é:

 source  |      target
---------+------------------
 real    | double precision
 numeric | real
 numeric | double precision
 numeric | numeric
(4 rows)

Então, pelo que entendi, para 0::numeric + 0::realo PostgreSQL deveria (os trechos são todos de 10.2. Conversão de Tipo: Operadores ):

1. Selecione os operadores a serem considerados do pg_operatorcatálogo do sistema. Se um nome de operador não qualificado por esquema foi usado (o caso usual), os operadores considerados são aqueles com o nome correspondente e a contagem de argumentos que são visíveis no caminho de pesquisa atual.

Espero que comece com todos +os operadores - cada um aceita um par dos mesmos tipos numéricos ( real + real, integer + integer, etc.)

2. Verifique se há um operador que aceita exatamente os tipos de argumentos de entrada.

Na etapa 2, nenhum operador é uma correspondência exata para reale numeric, então espero que nada aconteça aqui.

3a. Descarte operadores candidatos cujos tipos de entrada não correspondem e não podem ser convertidos (usando uma conversão implícita) para corresponder.

Espero que isso descarte a maioria dos candidatos. Ele deve manter exatamente dois: o de real, e o de double precisionque ele aparentemente acaba usando. (Note que realnão pode ser implicitamente convertido para numeric, então ele não deve manter o de numeric.)

3b. Se qualquer argumento de entrada for de um tipo de domínio, trate-o como sendo do tipo base do domínio para todas as etapas subsequentes.

Espero que isso não faça nada, pois não há tipos de domínio aqui.

3c. Execute todos os candidatos e mantenha aqueles com as correspondências mais exatas em tipos de entrada. Mantenha todos os candidatos se nenhum tiver correspondências exatas. Se apenas um candidato permanecer, use-o; caso contrário, continue para a próxima etapa.

Aqui, espero que ele descarte o operador for double precision, porque o operador for realtem uma correspondência exata, enquanto o for double precisiontem zero correspondências exatas. E então, como só resta um candidato aqui, ele deve usar o operador for real, e espero que o resultado seja um real. Mas, em vez disso, o resultado é um double precisionvalor.

Então, minha pergunta é por que o PostgreSQL está escolhendo o double precisionoperador neste caso, onde ele precisa converter implicitamente ambos os operandos em vez de apenas um deles? A documentação está errada, ou meu entendimento dela está errado?

Estou tentando vincular esta função de montagem com este código c++:

.text 

.global _Z7scambiaRiS_

_Z7scambiaRiS_:
    pushq %rbp
    mov %rsp, %rbp

    mov (%rdi), %rax
    mov (%rsi), %rcx
    mov %rcx, (%rdi)
    mov %rax, (%rsi)

    leave
    ret

.data

#include <iostream>

void extern scambia(int &a, int &b);

int main()
{ 
    int a, b;
    std::cin>>a>>b;
    std::cout<<"a: "<<a<<" b: "<<b<<"\n";
    
    scambia(a, b);

    std::cout<<"a: "<<a<<" b: "<<b<<"\n";
    
    return 0;
};

O assembly é uma versão intel x86-64.

O programa funciona, mas depois para com falha de segmentação. Aqui está a saída, fornecida como entrada 3 4:

3 4 
a: 3 b: 4
a: 4 b: 3
*** stack smashing detected ***: terminated
Aborted (core dumped)

Eu realmente não entendo como consegui comprometer a pilha, e mesmo depurando com o gdb não consegui descobrir o que deu errado

Estou lendo este guia sobre programação de rede, do qual estou gostando muito: https://beej.us/guide/bgnet/html/split/slightly-advanced-techniques.html#serialization

Estou confuso sobre algo, no entanto. Nesta seção sobre serialização, ele fala sobre serializar ints por motivos de ordenação de bytes, o que faz sentido para mim, mas ele também inclui essas duas funções pack754 e unpack754 para serializar floats no formato IEEE-754.

uint64_t pack754(long double f, unsigned bits, unsigned expbits)
{
    long double fnorm;
    int shift;
    long long sign, exp, significand;
    unsigned significandbits = bits - expbits - 1; // -1 for sign bit

    if (f == 0.0) return 0; // get this special case out of the way

    // check sign and begin normalization
    if (f < 0) { sign = 1; fnorm = -f; }
    else { sign = 0; fnorm = f; }

    // get the normalized form of f and track the exponent
    shift = 0;
    while(fnorm >= 2.0) { fnorm /= 2.0; shift++; }
    while(fnorm < 1.0) { fnorm *= 2.0; shift--; }
    fnorm = fnorm - 1.0;

    // calculate the binary form (non-float) of the significand data
    significand = fnorm * ((1LL<<significandbits) + 0.5f);

    // get the biased exponent
    exp = shift + ((1<<(expbits-1)) - 1); // shift + bias

    // return the final answer
    return (sign<<(bits-1)) | (exp<<(bits-expbits-1)) | significand;
}

long double unpack754(uint64_t i, unsigned bits, unsigned expbits)
{
    long double result;
    long long shift;
    unsigned bias;
    unsigned significandbits = bits - expbits - 1; // -1 for sign bit

    if (i == 0) return 0.0;

    // pull the significand
    result = (i&((1LL<<significandbits)-1)); // mask
    result /= (1LL<<significandbits); // convert back to float
    result += 1.0f; // add the one back on

    // deal with the exponent
    bias = (1<<(expbits-1)) - 1;
    shift = ((i>>significandbits)&((1LL<<expbits)-1)) - bias;
    while(shift > 0) { result *= 2.0; shift--; }
    while(shift < 0) { result /= 2.0; shift++; }

    // sign it
    result *= (i>>(bits-1))&1? -1.0: 1.0;

    return result;
}

O que me confunde é que essas funções funcionam olhando para o primeiro bit para o sinal, depois os próximos bits X para o expoente, depois os próximos bits Y para a mantissa. Então isso não significa que o float já tem que estar no formato IEEE-754 na máquina host para que isso funcione?

Isto está aqui apenas para explicar o formato ou é algo que você realmente faria na vida real?

No React, estou usando @react-three/fiberpara coisas 3D. Há muitos componentes que não suportam a maneira declarativa de fazer as coisas e exigem refs e código imperativo (por exemplo, CameraControlsde drei).

Estou tentando inicializar um CameraControlsna inicialização:

const cameraRef = useRef<CameraControls>(null)

const resetCamera = () => {
  if (cameraRef.current == null) return
  cameraRef.current.setLookAt(
    ...cameraInitialPosition,
    ...cameraInitialTarget,
    true
  )
}

useEffect(resetCamera, [])

return (
  <Canvas shadows>
    <CameraControls ref={cameraRef} />
    ...
)

Claro que isso não funciona, pois na primeira e única vez useEffectque é executado, o cameraRef.currentainda é null.

Quando tento usar o hack de timeout, o current ainda é nulo:

useEffect(() => {
  setTimeout(resetCamera, 0)
}, [])

Quando aumento o tempo limite para algumas centenas de ms, ele começa a funcionar:

useEffect(() => {
  setTimeout(resetCamera, 500)
}, [])

Essa abordagem com tempo limite é hackeada e ruim, buscando algo melhor.

Existe uma maneira de escrever um gancho personalizado que retorne refObjecte, mais tarde, quando o atual for preenchido pela primeira vez, execute a função fornecida?

O GCC aceita esse código, o Clang e o MSVC o rejeitam devido à falha de asserção estática em assert. O que o padrão diz?

https://godbolt.org/z/PKMKzYGsc

template<typename T>
constexpr int assert() {
    static_assert(sizeof(T) == 1);
    return 1;
}

template<auto I>
using Int = int;

template<typename T> requires (sizeof(T) == 1)
constexpr auto foo(T) -> Int<assert<T>()> {
    return 1;
}

template<typename T> requires (sizeof(T) > 1)
constexpr auto foo(T a) -> Int<1> {
    return 2;
}

static_assert(foo('1') == 1);
static_assert(foo(2) == 2);

Saída do Clang:

<source>:3:19: error: static assertion failed due to requirement 'sizeof(int) == 1'
    3 |     static_assert(sizeof(T) == 1);
      |                   ^~~~~~~~~~~~~~
<source>:11:30: note: in instantiation of function template specialization 'assert<int>' requested here
   11 | constexpr auto foo(T) -> Int<assert<T>()> {
      |                              ^
<source>:21:15: note: while substituting deduced template arguments into function template 'foo' [with T = int]
   21 | static_assert(foo(2) == 2);
      |               ^
<source>:3:29: note: expression evaluates to '4 == 1'
    3 |     static_assert(sizeof(T) == 1);

Qual é a maneira correta de indexar em um HashMap<&String, V>com um &str? Rust relata que &Stringnão é Borrow<str>, o que é necessário para indexação. (Isso parece um pouco bobo para mim; se T: Borrow<U>então certamente &T: Borrow<U>também deveria ser válido?)

use std::collections::HashMap;

fn main() {
    let strings = vec!["x".to_owned(), "y".to_owned(), "z".to_owned()];
    let m = [0, 1, 2]
        .into_iter()
        .map(|i| (&strings[i], i))
        .collect::<HashMap<&String, usize>>();
    let zero = m["x"];
}

error[E0277]: the trait bound `&String: Borrow<str>` is not satisfied
 --> src/main.rs:9:18
  |
9 |     let zero = m["x"];
  |                  ^^^ the trait `Borrow<str>` is not implemented for `&String`, which is required by `HashMap<&String, usize>: Index<&_>`
  |
  = help: the trait `Borrow<str>` is implemented for `String`
  = help: for that trait implementation, expected `String`, found `&String`
  = note: required for `HashMap<&String, usize>` to implement `Index<&str>`

Obviamente, como eu construí esse HashMap em particular, eu poderia voltar e mudar seu tipo de chave para &strem vez disso. Mas supondo que eu receba um HashMap<&String, V>, qual é a maneira correta de indexá-lo? Construir um whole Stringapenas para pegar uma referência a ele parece desperdício.

Preciso alterar a ordem de uma string no AIX, mas com o comando cutnão consigo fazer

Ex: echo FT0215202301.xml | cut -b 7-10,5-6,3-4

Resultado: 02152023

Esperado : 20230215

Meu código:

import torch
import random


image_width, image_height = 128, 128

def apply_ellipse_mask(img, pos, axes):
    r = torch.arange(image_height)[:, None]
    c = torch.arange(image_width)[None, :]
    val_array = ((c - pos[0]) ** 2) / axes[0] ** 2 + ((r - pos[1]) ** 2) / axes[1] ** 2
    mask = torch.where((0.9 < val_array) & (val_array < 1), torch.tensor(1.0), torch.tensor(0.0))

    return img * (1.0 - mask) + mask


random.seed(0xced)

sphere_radius = image_height / 3
sphere_position = torch.tensor([image_width / 2, image_height / 2 ,0], requires_grad=True)

ref_image = apply_ellipse_mask(torch.zeros(image_width, image_height, requires_grad=True), sphere_position, [sphere_radius, sphere_radius, sphere_radius])

ellipsoid_pos = torch.tensor([sphere_position[0], sphere_position[1], 0], requires_grad=True)
ellipsoid_axes = torch.tensor([image_width / 3 + (random.random() - 0.5) * image_width / 5, image_height / 3 + (random.random() - 0.5) * image_height / 5, image_height / 2], requires_grad=True)

optimizer = torch.optim.Adam([ellipsoid_axes], lr=0.1)
criterion = torch.nn.MSELoss()
for _ in range(100):

    optimizer.zero_grad()
    current_image = torch.zeros(image_width, image_height, requires_grad=True)
    current_image = apply_ellipse_mask(current_image, ellipsoid_pos, ellipsoid_axes)

    loss = criterion(current_image, ref_image)
    loss.backward()
    print(_, loss)
    optimizer.step()

Erro:

RuntimeError: Tentando retroceder no gráfico uma segunda vez (ou acessar diretamente tensores salvos após eles já terem sido liberados). Valores intermediários salvos do gráfico são liberados quando você chama .backward() ou autograd.grad(). Especifique retain_graph=True se você precisar retroceder no gráfico uma segunda vez ou se precisar acessar tensores salvos após chamar backward.

Por que ele estaria tentando retroceder pelo mesmo gráfico uma segunda vez? Estou acessando diretamente os tensores salvos depois que eles foram liberados?

Estou tentando girar um círculo pai e negar o efeito em seus filhos. Tentei negar o efeito usando

transform: translate(-50%, -50%)
           rotate(calc(var(--i) * -60deg))
           translateY(150px)
           rotate(calc(var(--i) * 60deg - var(--rotation)))

mas as crianças vão girar 60 graus no início da transição. Como evitar que elas girem completamente durante a transição?

const circle = document.getElementById('circle');
let deg = 0;

function rotate() {
  deg += 60;
  circle.style.cssText = `--rotation: ${deg}deg`;
}

.circle {
  border: 2px solid #ccc;
  border-radius: 50%;
  height: 300px;
  margin: 40px auto 0;
  transform: rotate(var(--rotation));
  transition: transform 1000ms ease;
  position: relative;
  width: 300px;
}

.item {
  align-items: center;
  background: red;
  border: 2px solid #fff;
  border-radius: 50%;
  display: flex;
  height: 30px;
  justify-content: center;
  left: 50%;
  position: absolute;
  top: 50%;
  transform: translate(-50%, -50%) rotate(calc(var(--i) * -60deg)) translateY(150px) rotate(calc(var(--i) * 60deg - var(--rotation)));
  width: 30px;
}

.btn {
  align-items: center;
  background: lawngreen;
  display: flex;
  height: 30px;
  justify-content: center;
  width: 100px;
}

<meta name="viewport" content="width=device-width, initial-scale=1.0">

<div class="circle" id="circle" style="--rotation: 0deg">
  <div class="item" style="--i: 0">1</div>
  <div class="item" style="--i: 1">2</div>
  <div class="item" style="--i: 2">3</div>
  <div class="item" style="--i: 3">4</div>
  <div class="item" style="--i: 4">5</div>
  <div class="item" style="--i: 5">6</div>
</div>

<div class='btn' onclick="rotate()">rotate</div>