主页 / coding / 问题

全部问题(coding)

Martin Hope
Amir Zhaybev
Asked: 2024-10-29 09:54:19 +0800 CST
  • 8

我尝试了几种逻辑来处理我的这个问题。

  1. 使用线程本地存储 (TLS)
#include <iostream>
#include <thread>

void thread_function() {
    thread_local int local_var = 0;
    local_var++;
    std::cout << "Local variable value: " << local_var << std::endl;
}

int main() {
    std::thread t1(thread_function);
    std::thread t2(thread_function);
    t1.join();
    t2.join();
    return 0;
}
  1. 应用智能指针
#include <iostream>
#include <memory>

void shared_pointer_example() {
    std::shared_ptr<int> sptr(new int(10));
    std::shared_ptr<int> sptr2 = sptr; // reference count increased
    std::cout << "Shared Pointer value: " << *sptr << std::endl;
}

void unique_pointer_example() {
    std::unique_ptr<int> uptr(new int(20));
    std::cout << "Unique Pointer value: " << *uptr << std::endl;
    // std::unique_ptr<int> uptr2 = uptr; // Error: unique_ptr cannot be copied
}

int main() {
    shared_pointer_example();
    unique_pointer_example();
    return 0;
}
  1. 实现无锁数据结构
#include <iostream>
#include <atomic>
#include <vector>
#include <thread>

std::atomic<int> atomic_counter(0);

void increment() {
    for (int i = 0; i < 1000; ++i) {
        atomic_counter++;
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment);
    }
    for (auto& t : threads) {
        t.join();
    }
    std::cout << "Atomic Counter: " << atomic_counter.load() << std::endl;
    return 0;
}

但实际上，没有一个是直观的，或者足够好到可以真正发挥作用。我该怎么办？

我已经尝试了上面提到的 4 种解决方案

c++
Martin Hope
farrow90
Asked: 2024-10-28 21:42:21 +0800 CST
  • 8

我在 R 中有一个马尔可夫链：

set.seed(123)

n_states <- 5

matrix <- matrix(runif(n_states^2), nrow=n_states)

# set some transitions to 0 
matrix[1, 4:5] <- 0 
matrix[5, 1:3] <- 0  
matrix[2, 5] <- 0    

transition_matrix <- t(apply(matrix, 1, function(x) x/sum(x)))

rownames(transition_matrix) <- paste0("S", 1:n_states)
colnames(transition_matrix) <- paste0("S", 1:n_states)

print(round(transition_matrix, 3))

它看起来像这样：

          S1         S2        S3         S4        S5
S1 0.2229340 0.03531601 0.7417500 0.00000000 0.0000000
S2 0.3910569 0.26197885 0.2248868 0.12207747 0.0000000
S3 0.1536622 0.33530265 0.2545791 0.01580275 0.2406533
S4 0.2652280 0.16563210 0.1719994 0.09849610 0.2986444
S5 0.0000000 0.00000000 0.0000000 0.59278229 0.4072177

对于固定的回合数，我想找出所有可能出现的状态序列及其对应的概率。

我尝试使用循环手动枚举所有这样的序列：

# Function to generate sequences for multiple turn lengths
find_sequences_all_turns <- function(transition_matrix, start_state = 1, max_turns = 5) {
    n_states <- nrow(transition_matrix)
    
   
    all_sequences <- list()
    all_probabilities <- numeric()
    all_turns <- numeric()
    seq_counter <- 1
    
    generate_sequence <- function(current_seq, current_prob, steps_left, total_steps) {
        if(length(current_seq) > 1) {
            all_sequences[[seq_counter]] <<- current_seq
            all_probabilities[seq_counter] <<- current_prob
            all_turns[seq_counter] <<- total_steps - steps_left
            seq_counter <<- seq_counter + 1
        }
        
        if(steps_left == 0) {
            return()
        }
        
        current_state <- current_seq[length(current_seq)]
        possible_next_states <- which(transition_matrix[current_state,] > 0)
        
        for(next_state in possible_next_states) {
            prob <- transition_matrix[current_state, next_state]
            generate_sequence(
                c(current_seq, next_state),
                current_prob * prob,
                steps_left - 1,
                total_steps
            )
        }
    }
    
    generate_sequence(c(start_state), 1, max_turns - 1, max_turns)
    
    result_df <- data.frame(
        turn = all_turns,
        sequence_no = 1:length(all_sequences),
        sequence = sapply(all_sequences, paste, collapse=""),
        probability = all_probabilities
    )
    
    result_df <- result_df[order(result_df$turn, -result_df$probability),]
    rownames(result_df) <- NULL
    
    return(result_df)
}

然后我尝试调用该函数：

sequences_df <- find_sequences_all_turns(transition_matrix)

> sequences_df
    turn sequence_no sequence  probability
1      2         154       13 7.417500e-01
2      2           1       11 2.229340e-01
3      2          65       12 3.531601e-02
4      3         171      132 2.487108e-01
5      3         193      133 1.888341e-01
6      3         243      135 1.785046e-01
7      3          40      113 1.653613e-01
8      3         155      131 1.139789e-01
9      3           2      111 4.969955e-02
10     3          66      121 1.381057e-02
11     3         218      134 1.172169e-02
12     3          82      122 9.252048e-03
13     3         104      123 7.942105e-03
14     3          18      112 7.873137e-03
15     3         129      124 4.311289e-03

我可以做些什么来确保此代码在大量回合中运行得更快

PS：我使用此代码来验证每次所有概率的总和是否为 1：

library(dplyr)

probability_sums <- sequences_df %>%
    group_by(turn) %>%
    summarise(
        total_probability = sum(probability),
        num_sequences = n(),
        check_sum_to_one = abs(total_probability - 1) < 1e-10
    )

print(probability_sums)
Martin Hope
Zebrafish
Asked: 2024-10-27 15:12:20 +0800 CST
  • 8

我尝试过：

#ifdef USE_CPP20_MODULES
#define IMPORT_OR_INCLUDE(module_name, include_filepath) \
import module_name;
#else
#define IMPORT_OR_INCLUDE(module_name, include_filepath) \
#include include_filepath
#endif

但是没有一个编译器可以编译它：

铛：

    Output of x86-64 clang 19.1.0 (Compiler #1)

<source>:6:2: error: '#' is not followed by a macro parameter
    6 | #include include_filepath
      |  ^

海湾合作委员会（GCC）：

<source>:5:56: error: '#' is not followed by a macro parameter
    5 | #define IMPORT_OR_INCLUDE(module_name, include_filepath) \

我不明白预处理器为何会失败。
我猜你不能将其用作#include宏的定义/替换？

c++
Martin Hope
whatf0xx
Asked: 2024-10-26 22:15:28 +0800 CST
  • 8

我正在研究这个问题以回答我遇到的一个简单问题：我想要一个 if/else 块来决定迭代是否应该有一个附带的tqdm进度条：

fn run(n: usize, verbose: bool) {
  let it = if verbose { tqdm(0..n) } else { 0..n };
  for _ in it { _ }
}

上面的代码无法编译，因为 if/else 的两个分支具有不同的类型，一个是 a Range，另一个是 a Tqdm<Range>。但是，根据顶部链接的问题，我进行了以下修改，并且可以很好地编译：

fn run(n: usize, verbose: bool) {
  let it: Box<dyn impl Iterator<Item = usize>> = if verbose { 
    Box::new(tqdm(0..n))
  } else {
    Box::new(0..n)
  };
  for _ in it { _ }
}

通过指定类型（这实际上是必要的，仅仅包装它Box没有帮助），我可以使代码编译。但是，我天真地觉得这意味着对象有一个额外的堆分配，dyn Iterator而之前所有东西（至少据我所知）或多或少都是在堆栈框架内处理的。我知道一般来说，动态调度（我认为这是但我不完全确定）确实会带来性能损失。

在包装之前Box我确实尝试过只是注释dyn Iterator<Item = usize>但是这不起作用，我猜是因为某种程度上Box抽象是必要的，但我不太明白为什么。

有没有办法让这段代码或其背后的想法在不进行和堆分配的情况下进行编译？这是否没有我想象的那么重要？如果这是不可能的，为什么我不能像上面提到的那样在没有的情况下Box做简单的事呢？dyn IteratorBox

rust
Martin Hope
nexos
Asked: 2024-10-26 06:58:00 +0800 CST
  • 8

我一直在尝试通读 ARM 手册，以了解 ARM 的架构工作原理。我知道每个 EL 都有一个用于 SP 的系统寄存器，如 SP_EL0、SP_EL1 等。我还知道 PSTATE 中有一个 SPSel 位，用于选择在 EL 更改时是否从 SP_EL0 或 SP_ELx 获取堆栈指针。但是，我的问题是，SP 是否在架构上映射到适当的 SP_ELx 寄存器，或者 SP_ELx 是否在 EL 更改时复制到 SP？换句话说，如果我写入 SP，我是否也会写入 SP_ELx？

我尝试阅读这方面的手册，但它看起来相当模糊，并且可以用任何一种方式来解释。

assembly
Martin Hope
akryukov
Asked: 2024-10-26 03:48:56 +0800 CST
  • 8

在我们的代码库中，我们的代码可以归结为以下内容（尝试使用动态堆栈分配而不是堆分配）：

#include <memory>
#include <alloca.h>

void f(long long const* data, size_t len);

void h(int const* data, size_t len)
{
  std::unique_ptr<char[]> heapBuff;

  auto nbytes = len * sizeof(long long);
  long long* arr;                                                 
  if (nbytes <= 1024) {                          
    arr = reinterpret_cast<long long*>(alloca(nbytes));
  }
  else {
    heapBuff.reset(new char[nbytes]);
    arr = reinterpret_cast<long long*>(heapBuff.get());
  }

  for (size_t i=0; i < len; ++i)
    arr[i]=data[i];

  f(arr, len);
}

（编译器资源管理器中的完整示例），从版本 11 开始，GCC中的编译结果会出现“可能使用未初始化”警告。

/app/h.cpp: In function 'void h(const int*, size_t)':
/app/h.cpp:23:4: warning: 'arr' may be used uninitialized [-Wmaybe-uninitialized]
   23 |   f(arr, len);
      |   ~^~~~~~~~~~
In file included from /app/h.cpp:2:
/app/f.hpp:4:6: note: by argument 1 of type 'const long long int*' to 'void f(const long long int*, size_t)' declared here
    4 | void f(long long const* data, size_t len);
      |      ^

Clang 或更早版本的 GCC 不会产生此警告。
在我看来，没有导致arr指针未初始化的路径，并且代码非常简单，编译器应该可以轻松找出原因。我是不是漏掉了什么？
有一点很奇怪，用 替换alloca()不会malloc()影响警告，但用一些非内联void* allocate(size_t)函数替换 会消除警告。

c++
Martin Hope
Kambal
Asked: 2024-10-26 02:51:51 +0800 CST
  • 8

在 Luciano Ramalho 所著的《Fluent Python》一书（第 2 版）中，他定义了容器序列和平面序列的概念：

容器序列保存对其所包含的对象的引用，这些对象可以是任何类型，而平面序列将其内容的值存储在其自己的内存空间中，而不是作为不同的 Python 对象。

range我们可以说和类型的对象bytearray是平面序列吗（我认为这些对象不能包含引用，但不确定）？
有没有一种简单的方法来测试一个序列是否是平面的？

我刚刚发现这篇文章引用了《Fluent Python》一书第一版中的一段话（我个人只有第二版）：

平面序列：str，bytes，bytearray，memoryview和array.array仅保存一种类型的项目。

因此，这似乎bytearray是一个平序列。在第二版（第 22 页）中，作者只说

扁平序列 – 保存一种简单类型的项目。例如：str、bytes和array.array。
容器序列 – 可以保存不同类型的项目，包括嵌套容器。例如：list、tuple和collections.deque。

python
Martin Hope
Mike
Asked: 2024-10-26 02:38:42 +0800 CST
  • 8

我找到了三种 RGB888 到 RGB565 的转换算法，但我不确定哪种最正确。前两种产生相同的结果。第三种产生不同的结果，但与在线计算器一致。第三种是有道理的，因为它可以缩放。但前两种会更快，因为没有整数乘法或除法。

uint8_t r8, g8, b8;
uint16_t r5, g6, b5, val;

r8 = someredvalue;
g8 = somegreenvalue;
b8 = somebluevalue;


// first method:
b5 =  (b8  >> 3)        & 0x001F;
g6 = ((g8  >> 2) <<  5) & 0x07E0;
r5 = ((r8  >> 3) << 11) & 0xF800;
val = (r5 | g6 | b5);
printf("%d, %d, %d, %u\n", r8, g8, b8, val);


// second method:
val = ((r8 & 0b11111000) << 8) | ((g8 & 0b11111100) << 3) | (b8 >> 3);
printf("%d, %d, %d, %u\n", r8, g8, b8, val);


// third method:
r5 = r8 * 31 / 255;
g6 = g8 * 63 / 255;
b5 = b8 * 31 / 255;     
val =  (r5 << 11) | (g6 << 5) | (b5);
printf("%d, %d, %d, %u\n", r8, g8, b8, val);
c
Martin Hope
Mark
Asked: 2024-10-26 00:46:02 +0800 CST
  • 8

我正在努力sympy获得方程的符号解。这是我的代码：

import sympy as sp

# Define the symbolic variable
x = sp.symbols('x')

# Define f(x)
f = ((x**2 - 2)**2 - 2)**2 - 2

# Solve the equation f(x) = 0
solutions = sp.solve(f, x)

# Filter only the positive solutions
positive_solutions = [sol for sol in solutions if sol.is_real and sol > 0]

# Print the positive solutions
print("The positive solutions of the equation f(x) = 0 are:")
for sol in positive_solutions:
    print(sol)

我正在使用 SymPy 来解方程

[ L_3(x) = \left(\left(x^2 - 2\right)^2 - 2\right)^2 - 2 = 0 ]

我能够得到正解。但是，返回的解带有嵌套的平方根，使得内部根出现在左侧，如下所示：

sqrt(2 - sqrt(2 - sqrt(2)))
sqrt(2 - sqrt(sqrt(2) + 2))
sqrt(sqrt(2 - sqrt(2)) + 2)
sqrt(sqrt(sqrt(2) + 2) + 2)

我希望嵌套的平方根以一种方式格式化，使它们都出现在右侧，如下所示：

sqrt(2 - sqrt(2 - sqrt(2)))
sqrt(2 - sqrt(sqrt(2) + 2))
sqrt(2 + sqrt(2 - sqrt(2))) 
sqrt(2 + sqrt(sqrt(2) + 2))

有没有办法调整解决方案的输出格式，以便嵌套平方根按预期显示？任何帮助都将不胜感激！谢谢！

python
Martin Hope
Markus Müller
Asked: 2024-10-25 19:21:09 +0800 CST
  • 8

我想使用 Doxygen 将static constexpr命名空间中定义的添加到我的文档中。这似乎不起作用。只有constexpr那些没有static被转移的。
我使用的是 Doxygen 1.12.0

有人有想法吗？

这是我的示例代码：

/// @file foo.cpp

/** @defgroup group_1
*/
/** @defgroup group_2
 *  @ingroup group_1
*/

class ABC {
public:
/// @ingroup group_2
/// @brief lorem
static constexpr uint32_t AA=123;
/// @ingroup group_2
/// @brief ipsum
static constexpr uint32_t BB=456;

private:
/// @ingroup group_2
/// @brief what_abcd
static constexpr uint32_t  private_abcdef = 42;
};

namespace parameterXYZ {
/// @ingroup group_2
/// @brief lorem
constexpr uint32_t D=77;
/// @ingroup group_2
/// @brief lorem
static constexpr uint32_t E=88;
}

int main() {

    /// @ingroup group_2
    /** \code */
    printf("ABC");
    /** \endcode */

    return 0;
}

结果如下： 生成的 HTML 的屏幕截图

我尝试启用/禁用所有相关的 Doxygen 构建参数，并尝试修改我的代码。但毫无效果。

c++
上一页
下一页