小编ham*_*mar的帖子

我在集合上有等价关系 .如何构建等价类？它就是这样,但在所有元素之间,不仅仅是邻居.RAAgroupBy

例如,equal是等价关系(它是自反,对称和传递二元关系):

type Sometuple = (Int, Int, Int)

equal :: Sometuple -> Sometuple -> Bool
equal (_, x, _) (_, y, _) = x == y

它实际上是连接2个Sometuple元素的谓词.

?> equal (1,2,3) (1,2,2)
True

那么,我如何[Sometuple]基于equal谓词构建所有等价类？像这样的东西:

equivalenceClasses :: (Sometuple -> Sometuple -> Bool) -> [Sometuple] -> [[Sometuple]]
?> equivalenceClasses equal [(1,2,3), (2,1,4), (0,3,2), (9,2,1), (5,3,1), (1,3,1)]
[[(1,2,3),(9,2,1)],[(2,1,4)],[(0,3,2),(5,3,1),(1,3,2)]]

我正试图用matplotlib填充曲线下的区域.下面的脚本运行正常.

import matplotlib.pyplot as plt
from math import sqrt
x = range(100)
y = [sqrt(i) for i in x]
plt.plot(x,y,color='k',lw=2)
plt.fill_between(x,y,0,color='0.8')
plt.show()

但是,如果我将y标度设置为对数(见下文).它有时会填满曲线上方的区域!谁能帮我？我想填充曲线和y = 0之间的区域.

x = range(100)
y = [sqrt(i) for i in x]
plt.plot(x,y,color='k',lw=2)
plt.fill_between(x,y,0,color='0.8')
plt.yscale('log')
plt.show()

提前致谢!

我的程序的一部分要求我能够随机洗牌列表元素.我需要一个函数,当我给它一个列表时,它将伪随机地重新排列列表中的元素.
排列方式的更改 必须在每次调用时都显示相同的列表.

我的实现似乎工作得很好,但我觉得它相当长,并且正在增加我的代码库,而且,我觉得它不是这样做的最佳解决方案.所以我需要一个更短的实现.这是我的实现:

-module(shuffle).
-export([list/1]).
-define(RAND(X),random:uniform(X)).
-define(TUPLE(Y,Z,E),erlang:make_tuple(Y,Z,E)).

list(L)->    
    Len = length(L),
    Nums = lists:seq(1,Len),    
    tuple_to_list(?TUPLE(Len,[],shuffle(Nums,L,[]))).

shuffle([],_,Buffer)-> Buffer;
shuffle(Nums,[Head|Items],Buffer)->
    {Pos,NewNums} = pick_position(Nums),    
    shuffle(NewNums,Items,[{Pos,Head}|Buffer]).

pick_position([N])-> {N,[]};
pick_position(Nos)->
    T = lists:max(Nos), 
    pick(Nos,T).

pick(From,Max)->
    random:seed(begin
                    (case random:seed(now()) of 
                        undefined -> 
                            NN = element(3,now()),
                            {?RAND(NN),?RAND(NN),?RAND(NN)};
                        Any -> Any
                    end)
                end
                ),
    T2 = random:uniform(Max),
    case lists:member(T2,From) of
        false -> pick(From,Max);
        true -> {T2,From -- [T2]}
    end.

在shell中运行它:

F:\> erl
Eshell V5.8.4  (abort with ^G)
1> c(shuffle).
{ok,shuffle}
2> shuffle:list([a,b,c,d,e]).
[c,b,a,e,d]
3> shuffle:list([a,b,c,d,e]).
[e,c,b,d,a] …

我正在尝试优化一些代码,使用标准来尝试比较,例如,将INLINEpragma 添加到函数的效果.但我发现重新编译/运行之间的结果并不一致.

我需要知道如何使结果在运行中保持一致,以便我可以比较它们,或者如何评估基准是否可靠,即(我猜)如何解释方差的细节,"成本时钟呼叫"等

我的具体案例详情

这与我上面的主要问题是正交的,但是在我的特定情况下,有几件事可能导致不一致:

1. 我正在尝试使用基准测试IO操作,whnfIO因为whnf在此示例中使用的方法不起作用.

2. 我的代码使用并发

3. 我有很多标签和垃圾打开

示例输出

这两个都来自相同的代码,以完全相同的方式编译.我直接在下面进行了第一次运行,做了一个更改并做了另一个基准测试,然后还原并再次运行第一个代码,编译:

ghc --make -fforce-recomp -threaded -O2 Benchmark.hs

第一次运行:

estimating clock resolution...                                      
mean is 16.97297 us (40001 iterations)                              
found 6222 outliers among 39999 samples (15.6%)                     
  6055 (15.1%) high severe                                          
estimating cost of a clock call...                                  
mean is 1.838749 us (49 iterations)                                 
found 8 outliers among 49 samples (16.3%)                           
  3 (6.1%) high mild                                                
  5 (10.2%) high severe                                             

benchmarking actors/insert 1000, query 1000                         
collecting …

我正在做一些练习,我必须添加一个函数的类型并解释它的作用.我坚持这个:

phy = uncurry ($)

据GHCi说,这种类型phy :: (a -> b, a) -> b.我的haskell知识是基本的,所以我真的不知道它的作用.

关于什么时候你需要_一个方法来使用它作为一个函数,我对规则有点不稳定.例如,为什么以下的Foo's和Nil's 之间存在差异::？

def square(n: Int) = n * n  
object Foo { def ::(f: Int => Int) = f(42) }

// ...

scala> Foo.::(square)
res2: Int = 1764

scala> Nil.::(square) 
<console>:6: error: missing arguments for method square in object $iw;
follow this method with `_' if you want to treat it as a partially applied function
   Nil.::(square)
          ^
scala> Nil.::(square _) 
res3: List[(Int) => Int] = List(<function1>)

我想从.xls文件中获取数据,而无需手动打开Excel.一种可能性是使用COM自动化.

有com-1.2.3和hdirect包,但我找不到如何使用这些包与Excel的任何示例.

有人有解决方案吗？

我最近一直在重写许多OCaml标准库函数,以便进行尾递归.鉴于这需要直接进行CPS转换,我仍然不知道为什么默认版本不是这样编写的.

例如,在标准库中,map定义为:

let rec map f = function
    []   -> []
  | a::l -> let r = f a in r :: map f l

我把它重写为:

let map f l =
  let rec aux l k = match l with
      []   -> k []
    | a::l -> aux l (fun rest -> k (f a :: rest))
  in aux l (fun x -> x)

我一直在努力弄清楚TED Talk主页是如何工作的.撇开所有的动画垃圾,我发现盒子组织的方式真的很吸引人.

乍一看,它看起来像jQuery砌体插件,很快就会发现它倾向于创建几个直角三角形形状,但没有固定数量的列或行,并且产生的最终形状总是完全坚固(没有空心部件) ).

我最初的假设是,盒子(它们的大小是由网站上的某个因素预先确定的)是随机排序的,然后使用一些简单的规则顺序添加到网格中,但是我无法确定这些规则可能是什么,或者它们如何可以防止最终形状的任何凹陷.

有谁知道这是如何工作的？

我是Haskell的新手,我想知道是否有办法在Haskell中的函数中输出'debug'行？IE我想调试输入函数的值

我目前的代码是

import Prelude

foo(a,b,c) 
    print("input a : " ++ a)
    = a + b + c

main = print(foo(1, 2, 3))

我有编程经验,但这是我第一次接近函数式编程,所以任何帮助都将受到赞赏.