小编Mot*_*sim的帖子

我正在通过黑客机器学习,我被困在这一行:

from.weight <- ddply(priority.train, .(From.EMail), summarise, Freq = length(Subject))

这会产生以下错误:

Error in attributes(out) <- attributes(col) : 
  'names' attribute [9] must be the same length as the vector [1]

这是一个追溯():

> traceback()
11: FUN(1:5[[1L]], ...)
10: lapply(seq_len(n), extract_col_rows, df = x, i = i)
9: extract_rows(x$data, x$index[[i]])
8: `[[.indexed_df`(pieces, i)
7: pieces[[i]]
6: function (i) 
   {
       piece <- pieces[[i]]
       if (.inform) {
           res <- try(.fun(piece, ...))
           if (inherits(res, "try-error")) {
               piece <- paste(capture.output(print(piece)), collapse = "\n")
               stop("with piece ", i, ": …

在 iOS 14 及更早版本上，我们导入presentationMode环境变量：

@Environment(\.presentationMode) var presentationMode

然后打电话self.presentationMode.wrappedValue.dismiss()驳回视图。

这在 iOS 15 上已被弃用，并dismiss引入了一个新的环境变量 ：

@Environment(\.dismiss) var dismiss

我们可以直接调用 usingdismiss()来实现相同的效果。

我知道我们可以执行以下操作来调用适当的解雇函数并支持所有版本：

if #available(iOS 15, *) {
    self.dismiss()
} else {
    self.presentationMode.wrappedValue.dismiss()
}

但是如何导入/定义正确的环境变量呢？因为尝试这不起作用：

if #available(iOS 15, *) {
    @Environment(\.dismiss) var dismiss
} else {
    @Environment(\.presentationMode) var presentationMode: Binding<PresentationMode>
}

编辑：

显然，presentationMode在 iOS 15 Beta 4 上，使用关闭导航堆栈中的视图仍然有效。除非 NavigationView 中有 TabView：

struct ContentView: View {
    var body: some View {
        NavigationView {
            TabView { …

import nltk
>>> nltk.__version__
'3.0.4'
>>> nltk.word_tokenize('"')
['``']
>>> nltk.word_tokenize('""')
['``', '``']
>>> nltk.word_tokenize('"A"')
['``', 'A', "''"]

看看它如何变成"双重``和''？

这里发生了什么事？为什么要改变这个角色？有修复吗？因为我需要稍后在字符串中搜索每个标记.

Python 2.7.6如果它有任何区别.

我是在查看项目的源代码,我注意到以下语句(keyByte和codedByte都是类型byte):

return (byte)(keyByte - codedByte);

我现在正在尝试理解在keyByte小于codedByte的情况下结果会是什么,这会导致负整数.

经过一些实验来了解投射负整数的结果,其值在[-255:-1]范围内,我得到以下结果:

byte result = (byte) (-6);  // result = 250
byte result = (byte) (-50); // result = 206
byte result = (byte) (-17); // result = 239
byte result = (byte) (-20); // result = 236

所以,只要-256 < a < 0我能够通过以下方式确定结果:

result = 256 + a;

我的问题是:我是否应该始终期待这种情况？

如果我有阵列:

{01101111,11110000,00001111} // {111, 240, 15}

1位移位的结果是:

{10110111,11111000,00000111} // {183, 248, 7}

阵列大小不固定,移位将从1到7(包括1和7).目前我有以下代码(工作正常):

private static void shiftBitsRight(byte[] bytes, final int rightShifts) {
   assert rightShifts >= 1 && rightShifts <= 7;

   final int leftShifts = 8 - rightShifts;

   byte previousByte = bytes[0]; // keep the byte before modification
   bytes[0] = (byte) (((bytes[0] & 0xff) >> rightShifts) | ((bytes[bytes.length - 1] & 0xff) << leftShifts));
   for (int i = 1; i < bytes.length; i++) {
      byte tmp = bytes[i];
      bytes[i] = (byte) …

我熟悉多线程,我已经成功地用Java和Objective-C开发了许多多线程程序.但是在没有使用主线程的连接的情况下,我无法使用pthreads在C中实现以下内容:

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

#define NUM_OF_THREADS 2

struct thread_data {
    int start;
    int end;
    int *arr;
};

void print(int *ints, int n);
void *processArray(void *args);

int main(int argc, const char * argv[])
{
    int numOfInts = 10;
    int *ints = malloc(numOfInts * sizeof(int));
    for (int i = 0; i < numOfInts; i++) {
        ints[i] = i;
    }
    print(ints, numOfInts); // prints [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    pthread_t threads[NUM_OF_THREADS];
    struct thread_data thread_data[NUM_OF_THREADS];

    // …

我有以下代码执行数组中位的循环移位:

private static void method1(byte[] bytes) {
    byte previousByte = bytes[0];
    bytes[0] = (byte) (((bytes[0] & 0xff) >> 1) | ((bytes[bytes.length - 1] & 0xff) << 7));
    for (int i = 1; i < bytes.length; i++) {
       byte tmp = bytes[i];
       bytes[i] = (byte) (((bytes[i] & 0xff) >> 1) | ((previousByte & 0xff) << 7));
       previousByte = tmp;
    }
}

然后我认为这样做更容易,更易读:

private static void method2(byte[] bytes) {
    byte lastByte = bytes[bytes.length-1];
    for (int i = bytes.length-1; i > 0; i--) …

我有一个128位字符串,我的主管要求我将这128位表示为多项式.这是他正在写的论文的扫描:

他的想法是,由于我们从这些位中消除了0,我们将能够比我们处理所有位更快地执行下一个操作(大多数是位/多项式之间的XOR).

我理解要求是什么,我可以在纸上和应用程序中完成.但我的方式不会实现他的目标,即提高绩效.他实际上说有些图书馆已经这样做了,但遗憾的是我找不到任何图书馆.我发现的唯一一个是多项式类来评估多项式,这不是我想要的.

所以你们知道如何实现这一点来提高性能？任何代码/片段/文章非常感谢.

该应用程序是用Java编写的,如果这有任何区别的话.

谢谢,

莫塔

更新:

我的主管说这个C库将完成任务.我无法弄清楚它是如何工作的以及如何做到这一点.

我有一个被调用数百万次的函数，这个函数完成的工作是多线程的。这是函数：

void functionCalledSoManyTimes()
{
  for (int i = 0; i < NUM_OF_THREADS; i++)
  {
    pthread_create(&threads[i], &attr, thread_work_function, (void *)&thread_data[i]);
  }
  // wait
}

每次调用函数时，我都会创建线程，并为每个线程提供其数据结构（在算法开始时设置一次）以在thread_work_function. 在thread_work_function简单地处理一个系列阵列，并且所述thread_data结构包含指向那些阵列和索引，每个线程负责。

尽管以这种方式对算法进行多线程处理确实将性能提高了 20% 以上，但我的分析表明对 pthread_create 的重复调用导致了显着的开销。

我的问题是：有没有办法在pthread_create每次调用函数时不调用就实现我的目标？

问题解决了。

谢谢你们，我真的很感谢你们的帮助！我在这里使用您的提示编写了一个解决方案。

我有一个带有 DateTimeField 的模型，我想用它来对管理中的表进行排序。ordering = ('-completed',)在工作中使用admin.py，但那些有null值的在排序中排在第一位。有没有办法让它们出现在最后？

所以现在我有这样的事情：

Column A     Completed       Column C
x            -               y
x            -               y
x            Today's date    y
x            Yesterday's     y

有没有办法让它像这样？

Column A     Completed       Column C
x            Today's date    y
x            Yesterday's.    y
x            -               y
x            -               y