小编sas*_*cha的帖子

我有一个std::vector<int>和第二个容器持有迭代器或索引(没有键,我希望不断访问元素)到这个向量用于删除目的.让我们假设我有一个1000个元素的向量,并想要删除其中的200个元素.在删除操作之后,未删除元素的顺序应该与之前相同.

我在问题的第一个版本中错过了另一件事:价值观是独一无二的.他们是身份.

你如何在安全(关于stl规则)和有效方式(传统的决定是最终的)中做到这一点？

我想到的可能性或方法:

• 所述擦除remove惯用法(http://en.wikipedia.org/wiki/Erase-remove_idiom):最初为其中满足条件(包括直链的搜索)的元素的删除,但我认为有尺寸1这种方法可能是范围习惯于已经给定的迭代器和虚拟条件.问题:保留的元素的原始顺序是否比最后一种方法更高效？
• 循环遍历索引并使用vector.erase(vector.begin()+index+offset)同时删除元素,同时保持在容器中删除索引以计算偏移量.可以使用std::lower_bound已经移除的元素的容器来确定每次移除迭代的该偏移.问题:由于随机位置删除,很多binary_searches用于获取偏移量和大量移动操作.
• 目前我正在做以下事情:获取要删除的元素的所有迭代器.根据向量中的位置按降序对它们进行排序,并在它们上面循环以进行最终删除vector.erase.现在我没有使任何迭代器失效,除了删除本身之外没有向量重新排列操作.问题:很多排序

那么,你会如何解决这个问题呢？有什么新想法吗？有什么建议？

感谢您的输入.

萨沙

编辑/更新/拥有结果:我实现了擦除 - 删除习惯用法,这也是KennyTM提到的,带有一个基于boost :: dynamic_bitset中的查找的谓词,并且它的速度非常快.此外,我尝试了PigBen的move-and-truncate方法(也由Steve Jessop提到),它也在它的while循环中访问bitset.对我的数据来说,两者似乎同样快.我试图删除100个1000个元素(无符号整数)中的100个,这100个删除了1M次并且没有显着差异.因为我认为基于stl的擦除删除成语更"天生",我选择了这种方法(KennyTM也提到了参数).

C++ Library的GNU实现支持并行模式,这里解释.

• 有使用它的经验吗？好的？糟糕的？特别是关于正确性,还有性能.
• 是否有一些"或多或少严重"的项目使用它？
• 您是否将它与全局并联开关-D_GLIBCXX_PARALLEL一起使用,或者您是否小心使用它并手动启用特定的并行化功能,如:__gnu_parallel::sort(v.begin(), v.end());？
• 有没有类似的开源项目？含义:比使用openMP更容易并行化.

谢谢你的经验.

萨沙

我刚刚发现了Boost Phoenix库(隐藏在Spirit项目中)以及作为函数式编程风格的粉丝(但仍然是业余爱好者;有一些关于haskell和scheme的小经验)我想玩这个库来学习关于这个库的合理应用.

除了使用fp-style提高代码的表现力和清晰度之外,我对于以低成本加速计算的延迟评估特别感兴趣.

一个小而简单的例子如下:存在某种路由问题(如tsp),它使用的是eucliedean距离矩阵.我们假设,距离矩阵的某些值从未使用过,而且有些值经常使用(因此,为每次调用动态计算它们并不是一个好主意).现在,使用保持距离值的惰性数据结构似乎是合理的.凤凰怎么可能呢？(忽略了这样一个事实,即在没有fp风格编程的情况下我很容易就完成了)阅读凤凰的官方文档并没有让我理解到足以回答这个问题.

有可能吗？(例如,在Haskell中,创建thunk的能力保证了以后可以计算的值是语言的核心).

使用具有凤凰中定义的所有惰性函数的向量是什么意思？像我一样天真,我试图用随机值填充两个矩阵(vector>),一个用普通的push_back填充,另一个用boost :: phoenix :: push_back填充,并试图从这些矩阵中只读出少量的值并将它们存放在容器中以便打印出来.懒惰的人总是空着的.我是以错误的方式使用凤凰/应该可以吗？或者我误解了凤凰中容器/算法的功能.后者的一个小线索是FP ++库中存在一个特殊的列表数据结构,它影响了凤凰.

另外:

• 你用凤凰做什么的？
• 你知道一些关于凤凰的好资源吗？(教程,博客条目......)

感谢您的输入!

我是熊猫的新手,并尝试学习如何处理我的多维数据.

我的数据

我们假设,我的数据是列['A','B','C','D','E','F','G']的大CSV.该数据描述了一些模拟结果,其中['A','B',...,'F']是模拟参数,'G'是输出之一(本例中只有现有输出!).

编辑/更新: 正如Boud在评论中建议的那样,让我们​​生成一些与我的数据兼容的数据:

import pandas as pd
import itertools
import numpy as np

npData = np.zeros(5000, dtype=[('A','i4'),('B','f4'),('C','i4'), ('D', 'i4'), ('E', 'f4'), ('F', 'i4'), ('G', 'f4')])

A = [0,1,2,3,6] # param A: int
B = [1000.0, 10.000] # param B: float
C = [100,150,200,250,300] # param C: int
D = [10,15,20,25,30] # param D: int
E = [0.1, 0.3] # param E: float
F = [0,1,2,3,4,5,6,7,8,9] # param F = random-seed = int -> 10 runs per …

我是PyMC的新手,并尝试使用最大后验估计来拟合我的非齐次泊松过程和分段恒定速率函数.

我的过程描述了一天中的一些事件.因此,我将一天分成24小时,这意味着,我的速率函数中有24个常数(分段常数).

结合以下思路:

• 黑客的概率规划和贝叶斯方法:第1章
• SO问题:使用可变速率拟合带顶点的泊松过程

我提出了以下一段代码,这是不满意的(结果明智,我确定这是错的):

import numpy as np
import pymc

eventCounter = np.zeros(24) # will be filled with real counts before going on
alpha = 1.0 / eventCounter.mean()

a0 = pymc.Exponential('a0', alpha)
a1 = pymc.Exponential('a1', alpha)
a2 = pymc.Exponential('a2', alpha)
a3 = pymc.Exponential('a3', alpha)
a4 = pymc.Exponential('a4', alpha)
a5 = pymc.Exponential('a5', alpha)
a6 = pymc.Exponential('a6', alpha)
a7 = pymc.Exponential('a7', alpha)
a8 = pymc.Exponential('a8', alpha)
a9 = pymc.Exponential('a9', alpha)
a10 = pymc.Exponential('a10', alpha) …

我想在向量中使用我的元素的partial_sum,其中每个元素都是一个pair<double, unsinged int>.所述partial_sum应该递增(第一各对)添加双值.

例:

vector<pair<double, unsigned int> > temp_vec;
temp_vec.push_back(make_pair(0.5, 0));
temp_vec.push_back(make_pair(0.2, 1));
temp_vec.push_back(make_pair(0.3, 2));
partial_sum(temp_vec.begin(), temp_vec.end(), temp_vec.begin(), ???);   // in place

应该给我一个包含:[(0.5,0),(0.7,1),(1.0,2)]的向量

如何实现必要的仿函数来使用partial_sum函数？

我能够使用自定义函数在stl lower_bound搜索中使用我的对,但在上面的例子中,我不知道如何声明二进制操作.

我正在尝试使用完全按照文档中所述使用别名的resize函数:http://scikit-image.org/docs/dev/auto_examples/transform/plot_rescale.html

from skimage.transform import resize
im_test = resize(im_test, (im_test.shape[0] / 3, im_test.shape[1] / 3),anti_aliasing=True)

但是这会返回:

Scikit图片:resize()得到了一个意外的关键字参数'anti_aliasing'

这是什么原因？默认情况下是否打开anti_aliasing？如果不能使用此功能,使用抗锯齿调整图像大小的最佳方法是什么？

我正在使用Apache Arrow进行非常基本的实验，主要是关于使用 Arrow 的 IPC 格式（到文件）、Parquet 格式（到文件）和 IPC 格式（通过 JNI 流）在 Java、C++、Python 之间传递一些数据。

C++ 和 Python 看起来有些用处，但 Java 部分确实让我感到困扰。

可悲的是，Java 文档有点有限，但尽管承认这些隐藏文档（不是 TOC 的一部分）的警告，我只是想VectorSchemaRoot从以前编写的文件中填充一些。

忽略 99% 的实验代码，以下最小示例显示了我的问题，我只是创建一些数据，将其写出（可以很好地在 Python 中导入）并尝试用 Java 读回。

但是数据所有权似乎妨碍了我想要实现的目标。

也许保留VectorSchemaRoot作为核心条目的想法（例如：我的所有数据都在这里）是某种错误的用法，但我不确定有什么替代方法。为什么我要手动保留IntVectors和合作。当这个类会做同样的事情并提供一些 API 来使用它时。

package arrow.test;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import org.apache.arrow.memory.RootAllocator;
import org.apache.arrow.vector.BitVector;
import org.apache.arrow.vector.FieldVector;
import org.apache.arrow.vector.IntVector;
import org.apache.arrow.vector.VectorSchemaRoot;
import org.apache.arrow.vector.ipc.ArrowFileReader;
import org.apache.arrow.vector.ipc.ArrowFileWriter;
import org.apache.arrow.vector.types.pojo.ArrowType;
import org.apache.arrow.vector.types.pojo.Field;
import org.apache.arrow.vector.types.pojo.FieldType;
import org.apache.arrow.vector.types.pojo.Schema;

import com.google.common.collect.ImmutableList;

public …

我正在尝试使用python在正方形中对随机封闭的包装球进行建模.球体不应重叠, 但我不知道如何做到这一点

我到目前为止:

码:

import random, math, pylab

def show_conf(L, sigma, title, fname):
    pylab.axes()
    for [x, y] in L:
        for ix in range(-1, 2):
            for iy in range(-1, 2):
                cir = pylab.Circle((x + ix, y + iy), radius=sigma,  fc='r')
                pylab.gca().add_patch(cir)
    pylab.axis('scaled')
    pylab.xlabel('eixo x')
    pylab.ylabel('eixo y')
    pylab.title(title)
    pylab.axis([0.0, 1.0, 0.0, 1.0])
    pylab.savefig(fname)
    pylab.close()

L = []
N = 8 ** 2

for i in range(N):
    posx = float(random.uniform(0, 1))
    posy = float(random.uniform(0, 1))
    L.append([posx, posy])

print L

N = 8 …

我正在努力将sqrt函数(对于64位双精度数)从fdlibm移植到我目前正在使用的模型检查器工具(cbmc).
作为我的一部分,我阅读了很多关于ieee-754标准的内容,但我认为我不理解基本操作(包括sqrt)的精度保证.

测试我的fdlibm的sqrt端口,我在64位double上使用sqrt进行了以下计算:

sqrt(1977061516825203605555216616167125005658976571589721139027150498657494589171970335387417823661417383745964289845929120708819092392090053015474001800648403714048.0) = 44464159913633855548904943164666890000299422761159637702558734139742800916250624.0

(这个案例在我的测试中打破了关于精度的简单后置条件;我不确定是否可以使用IEEE-754来实现这种后置条件)

为了进行比较,几个多精度工具计算如下:

sqrt(1977061516825203605555216616167125005658976571589721139027150498657494589171970335387417823661417383745964289845929120708819092392090053015474001800648403714048.0) =44464159913633852501611468455197640079591886932526256694498106717014555047373210.truncated

可以看出,左起第17个数字是不同的,意味着如下错误:

3047293474709469249920707535828633381008060627422728245868877413.0

问题1:是否允许这么大的错误？

标准是说每个基本操作(+, - ,*,/,sqrt)应该在0.5 ulps之内,这意味着它应该等于数学上精确的结果四舍五入到最近的fp表示(维基说的是一些库)只保证1 ulp,但目前并不重要).

问题2:这是否意味着,每个基本操作都应该有一个错误<2.220446e-16,64位双精度(机器epsilon)？

我用x86-32 linux系统(glibc/eglibc)计算了相同的结果,并得到了与fdlibm相同的结果,让我想到:

• a:我做错了什么(但是如何:printf将成为候选人,但我不知道是否可能是这个原因)
• b:错误/精度在这些库中很常见