有人可以向我解释功能性镜片吗？谷歌这是一个令人惊讶的困难主题,我没有取得任何进展.我所知道的是,它们提供了类似于OO的获取/设置功能.
我是clojure的初学者,昨天才开始.
我已经收集到了一个创建独立应用程序的简单方法是使用leiningen lein new foo.
我试图用leiningen创建一个hello world测试项目.我添加了:main和:aot指令到project.clj,添加:gen-class到core.clj文件并尝试过lein run,但是我发现没有找到类定义的错误.
Exception in thread "main" java.lang.NoClassDefFoundError:
Caused by: java.lang.ClassNotFoundException:
at java.net.URLClassLoader$1.run(URLClassLoader.java:217)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:205)
at java.lang.ClassLoader.loadClass(ClassLoader.java:321)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:294)
at java.lang.ClassLoader.loadClass(ClassLoader.java:266)
core.clj文件
(ns test.core
(:gen-class))
(defn -main [& args] (println "Hello main"))
和project.clj文件
(defproject test "1.0.0-SNAPSHOT"
:description "FIXME: write description"
:main test.core
:aot [test.core]
:dependencies [[org.clojure/clojure "1.2.1"]])
编辑:经过进一步测试,似乎将项目复制到我的桌面工作原样,我认为我的笔记本电脑上的环境有点笨拙,但我不知道如何.
桌面环境是来自存储库和来自AUR的leiningen的clojure.在笔记本电脑上,clojure来自clojure.org,leining来自github.
我正在尝试学习Haskell,在关于Markov文本链的reddit文章之后,我决定首先在Python中实现Markov文本生成,现在在Haskell中实现.但是我注意到我的python实现比Haskell版本快,甚至Haskell编译为本机代码.我想知道我应该做些什么来使Haskell代码运行得更快,而且现在我认为它因为使用Data.Map而不是hashmaps而慢得多,但我不确定
我也会发布Python代码和Haskell.使用相同的数据,Python需要大约3秒钟,Haskell接近16秒.
不言而喻,我会接受任何建设性的批评:).
import random
import re
import cPickle
class Markov:
def __init__(self, filenames):
self.filenames = filenames
self.cache = self.train(self.readfiles())
picklefd = open("dump", "w")
cPickle.dump(self.cache, picklefd)
picklefd.close()
def train(self, text):
splitted = re.findall(r"(\w+|[.!?',])", text)
print "Total of %d splitted words" % (len(splitted))
cache = {}
for i in xrange(len(splitted)-2):
pair = (splitted[i], splitted[i+1])
followup = splitted[i+2]
if pair in cache:
if followup not in cache[pair]:
cache[pair][followup] = 1
else:
cache[pair][followup] += 1
else:
cache[pair] = {followup: 1}
return cache
def …我试图围绕并行策略.我想我理解每个组合器的作用,但每次我尝试使用超过1个核心时,程序都会大大减慢.
例如前一段时间我试图从~700个文档中计算直方图(以及来自它们的独特单词).我认为使用文件级粒度是可以的.随着-N4我获得1.70的工作平衡.然而,-N1它的运行时间比它的运行时间少一半-N4.我不确定这个问题究竟是什么,但我想知道如何决定何时/何时/如何并行化并获得一些理解.如何将其并行化,以便速度随核心而不是降低而增加？
import Data.Map (Map)
import qualified Data.Map as M
import System.Directory
import Control.Applicative
import Data.Vector (Vector)
import qualified Data.Vector as V
import qualified Data.Text as T
import qualified Data.Text.IO as TI
import Data.Text (Text)
import System.FilePath ((</>))
import Control.Parallel.Strategies
import qualified Data.Set as S
import Data.Set (Set)
import GHC.Conc (pseq, numCapabilities)
import Data.List (foldl')
mapReduce stratm m stratr r xs = let
mapped = parMap stratm m xs
reduced = r mapped `using` …我打算测试天真的贝叶斯分类.其中一部分是建立训练数据的直方图.问题是,我使用了大量的培训数据,几年前就已经有了haskell-cafe邮件列表,文件夹中有超过20k的文件.
使用python创建直方图需要两分钟的时间,而使用haskell需要8分多钟.我正在使用Data.Map(insertWith'),枚举器和文本.我还能做些什么来加速该计划？
哈斯克尔:
import qualified Data.Text as T
import qualified Data.Text.IO as TI
import System.Directory
import Control.Applicative
import Control.Monad (filterM, foldM)
import System.FilePath.Posix ((</>))
import qualified Data.Map as M
import Data.Map (Map)
import Data.List (foldl')
import Control.Exception.Base (bracket)
import System.IO (Handle, openFile, hClose, hSetEncoding, IOMode(ReadMode), latin1)
import qualified Data.Enumerator as E
import Data.Enumerator (($$), (>==>), (<==<), (==<<), (>>==), ($=), (=$))
import qualified Data.Enumerator.List as EL
import qualified Data.Enumerator.Text as ET
withFile' :: (Handle -> IO c) -> FilePath -> IO …我正在尝试使用Haskells Data.Heap模块,但我甚至无法使用整数.我能够使用的唯一堆是"空",它不带任何参数.
稍后我会弄清楚如何满足我的需求,但是现在如果我能用数字测试它,我会很高兴.
我有以下代码段:
import qualified Data.Vector as V
import qualified Data.ByteString.Lazy as BL
import System.Environment
import Data.Word
import qualified Data.List.Stream as S
histogram :: [Word8] -> V.Vector Int
histogram c = V.accum (+) (V.replicate 256 0) $ S.zip (map fromIntegral c) (S.repeat 1)
mkHistogram file = do
hist <- (histogram . BL.unpack) `fmap` BL.readFile file
print hist
我这样看:在打印之前什么也没做.通过首先解压缩打印thunk时,然后一次从一个Word8映射.这些word8中的每一个都用1压缩,一次一个值.这个元组然后由累加器函数获取,该函数一次更新数组,一个元组/ Word8.然后我们移动到下一个thunk并重复直到不再有内容.
这将允许在常量内存中创建直方图,但是这不会发生,而是它会因堆栈溢出而崩溃.如果我尝试对其进行分析,我会看到它运行到最后,但是记忆很多(对于2.5 Mb文件,需要300-500 Mb).直接获得记忆直到它可以被释放,形成"漂亮"的三角形图.
我的推理在哪里出错了,我应该采取什么步骤让它在恒定的记忆中运行？
对不起,我刚刚开始研究反应性香蕉和玻璃钢.
反应香蕉的作者根据我的建议制作了这个例子,他创造了一个可以增加和减少的计数器.他使用累积函数来累积事件.我想我能够在某种程度上了解事件类型,并能够用它测试很多东西,但后来我记得还有行为.我调查了一下,但似乎这种行为意味着在类似的情况下使用; 修改现有变量,就像accumE对事件一样.
行为意味着什么,它的用例是什么？
如何使PHPUnit尊重__autoload函数？
例如,我有这三个文件:
loader.php
function __autoload($name)
{
echo "foo\n";
require_once("$name.php");
}
test.php的
require_once("loader.php");
class FooTest extends PHPUnit_Framework_TestCase
{
function testFoo()
{
new Foo();
}
}
foo.php
require_once("loader.php");
new Foo();
正如预期的php foo.php错误,说文件"Foo.php"不存在.testFoo()然而,该函数通过说没有这样的类来错误Foo,并且从不回声"foo \n"行.
我有一些情况需要递归列出文件,但我的实现速度很慢.我有一个包含92784个文件的目录结构.find在不到0.5秒的时间内列出文件,但我的Haskell实现速度要慢得多.
我的第一个实现需要花费9秒多的时间来完成,下一个版本需要5秒多一点时间,我现在已经下降到不到两秒钟了.
listFilesR :: FilePath -> IO [FilePath]
listFilesR path = let
isDODD "." = False
isDODD ".." = False
isDODD _ = True
in do
allfiles <- getDirectoryContents path
dirs <- forM allfiles $ \d ->
if isDODD d then
do let p = path </> d
isDir <- doesDirectoryExist p
if isDir then listFilesR p else return [d]
else return []
return $ concat dirs
该测试需要大约100兆字节的内存(+ RTS -s),并且该程序在GC中花费大约40%.
我正在考虑在WriterT monad中进行列表,将Sequence作为monoid来阻止concats和list创建.这有帮助吗？我还该怎么办？
编辑:我已经编辑了使用readDirStream的函数,它有助于保持内存不变.仍然有一些分配发生,但现在生产率> 95%,它运行不到一秒钟.
这是当前版本:
list path …