小编Rem*_*i.b的帖子

这是一个向量：

myVect = c(1,6,3,12,11,15,7,9,19,21)

如何获得通过重新排序可以获得的所有可能的不同向量的列表myVect？

一种可能的重新排序方式可以通过以下方式获得：

set.seed(12)
sample(myVect)

map() 和列表理解大致相同:

map(function, list1)
[function(i) for i in list1]

如果我们想要使用的函数是一种方法怎么办？

[i.function() for i in list1]
map(.function, list1) # error!
map(run_method(function), list1) # error!

我怎么能用这种操作map呢？

这似乎是一个常见问题，但我无法解决这个问题。

我有一些使用 makefile 编译的 .c 代码。目标是创建一个共享对象 (.so)，以便我可以从 R 运行 C 代码。

这是我的生成文件：

obs = R_wrapper.o G.o develop.o utilities.o
CFLAGS = -arch x86_64 -std=gnu99 -I/Library/Frameworks/R.framework/Resources/include -I/Library/Frameworks/R.framework/Resources/include/x86_64 -DNDEBUG  -I/usr/local/include    -fPIC  -g -O3  -c
LFLAGS = -arch x86_64 -std=gnu99 -dynamiclib -Wl,-headerpad_max_install_names -undefined dynamic_lookup -single_module -multiply_defined suppress -L/usr/local/lib -O3 -lgsl -lm -lgslcblas

R_wrapper : $(obs)
    $gcc $(LFLAGS) $(obs) -o R_wrapper.so

R_wrapper.o : R_wrapper.c constants.h develop.h G.h
    $gcc $(CFLAGS) R_wrapper.c

G.o : G.c G.h constants.h utilities.h develop.h 
    $gcc $(CFLAGS) G.c develop.c

develop.o : develop.c develop.h …

我的目标是在一个集群上并行运行10,000个左右的Julia编码模拟(每个模拟独立于所有其他模拟).每个模拟都有一个数字输出(以及有关哪个模拟产生此数字的3列信息).因此,强制每个模拟在单独的文件上打印对我来说听起来有点愚蠢.

我可以安全地要求所有这些模拟在同一个文件上写入,或者如果两个模拟恰好在同一时间写入文件,这可能会导致错误吗？什么是最好的解决方案？

我想使用的功能bitrand(),这是在compat.jl包中.这是我做的:

julia> Pkg.add("compat")
INFO: Nothing to be done

julia> using Compat

julia> bitrand()
ERROR: bitrand not defined

julia> Pkg.update()
INFO: Updating METADATA...
INFO: Computing changes...
INFO: No packages to install, update or remove

julia> using Compat

julia> bitrand()
ERROR: bitrand not defined

julia> Compat.bitrand()
ERROR: bitrand not defined

有关信息,我正在使用Julia-0.3.2.谢谢!

编辑

julia> Pkg.status()
3 required packages:
 - Compat                        0.2.10
 - Distributions                 0.6.3
 - StatsBase                     0.6.10
3 additional packages:
 - ArrayViews                    0.4.8
 - JSON                          0.4.0
 - …

expand.grid是一个非常方便的功能,R用于计算几个列表的所有可能组合.下面是它的工作原理:

> x = c(1,2,3)
> y = c("a","b")
> z = c(10,12)
> d = expand.grid(x,y,z)
> d
   Var1 Var2 Var3
1     1    a   10
2     2    a   10
3     3    a   10
4     1    b   10
5     2    b   10
6     3    b   10
7     1    a   12
8     2    a   12
9     3    a   12
10    1    b   12
11    2    b   12
12    3    b   12

如何在Julia中重现此功能？

考虑以下因素

x = factor(c("1|1","1|0","1|1","1|1","0|0","1|1","0|1"))

我想计算这个因素中字符"0"的出现次数.到目前为止我找到的唯一解决方案是

sum(grepl("0",strsplit(paste(sapply(x, as.character), collapse=""), split="")[[1]]))
# [1] 4

对于这样一个简单的过程,这个解决方案似乎很复 有没有"更好"的选择？(由于该过程将在2000个元素长的因素上重复约100,000次,我可能最终也会关注性能.)

介绍

我有一个C++进程调用MyProcess我称之为nbLines时间,其中nbLines是一个大文件的行数,InputDataFile.txt在其中找到输入数据.例如电话

./MyProcess InputDataFile.txt 142

通知MyProcess输入数据将142在InputDataFile.txt文件的行中找到.

问题

问题是,InputDataFile.txt如此大(~150 GB),搜索正确行的时间不可忽略.灵感来自这篇文章,这是我的(可能不是最优的)代码

int line = 142;
int N = line - 1;
std::ifstream inputDataFile(filename.c_str());
std::string inputData;
for(int i = 0; i < N; ++i)
    std::getline(inputDataFile, inputData);

std::getline(inputDataFile,inputData);

目标

我的目标是inputData更快地进行搜索MyProcess.

可能解决方案

将每行的第一个字符的索引与行号相匹配会很方便bash.这样,而不是给142到MyProcess,我可以直接给感兴趣的第一个字符的索引.MyProcess然后可以直接跳转到此位置,而无需搜索和计算'\n'字符.然后它将读取数据,直到遇到'\n'字符.这样的事情可行吗？怎么能实现呢？

当然,我欢迎任何其他解决方案,这将减少导入这些输入数据的总计算时间.

我有以下类型的列表:

class Ind(object):
    def __init__(self,ID,mate):
        self.ID=ID
        self.mate=mate

population=[Ind(8,None), Ind(1,2), Ind(20,3), Ind(2,1), Ind(12,None), Ind(3,20), Ind(10,11), Ind(11,10)]

您可以将此列表population视为所有人都拥有的个人群体ID.他们中的一些人mate(一个人出现在同一人群或相同的名单中).mate价值实际上ID是配偶的价值!因此,如果存在的一个实例Ind哪些属性ID等于12和mate等于34,那么就必须在其列表中的个体ID等于34,其mate等于12个人没有一个mate具有None在mate属性.是否有意义？

我想对这个列表进行排序,以便第一个人与最后一个匹配,第二个人与倒数第二个人匹配等等......属性mate等于的个体None应该位于列表的中间.

有许多可能的输出符合我的要求.以下是上述列表中这些输出的一个示例:

population=[Ind(1,2), Ind(20,3), Ind(10,11), Ind(8,None), Ind(12,None), Ind(11,10), Ind(3,20), Ind(2,1)]

设R中的序列为TRUE和FALSE

v = c(F,F,F,F,F,F,T,F,T,T,F,T,T,T,T,T,F,T,F,T,T,F,F,F,T,F,F,F,F,F)

我想获得第一个和最后一个TRUE的位置.实现这一目标的一种方法是

range(which(v)) # 7 25

但是这个解决方案相对较慢,因为它必须检查向量的每个元素以获得每个TRUE的位置然后遍历所有位置,if在每个位置评估两个语句(我认为)以获得最大值和最小值.从头开始搜索第一个TRUE,从头开始搜索第一个TRUE并返回那些位置将更具战略意义.

有更快的替代方案range(which(..))吗？