小编Tra*_*ers的帖子

我正在寻找Java中的内存流实现.应该在.NET内存流(*)实现之后大致建模实现.

基本上我想有一个MemoryStream必须工厂方法的类:

 class MemoryStream {
     MemoryInput createInput();
     MemoryOutput createOutput();
 }

 class MemoryInput extends InputStream {
    long position();
    void seek(long pos);
 }

 class MemoryOutput extends OutputStream {
    long position();
    void seek(long pos);
 }

因此,一旦我有一个类的实例,MemoryStream我应该能够同时创建输入和输出流,这也应该允许在任何方向上定位.内存流不必是圆形的,它应该适用于小尺寸并自动生长.内存流只需要限制在一个进程中.

任何开箱即用的代码？

(*).NET内存流
http://msdn.microsoft.com/en-us/library/system.io.memorystream.aspx

节日快乐的家伙.

我一直在研究C++预处理器序列(使用boost)来帮助我生成基于​​运算符的仿函数.到目前为止,我已完成了源代码,但是我无法找到最合适的关键字来识别这些仿函数.

更具体地说,在查看C++ 0x草案后,我找不到以下运算符的最合适(唯一)名称:

• - >和.这两个都在草案中被调用:类成员运算符
• - >*和.*都被调用:指向成员运算符的指针

你觉得你能帮助我更好地命名吗？

我用过的参考文献是:

1. C++ 0x草案(可以在线查找)
2. 在"升压/原/ operators.hpp"报头,其中包括最过度加载操作符.
3. 在C和C++运算符从维基百科也提供了以下名称
   • .结构参考
   • - >结构解除引用
   • - >*和.*成员指针

这是我到目前为止创建的列表.任何其他建议将不胜感激.

 Symbol        Keyword           Description
++      , post_increment      , post increment
--      , post_decrement      , post decrement
++      , pre_increment       , pre increment
--      , pre_decrement       , pre decrement
+       , unary_plus          , additive promotion
-       , unary_minus         , additive inversion
!       , negate              , logical negation
~       , complement          , complement
*       , indirect            , indirection …

我最近开始学习Prolog,我无法解决如何组合三个列表的问题.

我能够组合2个列表:

%element
element(X,[X|_]).
element(X,[_|Y]):-
               element(X,Y).

%union

union([],M,M).
union([X|Y],L,S) :- element(X,L),union(Y,L,S).
union([X|Y],L,[X|S]) :- (not(element(X,L))),union(Y,L,S).

有人可以帮我吗？

我在某处读到你可以将模块视为Prolog中的对象.我试图解决这个问题,如果这是一个很好的编码方式.

如果我有两个文件,一个定义一个类狗,然后另一个使用这个类来生成两个狗对象.

:- module(dog,
      [ create_dog/4,bark/1 ]).

create_dog(Name,Age,Type,Dog):-
   Dog = dog(name(Name),age(Age),type(Type)).

bark(Dog):-
   Dog = dog(name(_Name),age(_Age),type(Type)),
   Type = bassethound,
   woof.
bark(Dog):-
   Dog = dog(name(_Name),age(_Age),type(Type)),
   Type \= bassethound,
   ruff.

woof:-format("woof~n").

ruff:-format("ruff~n").

第二个档案

use_module(library(dog)).

run:-
   dog:create_dog('fred',5,bassethound,Dog),
   forall(between(1,5,_X),
       dog:bark(Dog)
      ),
   dog:create_dog('fido',6,bloodhound,Dog2),
   dog:bark(Dog2).

这使得一只狗对象Dog是一只巴塞特猎犬并且让它吠5次,然后我再制作另一只狗对象Dog2,它是一只猎犬并使它也吠叫.我知道在oop中你有对象有行为和状态.所以我现在根据自己的状态有两个具有不同行为的对象,但目前我将对象的状态存储在Dog变量中,主程序中的代码可以看到它们.有没有办法隐藏对象的状态,即拥有私有变量？例如,我可能希望有一种方法可以为每个狗对象存储状态has_barked,如果它在程序中较早出现,则为true,否则为false,然后bark/1根据此更改行为.

您还将如何处理继承和覆盖方法等？任何指向读数的指针都欢迎.谢谢.

alt-rt.jar和rt.jar中的HashMap有什么区别.我想我的一个应用程序中看到了相当快的速度,解释是什么？

最好的祝福

PS:我在JDK 1.6.0_25 64位中发现了两个不同的*.jar.最终加速也与alt-string.jar有关.此alt最终可能与命令行选项相关:

http://thevirtualmachinist.blogspot.com/2010/09/xxusecompressedstrings.html

但我对理解alt-rt.jar更感兴趣,我从上面的文章中看不出有与之相关的命令行选项.

我试图实现深度优先深度搜索状态空间图.我有一个带有三个顶点的图形,它们是两个激活边和两个禁止边.每个节点都有一个二进制值,统称这是图的状态.通过查看其中一个节点是高于阈值还是低于阈值(通过对所有传入节点求和计算),图形可以转换到新状态.每个转换最多只有一个节点会发生变化.由于它们是三个节点,它们是三个状态转换边缘,在状态转换图中留下每个状态.

我认为我的state_change/3工作正常,例如我可以查询:

?-g_s_s(0,1,1,Begin),node(Arc),state_change(g_s(Begin),Second,Arc).

它给了我三个正确的答案:

Begin = [node(v1, 0), node(v2, 1), node(v3, 1)],
Arc = v1,
Second = g_s([node(v1, 1), node(v2, 1), node(v3, 1)]) ;

Begin = [node(v1, 0), node(v2, 1), node(v3, 1)],
Arc = v2,
Second = g_s([node(v1, 0), node(v2, 0), node(v3, 1)]) ;

Begin = [node(v1, 0), node(v2, 1), node(v3, 1)],
Arc = v3,
Second = g_s([node(v1, 0), node(v2, 1), node(v3, 0)]) 

我正在尝试使用Bratkos Prolog中为AI书提供的谓词id_path,这是问题11.3的解决方案,但我在使用/调整它时遇到了问题. 我想创建一个从起始节点到其他节点的路径,而没有进入循环 - 我不希望它有重复元素或在路径不存在时卡住.我希望路径说出起始状态,然后是一系列可以从起始状态访问的状态.如果有一个自循环,我希望每次到达那里都包含一次.即我想跟踪我进入状态空间的方式并使其独特,而不仅仅是状态空间在路径中是唯一的.

例如,从011开始,我希望所有三条长度为1的路径都可以找到弧线.

 ?-id_path(g_s([node(v1,0),node(v2,1),node(v3,1)],Last,[Temp],Path).
Path = [[node(v1,0),node(v2,1),node(v3,1)],to([node(v1,1),node(v2,1),node(v3,1)],v1)];
Path =[[node(v1,0),node(v2,1),node(v3,1)], to([node(v1,0),node(v2,0),node(v3,1)],v2)];
Path=[[node(v1,0),node(v2,1),node(v3,1)],to([node(v1,1),node(v2,1),node(v3,0)],v3)];

然后在下一个级别所有具有三个节点的路径,显示它需要到达节点的两个弧,然后在下一个级别所有具有四个节点的路径显示它需要的三个弧等

如果这有用,我还将我的代码放在SWISH中？(第一次尝试这个？!) …

min_member(-Min ,+ List)

如果Min是标准术语中最小的成员,则为True.如果List为空,则失败.

?- min_member(3, [1,2,X]).
X = 3.

解释当然是变量在标准的术语顺序中位于所有其他术语之前,并且使用统一.但是,报告的解决方案感觉有些不对劲.

怎么可以说是合理的？我该如何解释这个解决方案？

编辑:

防止min_member/2成功使用此解决方案的一种方法是更改标准库(SWI-Prolog)实现,如下所示:

xmin_member(Min, [H|T]) :-
    xmin_member_(T, H, Min).

xmin_member_([], Min0, Min) :-
    (   var(Min0), nonvar(Min)
    ->  fail
    ;   Min = Min0
    ).
xmin_member_([H|T], Min0, Min) :-
    (   H @>= Min0 
    ->  xmin_member_(T, Min0, Min)
    ;   xmin_member_(T, H, Min)
    ).

失败而不是抛出实例化错误(@mat在他的回答中建议,如果我理解正确的话)的理由是,这是一个明确的问题:

" [1,2,X]当X是自由变量时,3是最小成员吗？"

对此的答案是(至少对我来说)一个明确的"不",而不是"我无法说出来".

这与以下行为属于同一类sort/2:

?- sort([A,B,C], [3,1,2]).
A = 3,
B = 1,
C = 2.

适用相同的技巧:

?- …

我想知道与其他程序员共享Prolog代码/库的最佳实践(以及多个项目之间的自己).我自己也在使用SWI-Prolog,但也对其他Prolog如何解决这个问题感兴趣.

相比之下,Java有Maven + JAR,Python有EasyInstall + PythonEggs,其他语言可能还有很多其他语言.但Prolog还有吗？

SWI-Prolog包

在SWI-Prolog中有Packs,由模块支持library(prolog_pack).这些的缺点是:

1. 您必须为每个包创建存档文件或Git存储库.说我想创建10包.现在我需要创建10个Git存储库.我有时会编辑影响多个文件,可能驻留在多个包/ repos中,要求我为单个(多文件)编辑提交几个Git存储库.
2. 为了创建一个包,你必须手工挑选一些"属于一起"的文件.有时候我发现文件X属于包A和包B.现在我需要在存储库A和B中维护文件X的副本,或者我需要创建另一个包C只包含X和导入C到A和B.
3. 包在公共网站上发布.我的大部分图书馆对我来说都很有趣.其中一些对我与之合作的特定人员很有意思,只有少数人准备好进行更广泛/公开的传播.
4. 包维护者必须指定包间依赖关系.对于复杂的图书馆等级,对我来说似乎是不必要的工作.我已经非常严格地使用Prolog模块,并且只想使用Prolog模块导入的层次结构作为依赖图.

Git子模块

另一种我直到现在使用过的方法是Git子模块.通过将一个存储库导入另一个存储库来实现库之间的依赖关系.这与SWI-Prolog包有一些相同的缺点:

1. 每个库的Git存储库,因此需要维护大量存储库.
2. 维护者必须明智地选择每个repo的文件,并且必须指定需要哪些Git子模块包含.
3. 更新现有库非常困难.我发现(困难的方法)我交给代码的大多数人都无法成功更新具有许多错综复杂的相互依赖的子模块导入的Git存储库.(我非常尊重偶尔使用子模块的Git大师并且总是把它做对,但是大多数非程序员和我工作的很多程序员都觉得它太难了.)

我的理想方法

我个人对完美的Prolog代码共享方法的偏好是:

1. 您传播的库的数量和您拥有的Git存储库的数量是独立的.具体来说,我可以有一个相当大的存储库,其中的一部分以不同的方式传播.如果有人喜欢(重新)使用我的Prolog模块和DCG帮助器谓词,那么我可以简单地向该人传播该单个文件(加上潜在的依赖关系).
2. 您不必亲自挑选和手动复制单个文件,而是让算法遍历模块导入的层次结构以提取(显然)属于一起的文件.首次运行程序时会下载文件.这些文件可能都属于同一个Git存储库或多个存储库,算法根本不关心存储库和库之间或存储库和文件之间的映射.
3. 代码的维护者能够决定一个库是公开发布还是发布给有限的一组人(或者只限于包括维护者在内的有限组).
4. 文件之间的模块导入层次结构是依赖关系跟踪所需的全部内容.

以上暗示我理想的库共享方法是基于文件的,而不是基于包的.如果Prolog模块A使用Prolog模块B并且加载了A,则从本地文件(如果存在)加载B或从存储库下载B. 我不确定基于文件的方法在其他语言中有多常见.前面提到的Maven + JAR和EasyInstall + PythonEggs都是基于包的.

我对其他Prolog程序员使用和思考这个主题非常感兴趣!

在某些情况下,递归谓词可以是CLP(FD) - 具有谓词转向双向的好处.这种方法有哪些限制？例如,可以进行以下计算 CLP(FD):

Fn: n-th Fibonacci Number
Ln: n-th Lucas Number (starting with 2)

通过这个加倍的递归步骤:

F2n = Fn*Ln
L2n = (5*Fn^2+Ln^2)//2

这个递增的递归步骤:

Fn+1 = (Fn+Ln)//2
Ln+1 = (5*Fn+Ln)//2

传统的Prolog 实现已经从n到Fn工作.这可以转变为CLP(FD)程序,保持快速递归并同时使其双向,例如找出Fn = 377的索引n吗？如果有,怎么样？如果不是为什么？

再见

有人可以提供一个简单的渠道约束示例吗？

通道约束用于组合约束问题的视点.约束编程手册很好地解释了它是如何工作的以及为什么它有用:

搜索变量可以是其中一个视点的变量,比如X1(这将在下面进一步讨论).随着搜索的进行,传播约束C1从X1中的变量的域中移除值.然后,信道约束可以允许从X2中的变量的域中移除值.使用第二模型C2的约束来传播这些值删除可以从这些变量中移除更多值,并且这些移除可以通过信道约束再次转换回第一视点.最终结果可能是在视点V1内移除的值多于仅由约束C1移除的值,导致搜索减少.

我不明白这是如何实现的.究竟是什么限制,它们在真正的问题中看起来如何？一个简单的例子非常有用.