所以我正在完成"Scala for the Impatient"中的一些练习,其中一个是:
编写一个for循环来计算字符串中所有字母的Unicode代码的乘积.例如,"Hello"中的字符的乘积是9415087488 L.
下一个问题是做同样的事情,但没有for循环 - 它暗示我们应该检查StringOpsScaladoc.
我检查了Scaladoc中的RichChar和StringOps部分,也许我误读或者看错了地方,但我找不到任何能让我匹配输出的东西.我到目前为止尝试过:
scala> x.foldLeft(1)(_ * _.toInt)
res0: Int = 825152896
scala> x.foldLeft(1)(_ * _.getNumericValue)
res5: Int = 2518992
scala> x.foldLeft(1)(_ * _.intValue())
res6: Int = 825152896
scala> var x = 1
x: Int = 1
scala> for (c <- "Hello") x *= c.toInt
scala> x
res12: Int = 825152896
哪个与他们的输出不匹配.
如何做到这一点,无论是for和非for的方式？
谢谢!
我正在研究K&R(例如5-9),我试图转换原始程序的2D数组
static char daytab[2][13] = {
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
使用指针指向13个整数的数组
static char (*daytab)[13] = {
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
但编译器会打印警告:标量初始化程序中的多余元素.
谷歌搜索没有帮助,甚至K&R在将数组传递给函数时写道,
myFunction(int daytab[2][13]) {...}
是相同的
myFunction(int (*daytab)[13]) {...}
最近开始研究这些AMQP(RabbitMQ,ActiveMQ)和ZeroMQ技术,对分布式系统/计算感兴趣.一直在谷歌搜索和StackOverflow'周围,找不到两者之间的明确比较.
我得到的最远的是两者不太可比,但我想知道差异.在我看来ZeroMQ更加分散(没有消息经纪人在播放中间人处理消息/ guarenteering交付)并且因此更快,但并不意味着是一个完全成熟的系统,而是需要以编程方式处理的事情,比如演员.
另一方面,AMQP似乎是一个更完善的系统,中央消息代理确保可靠的交付,但由于这一点,比ZeroMQ慢.但是,中央经纪人会造成单点故障.
也许比喻是客户/服务器与P2P？
我的发现是真的吗？另外,使用一个优于另一个的优点,缺点或用例是什么？比较使用*MQ与像Akka Actors这样的东西也会很好.
编辑多看了一下.. ZeroMQ似乎是AMQP的新竞争者,似乎要快得多,唯一的问题是采用/实现？
我想知道..你把把application.conf配置演员的文件放在哪里？我正在尝试做这里正在做的事情,但SBT没有接收到文件 - 我的印象是SBT会找到application.conf并自动将其添加到我的文件中-classpath.我现在有application.conf在/project/application.conf
我得到的错误是:
[ERROR] [04/11/2012 16:08:13.174] [HittingTimeSystem-akka.actor.default-dispatcher-2] [akka://HittingTimeSystem/user/master] error while creating actor
akka.config.ConfigurationException:router Actor[akka://HittingTimeSystem/user/master/workerRouter] needs external configuration from file (e.g. application.conf)
谢谢!-kstruct
所以我一直在尝试使用信号收集框架,我下载了.jar文件并将其解压缩到一个文件夹中.目前文件夹结构如下:
LICENSE.txt
PageRank.scala
core-1.1.1-sources.jar
dependencies/
javaapi-1.1.1-sources.jar
NOTICE.txt
README.txt
core-1.1.1.jar
javaapi-1.1.1-javadoc.jar
javaapi-1.1.1.jar
PageRank.scala他们提供的Scala测试代码在哪里,即:
import com.signalcollect._
object PageRank extends App {
val graph = GraphBuilder.build
graph.addVertex(new PageRankVertex(id=1))
graph.addVertex(new PageRankVertex(id=2))
graph.addEdge(new PageRankEdge(sourceId=1, targetId=2))
graph.addEdge(new PageRankEdge(sourceId=2, targetId=1))
graph.execute
graph.foreachVertex(println(_))
graph.shutdown
}
class PageRankVertex(id: Any, dampingFactor: Double=0.85)
extends DataGraphVertex(id=id, state=1-dampingFactor) {
type Signal = Double
def collect(oldState: Double, mostRecentSignals: Iterable[Double]): Double = {
1 - dampingFactor + dampingFactor * mostRecentSignals.sum
}
}
class PageRankEdge(sourceId: Any, targetId: Any)
extends DefaultEdge(sourceId, targetId) …在此代码块之前定义:
dataset可以是一个Vector或ListnumberOfSlices是一种Int表示许多"次"怎么给数据集我想将数据集拆分成numberOfSlices切片,尽可能均匀地分布.通过"拆分"我想我的意思是"分区"(所有的交集都应该是空的,所有的联合应该是原始的)来使用集合理论术语,尽管这不一定是集合,只是一个任意集合.
例如
dataset = List(1, 2, 3, 4, 5, 6, 7)
numberOfSlices = 3
slices == ListBuffer(Vector(1, 2), Vector(3, 4), Vector(5, 6, 7))
有没有比我下面更好的方法呢？(我甚至不确定它是最优的......)或者这可能不是算法上可行的尝试,在这种情况下,任何已知的良好启发式方法？
val slices = new ListBuffer[Vector[Int]]
val stepSize = dataset.length / numberOfSlices
var currentStep = 0
var looper = 0
while (looper != numberOfSlices) {
if (looper != numberOfSlices - 1) {
slices += dataset.slice(currentStep, currentStep + stepSize)
currentStep += stepSize
} else {
slices …所以直到大约6个月前,我的大部分工作(大图处理)都包含Python和C++.到目前为止,甚至现在,我还没有编写任何Java ..我已经看过语言并且熟悉语法(来自C/C++背景),并且喜欢JVM的想法,但从来没有实际上写了大量的Java.
当我拿起Scala时,我非常喜欢它,OOP和函数式编程功能于一体,它在JVM上非常棒.我一直在努力改进我的Scala并且一直在玩Akka,并且仍然喜欢它.然而,有时候,也许只是我推翻它,但我觉得我应该学习更多关于Java和/或JVM的知识.
我从很多人那里听说Scala应该被认为是一种与Java不同的语言,就像C++到C.也许你可能会有同样的感觉,也许学习Java或多或少与学习Scala不相干,但我感觉学习更多关于JVM(例如JIT编译,类型擦除)会有帮助吗？
思考？
来自Scala(和Akka),我最近开始研究其他用分布式计算设计的语言,即Erlang(以及一点点的Oz和Bloom).Erlang和Oz都是动态类型的,如果我没记错(将尝试查找链接),人们已经尝试向Erlang添加类型并设法键入其中的一部分,但无法成功强制系统使其适合最后一点？
Oz,虽然是一种研究语言,对我来说当然很有趣,但它也是动态类型的.
Bloom目前的实现是在Ruby中,因此是动态类型的.
据我所知,Scala(我认为Haskell虽然我认为最初是作为对纯懒惰函数语言而不是分布式系统的探索而构建的)是唯一静态类型并提供语言级抽象的语言(因为缺乏在分布式计算中更好的术语.
我只是想知道动态类型与静态类型相比是否有固有的优势,特别是在为分布式系统编程提供语言级抽象的上下文中.
到目前为止,我一直在用SBT编译我的Scala项目(通过Typesafe堆栈).我想通过sbt-assembly在几台机器上运行代码.按照指示,我所做的唯一一项更改是在我的project/Build.scala文件中.这是相关部分:
resolvers += "Typesafe Releases" at "http://repo.typesafe.com/typesafe/releases",
resolvers += "artifactory" at "http://scalasbt.artifactoryonline.com/scalasbt/sbt-plugin-releases",
libraryDependencies += "com.eed3si9n" % "sbt-assembly" % "0.8.3"
sbt compile但是,当我运行时,我收到此错误:
sbt.ResolveException: unresolved dependency: com.eed3si9n#sbt-assembly/scala_2.9.1/sbt_0.11.2;0.8.3: not found.
我究竟做错了什么？
谢谢!
编辑build.sbt在与Build.scala(文件夹是/project/)相同的文件夹中
创建了一个文件,并在其中包含以下两行:
Seq[Setting[_]](resolvers += "artifactory" at "http://scalasbt.artifactoryonline.com/scalasbt/sbt-plugin-releases",
addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.8.3"))
现在的错误是:
[warn] ::::::::::::::::::::::::::::::::::::::::::::::
[warn] :: UNRESOLVED DEPENDENCIES ::
[warn] ::::::::::::::::::::::::::::::::::::::::::::::
[warn] :: com.eed3si9n#sbt-assembly;0.8.3: not found
[warn] ::::::::::::::::::::::::::::::::::::::::::::::
[warn]
[warn] Note: Some unresolved dependencies have extra attributes. Check …是否可以Vector在编译时强制传入方法的大小？我想使用空间中的一组点来模拟一个n维欧几里德空间,这些点看起来像这样(这就是我现在所拥有的):
case class EuclideanPoint(coordinates: Vector[Double]) {
def distanceTo(desination: EuclieanPoint): Double = ???
}
如果我有一个通过创建的坐标EuclideanPoint(Vector(1, 0, 0)),它是一个3D欧几里德点.鉴于此,我想确保调用中传递的目标点具有distanceTo相同的维度.
我知道我可以通过使用Tuple1to 来做到这一点Tuple22,但我想代表许多不同的几何空间,如果我用Tuples 做的话,我会为每个空间写22个类- 有更好的方法吗？