小编Mar*_*rkD的帖子

我有一个C++类,其成员函数可以使用少量到大量的参数.让我们命名那些参数,af.所有参数都有默认值.作为我正在研究的python项目的一部分,我想将这个类暴露给python.目前,成员函数看起来像这样:

class myClass {
    public:
    // Constructors - set a-f to default values.

    void SetParameters(std::map<std::string, double> &);
    private:
    double a, b, c, d, e, f;
}

void myClass::SetParameters(std::map<std::string, double> const& params) {
    // Code to iterate over the map, and set any found key/value pairs to their
    // corresponding variable.  i.e.- "a" --> 2.0, would set myClass::a to 2.0
}

理想情况下,在Python中,我想使用dict来实现这一点:

>>> A = myModule.myClass();
>>> A.SetParameters({'a': 2.2, 'd': 4.3, b: '9.3'})

通过这种方式,用户可以按任何顺序输入值,并输入任意数量的值以进行覆盖.有关如何在boost :: python中实现这一点的任何想法？在我看来,我可以通过将地图输入更改为boost :: python对象,并使用提取函数来实现此目的.但是,这需要我更改我的库的接口(我更喜欢保留std :: map接口,并为python版本提供一些中间/自动转换技术).思考？

我目前正在研究一个优化问题,该问题需要在所有基本方向上找到大于(或在某些情况下小于)特定点的所有点.例如,在2D中,我可能需要找到满足条件的所有点:

x > x* and y < y* 
for an arbitrary point (x*,y*)

(例如 - 如果下图中的蓝点是(x*,y*),我需要蓝色虚线定义的框中的所有点).

注意:我需要这是一个N维结构/搜索,因为我的实际优化问题有两个以上的目标,必须解决.典型的搜索空间大约为1000-5000点,并且具有2到5个维度.

是否有任何特定的数据结构非常适合此目的？在过去,我使用kd-trees来查找最近的邻居,以及半径内的所有点,但是在这种情况下我需要定向搜索.看起来某种形式的R-Tree可以解决这个问题,我的搜索矩形将分别从x*,y*变为一些主要的正值和负值.是否有更好的数据结构特定于这种搜索？

我目前正在为Python开发一个基于C++的模块.我发现Boost :: Python对我想要完成的工作非常有效.但是,我现在遇到了由Boost :: Python生成的docstring的一些问题.给出以下Boost :: Python定义:

BOOST_PYTHON_MODULE(gcsmt)
{
class_<gcsmt::Units>("Units", "Sets the units used as input.", no_init)
    .def("PrintSupported", &gcsmt::Units::printSupported, "Print out all supported units.")
    .def("SetDefault", &gcsmt::Units::setDefaultUnit, "Sets the default unit to be used for inputs/outputs.")
    .staticmethod("PrintSupported")
    .staticmethod("SetDefault")
    .def(self_ns::str(self_ns::self))
    ;
}

如果我编译,在Python中加载我的模块,并获得gscmt.Units类的帮助,输出如下:

>>> help(gcsmt.Units)

Help on class Units in module gcsmt:

class Units(Boost.Python.instance)
 |  Sets the units used as input.
 |  
 |  Method resolution order:
 |      Units
 |      Boost.Python.instance
 |      __builtin__.object
 |  
 |  Methods defined here:
 |  
 |  __reduce__ = <unnamed …

对于我目前正在处理的代码,我们有时需要使用较旧的编译器在一些较旧的系统上进行编译(例如,我们在较旧的IBM BlueGene/L上运行sims,谁的支持合同规定了一些相当旧的C++编译器).代码本身使用shared_ptrs,最初编写使用std :: tr1 :: shared_ptr.在旧的BlueGene机器上编译时,我很快意识到它没有tr1 :: implementation,所以我切换到boost :: shared_ptr.结果还有一个boost :: tr1 :: shared_ptr.既然代码在我们的研究小组之外被广泛使用,便携性变得更加重要.

在大型代码库中处理这些不断发展的标准库问题的最佳实践是什么？我假设在新的C++ 11标准中,shared_ptr将不再位于tr1命名空间中,这增加了另一个潜力:std :: shared_ptr,但我猜这种广泛的支持将是一个方法.如果可能的话,我想使用最新的标准,但需要保持可移植性.我应该坚持提升吗？

可以说我在python中有以下列表.首先按装备订购,然后按日期订购:

my_list = [
    {'Equip': 'A-1', 'Job': 'Job 1', 'Date': '2018-01-01'},
    {'Equip': 'A-1', 'Job': 'Job 1', 'Date': '2018-01-02'},
    {'Equip': 'A-1', 'Job': 'Job 1', 'Date': '2018-01-03'},
    {'Equip': 'A-1', 'Job': 'Job 2', 'Date': '2018-01-04'},
    {'Equip': 'A-1', 'Job': 'Job 2', 'Date': '2018-01-05'},
    {'Equip': 'A-2', 'Job': 'Job 1', 'Date': '2018-01-03'},
    {'Equip': 'A-2', 'Job': 'Job 3', 'Date': '2018-01-04'},
    {'Equip': 'A-2', 'Job': 'Job 3', 'Date': '2018-01-05'}
]

我想要做的是按照设备的工作不变的每一组折叠列表,并抓住设备在那里的第一个和最后一个日期.例如,这个简单的例子应该改为:

list_by_job = [
    {'Equip': 'A-1', 'Job': 'Job 1', 'First': '2018-01-01', 'Last': '2018-01-03'},
    {'Equip': 'A-1', 'Job': 'Job 2', 'First': …

我目前正在研究一个基于C++的大型稀疏线性代数问题库(是的,我知道很多这样的库存在,但我主要是为了学习迭代求解器,稀疏存储容器等等).

我正处于我在其他编程项目中使用求解器的地步,并希望针对不属于我自己的问题测试解算器.首先,我希望测试对称的稀疏系统是正定的.我找到了这样的系统矩阵的几个来源,例如:

Matrix Market UF稀疏矩阵集合

话虽这么说,我还没有找到任何包含整个系统 - 系统矩阵和RHS的良好测试矩阵的来源.为了检查结果,这将是很好的.关于我可以在哪里找到这样的完整系统的任何提示,或者我可以做什么来为我可以上网的系统矩阵生成"好的"RHS？我目前只是填充一个随机值或所有值的矩阵,但怀疑这不一定是最好的方法.

通常,我定义一个真正的全局常量(比方说,pi)的方法是在头文件中放置一个extern const,并在.cpp文件中定义常量:

constants.h:

extern const pi;

constants.cpp:

#include "constants.h"
#include <cmath>
const pi=std::acos(-1.0);

这适用于像pi这样的真常量.但是,我正在寻找一个最佳实践来定义一个"常量",因为它将从程序运行到程序运行保持不变,但可能会根据输入文件而改变.这方面的一个例子是引力常数,它取决于所用的单位.g在输入文件中定义,我希望它是任何对象都可以使用的全局值.我总是听说使用非常量全局变量是不好的做法,因此目前我已将其存储在系统对象中,然后将其传递给它生成的所有对象.然而,随着对象数量的增长,这似乎有点笨拙且难以维护.

思考？

按照多索引的文档代码,我执行以下操作:

arrays = [['bar', 'bar', 'baz', 'baz', 'foo', 'foo'],
          ['one', 'two', 'one', 'two', 'one', 'two']]
tuples = list(zip(*arrays))

index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])

df2 = pd.DataFrame(np.random.randn(3, 6), index=['A', 'B', 'C'], columns=index)

这会产生一个如下所示的数据框:

first        bar                 baz                 foo
second       one       two       one       two       one       two
A      -0.398965 -1.103247 -0.530605  0.758178  1.462003  2.175783
B      -0.356856  0.839281  0.429112 -0.217230 -2.409163 -0.725177
C      -2.114794  2.035790  0.059812 -2.197898 -0.975623 -1.246470

我的问题是,在我的输出(到HTML表)中,我想基于第二级索引进行分组,而不是第一级.产生看起来像的东西:

second       one                           two
first        bar       baz       foo       bar       baz       foo
A      -0.398965 -0.530605  1.462003 -1.103247 …

我在过去几年中开发的仿真工具是用C++编写的,目前有一个tcl解释的前端.编写它可以在交互式shell中运行,也可以通过传递输入文件.无论哪种方式,输入文件都是用tcl编写的(我添加了许多其他特定于仿真的命令).这允许非常强大的输入文件(例如,当运行monte-carlo sims时,随机分布可以直接在输入文件中编程为tcl过程).

不幸的是,我发现tcl解释器与现代解释语言提供的内容相比变得有限,而且它的语法似乎有些神秘.由于计算引擎是作为具有c兼容API的库编写的,因此编写替代前端应该很简单,而我正在考虑转移到新的解释器,但是我有一点时间选择(主要是因为我没有很多解释语言的经验).我开始探索的选项如下:

保留tcl:
优点:
- 无需更改现有代码.
- 现有输入文件保持不变.(虽然我可能会将tcl前端作为一个选项)
- 成熟的语言,有很多社区支持.
缺点:
- 感觉受语言语法的限制.
- 从用户那里获得有关学习tcl困难的投诉.

Python:
优点:
- 现代翻译,已知非常有效.
- 庞大,活跃的社区.
- 众所周知的科学和数学模块,如scipy.
- 常用于学术科学/工程界(我的代码的典型用户)
缺点:
- 我从未使用它,因此需要时间来学习语言(这也是专业人士,因为我一直有意学习python很长一段时间)
- 严格格式化输入文件(缩进等..)

Matlab:
优点:
- 非常强大和广泛使用的数学工具
- 强大的内置可视化/绘图.
- 可扩展,通过社区提交的代码,以及商业工具箱.
- 科学/工程学院的许多人都熟悉并熟悉matlab.
缺点:
- 不能作为可执行文件分发 - 需要是一个附加/工具箱.
- 需要(？)matlab编译器(这是pricy).
- 需要Matlab,这也很昂贵.

这些优点和缺点是我能够提出的,尽管我对解释语言的总体经验很少.我很想听到我在这里提出的解释器的任何想法,如果列出的这些优点/缺点是合法的,以及我没有想过的任何其他解释器(例如,php是否适合这样的事情？lua ？).在代码中嵌入解释器的第一手经验绝对是一个优势!

我在使用基本通信和组MPI2方法方面有相当多的经验,并且使用MPI进行了相当多的令人尴尬的并行仿真工作.到目前为止,我已经构建了我的代码,以便有一个调度节点和一堆工作节点.调度节点具有将与模拟器一起运行的参数文件列表.它使用参数文件为每个工作节点播种.工作节点运行其模拟,然后请求调度节点提供的另一个参数文件.运行所有参数文件后,调度节点会在关闭自身之前关闭每个工作节点.

参数文件通常命名为"Par_N.txt",其中N是标识整数(例如,-N = 1-1000).所以我在想,如果我可以创建一个计数器,并且可以在所有节点上同步这个计数器,我就可以省去调度节点,并使系统更简单一些.理论上这听起来很简单,在实践中我怀疑它有点困难,因为我需要确保计数器在被改变时被锁定等等.并且认为可能存在MPI的内置方式处理这个(事情.有什么想法吗？我在想这个吗？