采取以下数据框架:

x = np.tile(np.arange(3),3)
y = np.repeat(np.arange(3),3)
df = pd.DataFrame({"x": x, "y": y})

   x  y
0  0  0
1  1  0
2  2  0
3  0  1
4  1  1
5  2  1
6  0  2
7  1  2
8  2  2

我需要先排序x,然后排在第二位y:

df2 = df.sort(["x", "y"])

   x  y
0  0  0
3  0  1
6  0  2
1  1  0
4  1  1
7  1  2
2  2  0
5  2  1
8  2  2 …

介绍

我正在使用Google的测试框架Google-Mock编写关于Eigen矩阵的测试,正如另一个问题中已经讨论的那样.

使用以下代码,我能够添加一个自定义Matcher以匹配给定精度的特征矩阵.

MATCHER_P2(EigenApproxEqual, expect, prec,
           std::string(negation ? "isn't" : "is") + " approx equal to" +
               ::testing::PrintToString(expect) + "\nwith precision " +
               ::testing::PrintToString(prec)) {
    return arg.isApprox(expect, prec);
}

这样做是通过他们的isApprox方法比较两个特征矩阵,如果它们不匹配,Google-Mock将打印相应的错误消息,其中包含矩阵的预期值和实际值.或者,它应该至少......

问题

采取以下简单的测试用例:

TEST(EigenPrint, Simple) {
    Eigen::Matrix2d A, B;
    A << 0., 1., 2., 3.;
    B << 0., 2., 1., 3.;

    EXPECT_THAT(A, EigenApproxEqual(B, 1e-7));
}

此测试将失败,因为A并且B不相等.不幸的是,相应的错误消息如下所示:

gtest_eigen_print.cpp:31: Failure
Value of: A
Expected: is approx equal to32-byte object <00-00 00-00 00-00 …

我发现了一种情况,在这种情况下,Clang会产生非法指令,gcc没有这样做,同时试验这个问题.

我的问题是:我做错了什么,或者这是Clang的实际问题？

我把它归结为重现问题所需的最小片段.

拿文件eigen.cpp:

#include <iostream>

#define EIGEN_MATRIXBASE_PLUGIN "eigen_matrix_addons.hpp"
#include <Eigen/Dense>

int main() {
    Eigen::Matrix2d A;

    A << 0, 1, 2, 3;

    std::cout << A << "\n";
}

和文件eigen_matrix_addons.hpp:

friend std::ostream &operator<<(std::ostream &o, const Derived &m) {
    o << static_cast<const MatrixBase<Derived> &>(m);
}

(有关此文件的详细说明,请参见此处.简而言之,其内容直接放在类的定义中template<class Derived> class MatrixBase;.因此,这会引入另一个ostream运算符Derived,调用ostream运算符的Eigen实现MatrixBase<Derived>.此动机为此如果你读这个问题就会变得很明显.)

使用GCC编译并运行:

$ g++ -std=c++11 -Wall -Wextra -pedantic -isystem/usr/include/eigen3 -I. -o eigen_gcc eigen.cpp
$ ./eigen_gcc
0 1 …

介绍

免责声明:我对使用distutils的python包装非常陌生.到目前为止,我只是把所有东西都藏进了模块,手工打包并在此基础上开发.我以前从未写过setup.py文件.

我有一个Fortran模块,我想在我的python代码中使用numpy.我认为最好的方法是f2py,因为它包含在numpy中.为了自动化构建过程,我想使用distutils和相应的numpy增强功能,其中包括f2py包装器的便捷功能.

我不明白我应该如何组织我的文件,以及如何包含我的测试套件.

我想要的是./setup.py用于构建,安装,测试和开发的可能性.

我的目录结构如下:

volterra
??? setup.py
??? volterra
    ??? __init__.py
    ??? integral.f90
    ??? test
    ?   ??? __init__.py
    ?   ??? test_volterra.py
    ??? volterra.f90

该setup.py文件包含:

def configuration(parent_package='', top_path=None):
    from numpy.distutils.misc_util import Configuration
    config = Configuration('volterra', parent_package, top_path)
    config.add_extension('_volterra',
                         sources=['volterra/integral.f90', 'volterra/volterra.f90'])
    return config


if __name__ == '__main__':
    from numpy.distutils.core import setup
    setup(**configuration(top_path='').todict())

跑完后./setup.py build我得到了.

build/lib.linux-x86_64-2.7/
??? volterra
    ??? _volterra.so

其中既不包含__init__.py文件也不包含测试.

问题

• 是否真的有必要将路径添加到扩展的每个源文件中？(即volterra/integral.f90)我不能给出一个参数说,找东西volterra/？的top_path,并且package_dir参数没有做的伎俩. …

简而言之:如何在Haskell中过滤a Map或者Setmonadic谓词的元素？

我可以想到两种可能的方法:

a)往返列表并且filterM(可能效率不高):

filterMapM1 :: (Monad m, Ord k) => (v -> m Bool) -> M.Map k v -> m (M.Map k v)
filterMapM1 f m = liftM M.fromList $ filterM (f.snd) $ M.toList m

b)如果谓词不是固有的monadic,而是例如与Statemonad中的状态进行比较; 然后我们可以使用Data.Map.filter(非常特殊的情况):

filterMapM2 :: (Monad m, Ord k) => (v -> v -> Bool) -> M.Map k v -> StateT v m (M.Map k v)
filterMapM2 f m = do
    s <- get
    return $ …

我能找到的关于Persistent的所有教程和参考都非常详细地描述了Persistent如何在DSL中的单个定义中自动创建新的数据类型,模式,迁移等.但是,我找不到有关如何使Persistent处理现有数据类型的解释.

一个例子:假设我有一个已经存在的Haskell模块用于某些游戏逻辑.它包括玩家的记录类型.(它意味着通过镜头使用,因此是下划线.)

data Player = Player { _name   :: String
                     , _points :: Int
                     -- more fields ...
                     }
$(makeLenses ''Player)

问题:使用Persistent将这种类型存储在数据库中的规范方法是什么？我可以实现一些类型类吗？或者我应该通过Persistent最好地定义一个新类型,例如

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase|
PlayerEntry
    name Text
    points Int
|]

然后在这些类型之间手动映射？

playerToEntry :: Player -> PlayerEntry
playerToEntry pl = PlayerEntry (pl^.name) (pl^.points)

entryToPlayer :: PlayerEntry -> Player
entryToPlayer e = Player (name e) (points e)

我正在使用python与numpy,scipy和matplotlib进行数据评估.作为结果,我获得了带有错误栏的平均值和拟合参数.

我希望python能够根据给定的精度自动打印这些数据.例如:

假设我得到了结果x = 0.012345 +/- 0.000123.有没有办法1.235(12) x 10^-2在指定精度为2时自动格式化.也就是说,计算错误栏中的精度,而不是值.

有没有人知道提供此类功能的软件包,还是我必须自己实现？

有没有办法将其注入python字符串格式化机制？即能写出类似的东西"%.2N" % (0.012345, 0.0000123).

我已经查看了numpy和scipy的文档并用Google搜索,但我找不到任何东西.我认为对于处理统计数据的每个人来说,这都是一个有用的功能.

谢谢你的帮助!

编辑:根据内森怀特黑德的要求,我将举几个例子.

123 +- 1         ----precision 1----->  123(1)
123 +- 1.1       ----precision 2----->  123.0(11)
0.0123 +- 0.001  ----precision 1----->  0.012(1)
123.111 +- 0.123 ----precision 2----->  123.11(12)

为清楚起见,省略了10的幂.括号内的数字是标准错误的简写符号.parens之前的数字的最后一位数字和parens中数字的最后一位必须具有相同的十进制功率.出于某种原因,我无法在网上找到这个概念的好解释.只有我的事情是这家德国Wikpedia文章在这里.但是,它是一种非常常见且非常方便的符号.

EDIT2:我自己实现了速记符号:

#!/usr/bin/env python
# *-* coding: utf-8 *-*

from math import floor, log10

# uncertainty to string
def un2str(x, xe, precision=2):
    """pretty print nominal value and uncertainty

    x  - nominal …

我在python中使用argparse来解析命令行参数:

parser = ArgumentParser()
parser.add_argument("--a")
parser.add_argument("--b")
parser.add_argument("--c")
args = parser.parse_args()

现在我想要做一些计算用a,b和c.但是,我发现一直写的很烦人args.a + args.b + args.c.

因此,我正在提取这些变量:

a, b, c = [args.a, args.b, args.c]

这样我就可以写了a + b + c.

有更优雅的方式吗？

添加许多参数时,手动提取变得非常繁琐且容易出错.

问题

我有我想使用 ggplot2 在 y 轴上以对数刻度绘制的线图中的数据。不幸的是，我的一些价值观一直下降到零。数据表示依赖于某些参数的特征的相对出现。当在样本中没有观察到该特征时，零值出现，这意味着它很少出现，或者实际上从未出现。这些零值会导致日志图中出现问题。

以下代码说明了简化数据集上的问题。实际上，数据集包含更多点，因此曲线看起来更平滑，并且参数 的值也更多p。

library(ggplot2)

dat <- data.frame(x=rep(c(0, 1, 2, 3), 2),
                  y=c(1e0, 1e-1, 1e-4, 0,
                      1e-1, 1e-3, 0, 0),
                  p=c(rep('a', 4), rep('b', 4)))
qplot(data=dat, x=x, y=y, colour=p, log="y", geom=c("line", "point"))

鉴于上面的数据，我们希望有两条线，第一条在对数图上应该有三个有限点，第二条在对数图上应该只有两个有限点。

但是，正如您所看到的，这会产生一个非常具有误导性的情节。看起来蓝线和红线都收敛到 1e-4 和 1e-3 之间的值。原因是log(0)给出-Inf，ggplot 只是放在下轴上。

我的问题

用 ggplot2 在 R 中处理这个问题的最佳方法是什么？通过最好的我的意思是在效率方面，并且是ideomatic R（我是相当新的R）。

该图应表明这些曲线分别在 x=2（红色）或 x=1（蓝色）后下降到“非常小”。理想情况下，从最后一个有限点向下有一条垂直线。我的意思如下所示。

我的尝试

在这里，我将描述我想出的东西。但是，鉴于我对 R 相当陌生，我怀疑可能有更好的方法。

library(ggplot2)
library(scales)

dat <- data.frame(x=rep(c(0, 1, 2, 3), 2),
                  y=c(1e0, 1e-1, 1e-4, 0,
                      1e-1, 1e-3, 0, …

当将bit-wise应用于unsigned char时,我对C++的行为感到惊讶.

取二进制值01010101b,即0x55或85.在8位表示上不按比特应用应该产生10101010b,即0xAA,或170.

但是,我无法在C++中重现上述内容.以下简单断言失败.

assert(static_cast<unsigned char>(0xAAu) == ~static_cast<unsigned char>(0x55u));

我印刷的值0x55,0xAA和~0x55(如UCHAR)用下面的代码.并且它揭示了按位并不能达到我的预期.

std::cout << "--> 0x55: " << 0x55u << ", 0xAA: " << 0xAAu << ", ~0x55: "
     << static_cast<unsigned>(~static_cast<unsigned char>(0x55u)) << std::endl;

--> 0x55: 85, 0xAA: 170, ~0x55: 4294967210

打印的数字~0x55等于11111111111111111111111110101010b,而不是32位的位数0x55.因此,~即使我明确地将输入转换为a ,操作符也在32位整数上运行unsigned char.这是为什么？

我应用了另一个测试来查看~运算符返回的类型.结果int是unsigned char输入:

template <class …