小编Mr *_*der的帖子

我需要将对象转换为byte []以存储在Tokyo Cabinet键值存储中.当从键值存储区读取时,我还需要将byte []取消对象.

那里有什么包可以帮我完成这项任务吗？或者是我自己实施的最佳解决方案？

当JVM终止与发生什么System.exit(0)或^C或那样的东西吗？我读过"过程刚被吹走"和"每一个线程都被停止"之类的东西,但我想知道究竟发生了什么.我已经知道shutdownHook有些东西仍然会被执行,但是在调用shutdownHooks之前会发生什么,并且在所有这些线程完成之后会发生什么？

我想shutdownHook正确地实现这样一个并且这样做,我需要对可能仍然执行什么和不执行什么做出正确的假设.

更新:

一些代码:

class SomeObject {

    private boolean stopped;

    SomeObject() {
        stopped = false;
        Thread hook = new Thread() {

            @Override
            public void run() {
                stopped = true;
            }

        };
        hook.setPriority(Thread.MAX_PRIORITY);
        Runtime.getRuntime().addShutdownHook(hook);
    }

    boolean map(Iterator<Object> it) {
        while(it.hasNext() && !stopped) {
            writeToOtherObject(it.next());
            it.remove();
        }
        //have calculations finished?
        return !it.hasNext();
    }
}

该map函数计算在其他对象中收集的结果.在所有内容都被分解之前,该对象应该存储在某个文件中(也可以是普通优先级shutdownHook).请问shutdownHook这里有意义吗？据我所知,所有线程首先被销毁,然后shutdownHook才运行(同时,但我假设首先运行高优先级线程......)然后最终确定对象.这使得上面的代码相当无用,因为这样做的目的是shutdownHook确保在关闭已经开始时没有启动新的循环.我的理解是正确和完整的吗？

我试图实施ZCA美白并找到一些文章来做,但它们有点令人困惑..有人可以为我照亮吗？

任何提示或帮助表示赞赏!

这是我读过的文章:

http://courses.media.mit.edu/2010fall/mas622j/whiten.pdf http://bbabenko.tumblr.com/post/86756017649/learning-low-level-vision-feautres-in-10-lines-of

我尝试了几件事,但大多数我都不明白,我被锁定了一步.现在我以此为基础重新开始:

dtype = np.float32
data = np.loadtxt("../inputData/train.csv", dtype=dtype, delimiter=',', skiprows=1)
img = ((data[1,1:]).reshape((28,28)).astype('uint8')*255)

我是Smalltalk的新手,我一整天都在寻找如何编写GUI.我已经找到了大量关于如何使用Morphs和Halos是什么的信息,但我似乎无法找到我需要的东西(它只是一个带有a条目的表Dictionary).

接下来Morphs,我还发现了一些关于smalltalk如何引入MVC原理的东西.我甚至找到了ST-80 Views包含我需要的所有内容的类别,但我又不确定如何正确使用它,不知怎的,我似乎找不到合适的来源让我开始.

因此,我的问题:从哪里开始构建一个简单的GUI？我应该如何从Morph可用的十亿中选择,如何将它们组合成一个可靠的界面？MVC只应在它变得更复杂时使用,还是对简单的GUI有用？关于在哪些情况下使用什么,是否有任何一般概述？

为了说明我想做什么,我添加了一些伪代码,我将如何记住它:

d := Dictionary new.
"add data to the dictionary..."

view := DictionaryView new.
view addDictionary: d.

button := SimpleButtonMorph new.
"e.g. change label to sum of values"
button target: [button label: d sum.].

window := SystemWindow labelled: test.
window addMorph: view.
window addMorph: button.

任何帮助我开始这一点的人都非常感谢.

更新:

我最近在一本书中找到了一章,通过一些很好的解释和示例代码帮助我更好地理解形态,对于想要了解更多的人,也有一整套免费书籍.来自吱吱声维基的教程也很有用.特别是那个Pluggable Morphs让我更好地理解这个概念.请注意,本教程隐藏在未查看的教程列表中(可能是因为项目中存在一些可以下载的错误).

一些信息

我正在研究一个适用于基本集和反链的程序.

Antichains是集合的powerset的子集,因此该子集中没有两个元素(集合)是该子集中的另一个元素(集合)的子集.例如,{{1},{1,2}}不是一个反链,因为{1}⊆{1,2}.

关于抗原A和B的一些最重要的操作可以定义为

1. a.join(b)= sup(a∪b)
2. a.meet(b)= sup({X∩Y|X∈a和Y∈b})

sup是antihain的上限,意味着最小的antichain比给定的set更大.

到目前为止的代表

基本集由a long,bitarray-like组成.这意味着该组的每个元素在比特阵列中由1表示.例如,集合{1,2,3}由7(比特阵列111)表示,集合{1,2,4}由11(比特阵列1011)表示,依此类推.

现在我想提升这种表示以类似的方式表示反链.这意味着我可以在一个bitarray中将antichain {{1},{2,3}}表示为1000010,因为存储集合{1}的长整数是1而对于{2,3}它是6(指数是比特币中的1.
除非我找到更好的替代方案,否则我使用BitSet -class来处理这个bitarray,希望节省一些时间来处理任何问题Collection<T>.

我已经设法定义和优化之前陈述的大多数基本操作,但它们在较旧的实现中进行了优化,只需使用a TreeSet,因此未针对使用bitarray进行优化.

我的问题

1. 我现在的问题是BitSet是否是最佳表示,知道每次添加到起始集的元素时这些比特表示的大小加倍.我也想过,BigInteger例如,具有可比性的优势(我也需要).
2. 此外,我想知道是否有人已经做了一些可能的事情,并且知道如何使用bitarray属性实现连接并有效地满足.

提前致谢.

编辑:

我的加入和见面的代码目前看起来像这样:

public AntiChain join(AntiChain ac) {
    AntiChain res = new AntiChain(this);
    for(int i = ac.bitset.nextSetBit(0); i >= 0; i = ac.bitset.nextSetBit(i+1)) {
        res.addAndMakeAntiChain(new BasicSet(i));
    }
    return res;
}

public AntiChain meet(AntiChain ac) {
        AntiChain res = AntiChain.emptyAntiChain(this.getUniverse());
        for(int i = bitset.nextSetBit(0); i >= 0; i …

我正在尝试计算一些大数字.为了加快计算速度,我想利用多线程.每个线程都应该计算一个数字,最后计算一个总和.

我曾经看过一些与a SumThread和a Collector有关的东西,如下所示:

public BigInteger compute(int p) {
    Collector c = new Collector(p);

    for(T element : Collection<T> bigCollection) {
        new SumThread(c) {

            @Override
            protected void doTheJob() {
                long big = someVeryComplexCalculation(element, ...); //n!
                receive(BigInteger.valueOf(big));
            }

        }
    }

    if(collector.isReady())
        return collector.getResult();

    return null;
}

public class Collector {

    private int numberOfProcesses;
    private int numberOfAllowedProcesses;
    private BigInteger result;

    public Collector(int n) {
        numberOfAllowedProcesses = n;
        numberOfProcesses = 0;
        result = BigInteger.ZERO;
    }

    synchronized public void enter() throws InterruptedException { …

我想编写一些void* share(void*, int)应该设置共享内存以在指针处共享数据的函数.

我的第一次尝试看起来像(没有支票等):

void* share(void *toBeShared, int size) {
    int fd = shm_open(SHM_NAME, O_CREAT | O_RDWR | O_EXCL, S_IRUSR | S_IWUSR);
    ftruncate(fd, size);
    return mmap(toBeShared, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
}

但这似乎并不像我想的那样有用.第二次尝试是这样的:

void* share(void *toBeShared, int size) {
    void *mem = NULL;
    int fd = shm_open(SHM_NAME, O_CREAT | O_RDWR | O_EXCL, S_IRUSR | S_IWUSR);
    ftruncate(fd, size);
    mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)
    memcpy(mem, toBeShared, size);
    return mem;
}

这确实有效,但我需要复制整个数据,我想避免.

因此我的问题是:有没有办法分享已经分配的内存(如果可能的话,无需复制太多),如果可以的话,怎么办呢？

提前致谢. …

这个问题来自另一个问题的答案，其中建议使用 map 和 reduce 同时计算总和。

在那个问题中有一个complexCalculation(e)，但现在我想知道如何通过将计算分成两部分来进一步并行化，以便complexCalculation(e)= part1(e)* part2(e)。我想知道是否可以同时计算集合上的 part1 和 part2（map()再次使用），然后压缩两个结果流，以便两个流的第 i 个元素与函数 * 组合，以便结果流等于流可以通过complexCalculation(e)在该集合上进行映射来获得。在代码中，这看起来像：

Stream map1 = bigCollection.parallelStream().map(e -> part1(e));
Stream map2 = bigCollection.parallelStream().map(e -> part2(e));
// preferably map1 and map2 are computed concurrently...
Stream result = map1.zip(map2, (e1, e2) -> e1 * e2);

result.equals(bigCollection.map(e -> complexCalculation(e))); //should be true

所以我的问题是：是否存在一些类似于zip我在这里尝试描述的功能的功能？

我正在用以下代码绘制一些数据的均值和方差的变化

import matplotlib.pyplot as pyplot
import numpy

vis_mv(data, ax = None):
    if ax is None: ax = pyplot.gca()
    cmap = pyplot.get_cmap()
    colors = cmap(numpy.linspace(0, 1, len(data)))

    xs = numpy.arange(len(data)) + 1
    means = numpy.array([ numpy.mean(x) for x in data ])
    varis = numpy.array([ numpy.var(x) for x in data ])
    vlim = max(1, numpy.amax(varis))

    # variance
    ax.imshow([[0.,1.],[0.,1.]],
        cmap = cmap, interpolation = 'bicubic',
        extent = (1, len(data), -vlim, vlim), aspect = 'auto'
    )
    ax.fill_between(xs, -vlim, -varis, color = 'white')
    ax.fill_between(xs, varis, …