全部问题(coding)

我在 R 中的一个对象中存储了几千行这样的数据。我想通过配对下面 df 中的两列 ($exonStarts 和 $exonEnds) 中的元素来创建一个新的 df2

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")
 

产生如下所示的输出。输入 df 的第一行应通过将 $exonStart 的每个元素与 $exonEnd 的每个元素进行配对（元素计数将相同并存在于 $exonCount 列中），以下面的格式产生 5 行 df2。

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

这需要迭代输入 df 的所有行并将所有结果合并到 df2 中。因此，df2 中总共会有sum(object$exonCount)行。

我知道这里有某种strsplit函数可以拆分 $exonStarts 和 $exonEnds，然后将它们合并。也许有一个apply函数可以对所有行执行此操作？我首先尝试了类似这样的方法

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

生成配对元素的列表

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

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

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

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

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

但我不知道接下来该怎么做。任何帮助我都会很感激。

real在 PostgreSQL 中对一个操作数和一个操作数执行数学运算numeric会得到一个double precision值，但我觉得这很令人惊讶。为什么结果不是real, 呢？

我使用 PostgreSQL 13 和 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??

我已阅读了 PostgreSQL 文档的大部分内容，其中最相关的是：10.2。类型转换：运算符

我已经查询过pg_catalog.pg_cast（或psql）\dC来了解相关的隐式转换是什么：

> 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[];

结果是：

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

据我所知，对于0::numeric + 0::real，PostgreSQL 应该（摘录全部来自10.2. 类型转换：运算符）：

1. 从系统目录中选择要考虑的运算符pg_operator。如果使用了非模式限定的运算符名称（通常情况），则考虑的运算符是那些在当前搜索路径中可见的具有匹配名称和参数计数的运算符。

我希望它以所有运算符开始+- 每个运算符接受一对相同的数字类型（real + real，，integer + integer等等）

2. 检查运算符是否准确接受输入参数类型。

real在步骤 2 中，没有运算符与和完全匹配numeric，因此我预计这里不会发生任何事情。

3a. 丢弃输入类型不匹配且无法转换（使用隐式转换）以匹配的候选运算符。

我预计这应该会丢弃大多数候选者。它应该只保留两个：一个是real，另一个是double precision它显然最终使用的 。（请注意，real不能隐式转换为numeric，因此它不应该保留numeric。）

3b. 如果任何输入参数属于域类型，则在所有后续步骤中将其视为域的基类型。

我认为这不会产生任何作用，因为这里没有域类型。

3c. 遍历所有候选，并保留那些与输入类型最精确匹配的候选。如果没有精确匹配的候选，则保留所有候选。如果只剩下一个候选，则使用它；否则继续下一步。

在这里，我期望它应该丢弃 的运算符double precision，因为 的运算符real有一个精确匹配，而 的运算符double precision没有精确匹配。然后，由于这里只剩下一个候选，它应该使用 的运算符real，我期望结果是real。但结果却是一个double precision值。

因此，我的问题是，为什么 PostgreSQLdouble precision在这种情况下选择运算符，它需要隐式转换两个操作数而不是其中一个操作数？文档有误，还是我的理解有误？

我正在尝试将该汇编函数与该 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;
};

汇编是英特尔 x86-64 版本。

程序运行，但随后因段错误而停止，这里是输出，作为输入3 4：

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

我真的不明白我是如何设法破坏堆栈的，即使使用 gdb 进行调试，我也无法找出问题所在

我正在阅读有关网络编程的指南，我非常喜欢：https://beej.us/guide/bgnet/html/split/slightly-advanced-techniques.html#serialization

不过，我对一些事情感到困惑。在关于序列化的这一节中，他谈到了出于字节排序的原因而序列化整数，这对我来说很有意义，但他还包括这两个函数 pack754 和 unpack754，用于以 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;
}

我感到困惑的是，这些函数的工作原理是先查看符号的第一位，然后查看指数的下一个 X 位，再查看尾数的下一个 Y 位。那么，这是否意味着浮点数在主机上必须已经采用 IEEE-754 格式才能正常工作？

这只是为了解释格式，还是你在现实生活中实际会做的事情？

我在 React 中使用它@react-three/fiber来实现 3D 内容。有很多组件不支持声明式操作方式，需要 refs 和命令式代码（例如CameraControlsdrei）。

我正在尝试在CameraControls启动时初始化：

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} />
    ...
)

当然，这是行不通的，因为在第一次也是唯一一次useEffect执行时，cameraRef.current仍然是null。

当我尝试使用超时破解时，当前仍然为空：

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

当我将超时时间增加到几百毫秒时，它开始工作：

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

这种带有超时的方法是糟糕的，需要寻找更好的方法。

有没有办法编写一些自定义钩子，让它返回refObject，然后在当前第一次填充时执行提供的函数？

GCC 接受此代码，但 Clang 和 MSVC 拒绝此代码，因为 中的静态断言失败assert。标准是怎么说的？

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);

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);

HashMap<&String, V>使用索引的正确方法是什么&str？Rust 报告&String不是Borrow<str>，这是索引所必需的。（这对我来说似乎有点傻；如果T: Borrow<U>那么肯定&T: Borrow<U>也应该成立？）

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>`

显然，因为我构建了这个特定的 HashMap，所以我可以返回并将其键类型更改为&str。但是，假设我得到了一个HashMap<&String, V>，那么对其进行索引的正确方法是什么？构建一个整体String只是为了引用它似乎很浪费。

我需要在 AIX 中更改字符串的顺序，但使用命令cut我无法做到这一点

前任： echo FT0215202301.xml | cut -b 7-10,5-6,3-4

结果： 02152023

预期的： 20230215

我的代码：

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()

错误：

RuntimeError：尝试第二次向后遍历图表（或在已释放已保存的张量后直接访问它们）。调用 .backward() 或 autograd.grad() 时，将释放已保存的图表中间值。如果您需要第二次向后遍历图表，或者在调用 Backward 后需要访问已保存的张量，请指定 retain_graph=True。

为什么它会尝试第二次向后遍历同一张图？我是否在释放已保存的张量后直接访问它们？

我正在尝试旋转父圆并消除对其子圆的影响。我尝试使用以下方法消除影响

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

但是子元素在过渡开始时会旋转 60 度。如何防止它们在过渡期间完全旋转？

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>