小编Bry*_*ead的帖子

我正在考虑为我的一些项目采用browserify,但是如果他们想要使用(捆绑的)代码,他们希望确保其他人不必使用browserify.显而易见的方法是module.exports通过window.全局公开模块导出.但是,我宁愿不为那些正在require编写脚本的人污染全局命名空间.

是否可以检测脚本是否正在进行require？如果是,那么我可以这样做:

var mymodule = (function() { ... })();
if (isRequired()) {
  module.exports = mymodule;
} else {
  window.mymodule = mymodule;
}

请注意,无论如何,这都将预先捆绑,因此var mymodule不会暴露全局.此外,目前我正在使用揭示模块模式,但愿意切换到更适合browserify的东西.

什么是使模块既有require能力又有<script src=能力的最佳方法？在这两种情况下暴露全局是否最好？

在过去,当我需要在紧密循环中使用类似数组的索引查找时,我通常使用元组,因为它们通常看起来非常高效(接近仅使用n个变量).但是,我决定今天质疑这个假设,并得出一些令人惊讶的结果:

In [102]: l = range(1000)
In [103]: t = tuple(range(1000))
In [107]: timeit(lambda : l[500], number = 10000000)
Out[107]: 2.465047836303711
In [108]: timeit(lambda : t[500], number = 10000000)
Out[108]: 2.8896381855010986

元组查找似乎比列表查找长17%!重复实验给出了类似的结果.拆开每个,我发现它们都是:

In [101]: dis.dis(lambda : l[5])
  1           0 LOAD_GLOBAL              0 (l)
              3 LOAD_CONST               1 (5)
              6 BINARY_SUBSCR       
              7 RETURN_VALUE    

作为参考,典型的10,000,000个全局变量查找/返回需要2.2秒.另外,我在没有lambdas的情况下运行它,你知道,以防万一(注意数字= 100,000,000而不是10,000,000).

In [126]: timeit('t[500]', 't=range(1000)', number=100000000)
Out[126]: 6.972800970077515
In [127]: timeit('t[500]', 't=tuple(range(1000))', number=100000000)
Out[127]: 9.411366939544678

在这里,元组查找需要35%的时间.这里发生了什么？对于非常紧密的循环,这实际上似乎是一个显着的差异.可能是什么导致了这个？

注意,对于分解为变量(例如x,y = t),元组稍微快一点(在我的几次测试中减少约6%的时间),并且从固定数量的参数构造,元组疯狂得快(约83%的时间减少) ).不要将这些结果作为一般规则; 我刚刚完成了一些对大多数项目毫无意义的小型项目.

In [169]: print(sys.version)
2.7.1 (r271:86882M, Nov 30 2010, …

我有一个程序,我需要在尽可能短的时间内(以毫秒为单位)对类似List的对象进行100,000到1,000,000次随机读取读取,以实现类似细胞自动机的程序.我认为我正在使用的更新算法已经过优化(有效跟踪活动单元等).列表确实需要改变大小,但性能并不重要.所以我想知道使用Arrays而不是ArrayLists的性能是否足以在如此短的时间内处理那么多读取时产生差异.目前,我正在使用ArrayLists.

编辑:我忘了提到:我只是存储整数,所以另一个因素是使用Integer包装类(在ArrayLists的情况下)与int(在数组的情况下).有没有人知道使用ArrayList实际上是否需要3个指针查找(一个用于ArrayList,一个用于底层数组,一个用于Integer-> int),因为数组只需要1(数组地址+偏移到特定的INT)？HotSpot会优化额外的外观吗？这些额外的观察有多重要？

Edit2:另外,我忘了提到我还需要进行随机访问写入(写入,而不是插入).

在分析我们的代码库时,我发现了一些奇怪的东西.似乎用类型比较器(例如Comparator<MyClass>)排序总是先调用一个方法Comparator<MyClass>.compare(Object,Object)然后调用该方法Comparator<MyClass>.compare(MyClass,MyClass).此外,绝大部分时间都花在了Comparator<MyClass>.compare(Object,Object).为了进一步探索,我做了一个小测试程序:

public class Sandbox {
    public static void main(String argv[]) {
        for(int j=0; j<100; j++) {
            int n = 10000;
            SortMe[] sortMes = new SortMe[n];
            for (int i=0; i<n; i++) {
                sortMes[i] = new SortMe(Math.random());
            }
            Arrays.sort(sortMes, new SortMeComp());
            System.out.println(Arrays.toString(sortMes));
        }
        for(int j=0; j<100; j++) {
            int n = 10000;
            SortMe[] sortMes = new SortMe[n];
            for (int i=0; i<n; i++) {
                sortMes[i] = new SortMe(Math.random());
            }
            Arrays.sort(sortMes, new SortMeCompTypeless());
            System.out.println(Arrays.toString(sortMes));
        }
    } …

每当我将一个子目录拆分成一个分支时,git subtree split或者(因此？)当我向上游推送一个子树时,新分支/上游提交中的提交消息都有"-n"并且前面有一个换行符.

使用split进行演示最简单:

git init repo
cd repo
mkdir splitme
touch splitme/foo
git add splitme/
git commit -m 'Add foo'
git subtree split -P splitme -b splitme-only

从此,我得到:

$ git log master
commit 6d5164076bd88d1dab8963d91ec013372e58a444
Author: me
Date:   Fri Jul 26 12:22:27 2013 -0500

    Add foo

和

$ git log splitme-only 
commit 6ce8124a0b5e52d4bba198144d2f3f664d7b19e7
Author: me
Date:   Fri Jul 26 12:22:27 2013 -0500

    -n
    Add foo

如您所见,"splitme-only"分支在提交消息前面加上"-n".这尤其糟糕,因为github默认情况下会折叠除第一行之外的所有内容.因此,您无法在github上轻松浏览这些提交消息.

我已经尝试过使用--annotate可能更具可读性的东西,但这只是向"-n"行添加了一些内容.

行为是相同的subtree push.

有没有办法阻止添加"-n"行？我可以改掉这条线,但当我玩弄它时,它破坏了子树的合并.难道我做错了什么？

在OS X 10.8.4上使用git 1.8.3.4.

我想看看比使用for循环进行简单的数值运算要快多少.这是我发现的(使用标准timeit库):

In [54]: print(setup)
from operator import add, iadd
r = range(100)

In [55]: print(stmt1)    
c = 0
for i in r:
    c+=i        

In [56]: timeit(stmt1, setup)
Out[56]: 8.948904991149902
In [58]: print(stmt3)    
reduce(add, r)    

In [59]: timeit(stmt3, setup)
Out[59]: 13.316915035247803

再看一点:

In [68]: timeit("1+2", setup)
Out[68]: 0.04145693778991699

In [69]: timeit("add(1,2)", setup)
Out[69]: 0.22807812690734863

这里发生了什么？显然,reduce会比for循环更快,但函数调用似乎占主导地位.减少版本不应该几乎完全在C中运行吗？在for循环版本中使用iadd(c,i)使其在~24秒内运行.为什么使用operator.add比+慢得多？我的印象是+和operator.add运行相同的C代码(我检查以确保operator.add不只是在python中调用+或任何东西).

顺便说一句,只需在~2.3秒内使用总和运行.

In [70]: print(sys.version)
2.7.1 (r271:86882M, Nov 30 2010, 09:39:13) 
[GCC 4.0.1 (Apple Inc. build 5494)]

给定一个乌龟集nodes,我想找到所有具有两端的链接nodes.到目前为止我提出的最好的是:

link-set [ my-links with [ member? other-end nodes ] ] of nodes

这正是我想要的.但是,由于member?非线性集的线性时间运行,因此O(n*n*d)(d节点的最大程度和n节点数).我可以使用哈希集来改进它,但这需要滥用table扩展,找到第三方扩展,或者创建自己的扩展.我还可以创建一个who节点数量的排序列表,然后对它进行二进制搜索O(n * log(n) * d),但我希望得到一个更简单的答案.有任何想法吗？

我目前正在调查压缩类空间问题。我知道问题是什么，但在调查时，我注意到这一点jstat -gc ...，并jcmd ... GC.heap_info给出了不同数量的元空间和压缩类空间容量和使用情况：

\xe2\x96\xb6 jcmd 32152 GC.heap_info\n32152:\n PSYoungGen      total 153600K, used 129316K [0x00000000eab00000, 0x00000000f5b00000, 0x0000000100000000)\n  eden space 137728K, 91% used [0x00000000eab00000,0x00000000f26abf48,0x00000000f3180000)\n  from space 15872K, 16% used [0x00000000f4100000,0x00000000f439d428,0x00000000f5080000)\n  to   space 15872K, 0% used [0x00000000f3180000,0x00000000f3180000,0x00000000f4100000)\n ParOldGen       total 290816K, used 21446K [0x00000000c0000000, 0x00000000d1c00000, 0x00000000eab00000)\n  object space 290816K, 7% used [0x00000000c0000000,0x00000000c14f1ac0,0x00000000d1c00000)\n Metaspace       used 59690K, capacity 64980K, committed 65192K, reserved 1103872K\n  class space    used 9289K, capacity 10116K, committed 10152K, reserved 1048576K\n\n\xe2\x96\xb6 jstat -gc 32152\n S0C    S1C    S0U    S1U …

我一直在尝试sys.argv[1]使用glob.glob和递归地获取命令行参数()中与glob模式匹配的文件列表os.walk.问题是,bash(以及它看起来很多其他shell)会自动将glob模式扩展为文件名.

标准的unix程序(例如grep -R)如何执行此操作？我意识到他们不是在python中,但如果这种情况发生在shell级别,那应该不重要,对吧？有没有办法让脚本告诉shell不自动扩展glob模式？它似乎set -f会禁用通配,但我不知道如何尽早运行,可以这么说.

我见过使用Glob()在Python中递归查找文件？,但这并不包括实际从命令行参数获取glob模式.

谢谢!

编辑:

grep-like perl脚本ack接受perl正则表达式作为其参数之一.因此,ack .*打印出每个文件的每一行.但是.*应该扩展到目录中的所有隐藏文件.我试过阅读剧本,但我不知道perl; 它怎么能这样做？

(0 <= 0 <= 0) === false
(-1 < 0 <= 0 <= 0) === true

这里发生了什么？Javascript实际上是否存在不等式链接,在某些情况下是错误的？

我是 netlogo 的新手，我有一门课程，我完成了大部分课程，但我无法设置笔来与开关一起使用，我应该编写代码来做到这一点，这是我的代码

turtles-own [pen ]

to setup
  clear-all
  ask patches [ set pcolor sky ]
  setup-turtles

end

to setup-turtles
  create-turtles turtles-to-create
  [ set color lime setxy random-xcor random-ycor set size size-of-turtle]  
  set-default-shape turtles "circle"
end



to go 

 ask turtles

   [ 
     fd 1
   ]


end

to goforever

 ask turtles
  [
    fd 1
  ]


end

假设我们有两个品种,cats并且dogs.上go,我们要cats以meow和dogs到bark.ask导致给定代理集中的代理以随机顺序运行代码块,这很好.但是,如果我们这样做:

to go
  ask cats [ meow ]
  ask dogs [ bark ]
  tick
end

dogs总是追求cats.我们可以用条件解决这个问题:

to go
  ask turtles [
    if breed = cats [ meow ]
    if breed = dogs [ bark ]
  ]
  tick
end

但是这是总值(请注意,您可以替换turtles用(turtle-set cats dogs)与你不想混在品种更复杂的情况).更好的解决方案？

我已经有两点(x1,y1) (x2,y2)

我必须将其转换为以下形式的方程：Ax + By + C =0

我希望编写一个函数，将点作为输入并以列表的形式返回系数 A、B 和 C 作为输出。

A、B、C 的计算是否有直接的公式来计算这两点？