小编use*_*814的帖子

我使用scipy.spatial.ConvexHull创建了一个凸包.我需要计算凸包和光线之间的交点,从0开始并在某个其他定义点的方向上.已知凸包含0,因此应保证交叉.问题的维度可以在2到5之间变化.我尝试了一些谷歌搜索,但没有找到答案.我希望这是计算几何中已知解决方案的常见问题.谢谢.

import numpy as np
x = np.random.randn(2, 3, 4)
mask = np.array([1, 0, 1, 0], dtype=np.bool)
y = x[0, :, mask]
z = x[0, :, :][:, mask]
print(y)
print(z)
print(y.T)

为什么分两步完成上述操作会导致一步到位？

我想在内存中获取一个数据帧作为 hdf。下面的代码导致“AttributeError: '_io.BytesIO' object has no attribute 'put'”。我正在使用 python 3.5 和 Pandas 0.17

import pandas as pd
import numpy as np
import io

df = pd.DataFrame(np.arange(8).reshape(-1, 2), columns=['a', 'b'])
buf = io.BytesIO()
df.to_hdf(buf, 'some_key')

更新：正如 UpSampler 指出的那样，“path_or_buf”不能是 io 流（我觉得这很令人困惑，因为 buf 通常可以是 io 流，请参阅to_csv）。除了写入磁盘并将其读回之外，我可以在内存中获取数据帧作为 hdf 吗？

在下面的代码中,为什么第二个循环能够自动矢量化但第一个不能？如何修改代码以便自动进行矢量化？gcc说:

注意:没有矢量化:控制循环中的流程.

我使用的是gcc 8.2,标志是-O3 -fopt-info-vec-all.我正在编译x86-64 avx2.

#include <stdlib.h>
#include <math.h>

void foo(const float * x, const float * y, const int * v, float * vec, float * novec, size_t size) {
    size_t i;
    float bar;
    for (i=0 ; i<size ; ++i){
        bar = x[i] - y[i];
        novec[i] = v[i] ? bar : NAN;
    }
    for (i=0 ; i<size ; ++i){
        bar = x[i];
        vec[i] = v[i] ? bar : NAN;
    }
}

更新:这会自动执行:

for (i=0 ; i<size ; ++i){ …

App.js

import React, { Component } from "react";
import Select from "react-select";

const SELECT_OPTIONS = ["FOO", "BAR"].map(e => {
  return { value: e, label: e };
});

class App extends Component {
  state = {
    selected: SELECT_OPTIONS[0].value
  };

  handleSelectChange = e => {
    this.setState({ selected: e.value });
  };

  render() {
    const { selected } = this.state;
    const value = { value: selected, label: selected };
    return (
      <div className="App">
        <div data-testid="select">
          <Select
            multi={false}
            value={value}
            options={SELECT_OPTIONS}
            onChange={this.handleSelectChange}
          />
        </div>
        <p data-testid="select-output">{selected}</p> …

下面是一个使用WatchService保持数据与文件同步的简单示例.我的问题是如何可靠地测试代码.测试偶尔会失败,可能是因为os/jvm将事件带入监视服务和测试线程轮询监视服务之间的竞争条件.我的愿望是保持代码简单,单线程和非阻塞,但也可以测试.我强烈不喜欢将任意长度的睡眠调用放入测试代码中.我希望有更好的解决方案.

public class FileWatcher {

private final WatchService watchService;
private final Path path;
private String data;

public FileWatcher(Path path){
    this.path = path;
    try {
        watchService = FileSystems.getDefault().newWatchService();
        path.toAbsolutePath().getParent().register(watchService, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
    load();
}

private void load() {
    try (BufferedReader br = Files.newBufferedReader(path, Charset.defaultCharset())){
        data = br.readLine();
    } catch (IOException ex) {
        data = "";
    }
}

private void update(){
    WatchKey key;
    while ((key=watchService.poll()) != null) {
        for (WatchEvent<?> e : key.pollEvents()) …

这是一个完整简单的工作示例

import multiprocessing as mp
import time
import random


class Foo:
    def __init__(self):
        # some expensive set up function in the real code
        self.x = 2
        print('initializing')

    def run(self, y):
        time.sleep(random.random() / 10.)
        return self.x + y


def f(y):
    foo = Foo()
    return foo.run(y)


def main():
    pool = mp.Pool(4)
    for result in pool.map(f, range(10)):
        print(result)
    pool.close()
    pool.join()


if __name__ == '__main__':
    main()

我怎样才能修改它,所以Foo只被每个工人初始化一次,而不是每个任务？基本上我想要初始化调用4次,而不是10次.我使用的是python 3.5

我的原型文件是：

syntax = "proto3";

import "google/protobuf/timestamp.proto";

service Foo {
  rpc now(NowRequest) returns (NowResponse) {}
}

message NowRequest {}

message NowResponse {
  google.protobuf.Timestamp now = 1;
}

我生成代码的命令和由此产生的错误是：

protoc foo.proto --go_out=plugins=grpc,import_path=proto:internal/proto
foo.proto:3:1: Import "google/protobuf/timestamp.proto" was not found or had errors.
foo.proto:12:3: "google.protobuf.Timestamp" is not defined.

我的协议版本是：

protoc --version
libprotoc 3.11.3

我已遵循本指南并查看了此问题。如何导入众所周知的类型？我需要下载其他东西吗？我如何知道我当前安装的确切已知类型是什么？谢谢你。

为什么下面的代码baz, done之前打印1, 2, 3？

const bar = () => Promise.resolve([1, 2, 3]);
const cat = e => {
  console.log(e);
  return Promise.resolve(e);
};
const foo = () =>
  bar()
    .then(arr => Promise.all(arr.map(e => cat(e))))
    .then(console.log("baz"));

foo().then(console.log("done"));

如何在C中方便地初始化大型稀疏数组？下面的代码可以工作,但是对于大型数组来说变得难以处理,基本上是一种全新的方法可以解决一个错误!例如,如果我想要一个长度为200的数组,除了索引7,62,100和189的1之外,该怎么办.这些值在编译时是已知的.我想知道宏是否可以生成数组.

const char myArray[] = {0,0,1,0,0,0,0,0,1,0};

这个问题适用于C++,但也许结构的技巧也适用于C语言.