小编dvm*_*lls的帖子

所以说我有一些像这样的清单

val l = List((1, "blue"), (5, "red"), (2, "green"))

然后我想过滤其中一个,我可以做类似的事情

val m = l.filter(item => {
    val (n, s) = item          // "unpack" the tuple here
    n != 2
}

有没有什么办法可以直接将元组"解包"作为lambda的参数,而不是拥有这个中间item变量？

像下面这样的东西是理想的,但是eclipse告诉我 wrong number of parameters; expected=1

val m = l.filter( (n, s) => n != 2 )

任何帮助将不胜感激 - 使用2.9.0.1

说我有两个字符向量:

a <- c("a", "b", "c")
b <- c("1", "2", "3")

如何合并它们以便我得到:

ab <- c("a1", "b2", "c3")

我正在收集关于我的猫粪便多少的数据:

m <- cbind(fluffy=c(1.1,1.2,1.3,1.4),misterCuddles=c(0.9,NA,1.1,1.0))
row.names(m) <- c("2013-01-01", "2013-01-02", "2013-01-03","2013-01-04")

这给了我这个:

           fluffy misterCuddles
2013-01-01    1.1           0.9
2013-01-02    1.2            NA
2013-01-03    1.3           1.1
2013-01-04    1.4           1.0

在每个日期,我想知道每只猫连续多少天已经走了2号.所以结果矩阵应如下所示:

           fluffy misterCuddles
2013-01-01      1             1
2013-01-02      2             0
2013-01-03      3             1
2013-01-04      4             2

有没有办法有效地做到这一点？该cumsum函数做了类似的事情,但这是一个原始的,所以我无法修改它以满足我的脏,脏需求.

我可以运行for循环并存储计数如下:

m.output <- matrix(nrow=nrow(m),ncol=ncol(m))
for (column in 1:ncol(m)) {
  sum <- 0
  for (row in 1:nrow(m)) {
    if (is.na(m[row,column])) sum <- 0
    else sum <- sum + 1

    m.output[row,column] <- sum
  }
}

这是最有效的方法吗？我有很多猫,我记录了多年的便便数据.我可以通过某种方式将其平行化吗？

我想用scala替换我的很多perl.我倾向于做的很多事情之一就是调用二进制文件(通常是编译的C++,但可能是java,其他perl脚本,q脚本等),由我公司的其他团队提供给我.

例如,要做一些复杂的数学运算,我会启动一个外部二进制文件,然后将输入管道输入它.然后,我会收听其stdout流的结果,并stderr流式传输诊断消息.在perl中,我会使用POE::Wheel::Run小部件来完成此操作.我在scala中提出了类似(并且更好)的东西,但我想让它更强大.这是一个围绕ProcessIO物体的小包装.它看起来像这样:

class Exe(command: String, out: String => Unit, err: String => Unit) {

    import scala.sys.process._
    import scala.io._
    import java.io._
    import scala.concurrent._

    val inputStream = new SyncVar[OutputStream];

    val process = Process(command).run(
        new ProcessIO(
            stdin => inputStream.put(stdin),
            stdout => Source.fromInputStream(stdout).getLines.foreach(out),
            stderr => Source.fromInputStream(stderr).getLines.foreach(err)));

    def write(s: String): Unit = synchronized {
        inputStream.get.write((s + "\n").getBytes)
    }

    def close(): Unit = {
        inputStream.get.close
    }
}

然后我会像这样使用它:

val exe = new Exe("tr [a-z] [A-Z]", 
                  out => println("o: …

所以我正在阅读这篇文章,我爱上了俄罗斯方块式月历的日历热图.

然而,这个ggplot例子没有实现俄罗斯方块休息,这可以说是最好的部分.

所以,FTFY,请点击此处:

这个过程是:

1. 为您的数据创建适当的俄罗斯方块中断
2. left_join 你的数据是在(1)创建的俄罗斯方块中断
3. ggplot用一些特制的geoms 泵送上面的东西

(1)的方法是相当简单的,在要点的calendar_tetris_data(...)功能中实现,尽管使它更灵活一点会很好.

我的问题主要围绕(3):我如何捆绑geom必要的7 秒来使休息成为一个程序或geom？

如果我这样做:

calendar_tetris_geoms <- function() {
  geom_segment(aes(x=x, xend=x, y=ymin, yend=ymax)) +                    # (a)
    geom_segment(aes(x=xmin, xend=xmax, y=y, yend=y)) +                  # (b)
    geom_segment(aes(x=dec.x, xend=dec.x, y=dec.ymin, yend=dec.ymax)) +  # (c)
    geom_segment(aes(x=nye.xmin, xend=nye.xmax, y=nye.y, yend=nye.y)) +  # (d)
    geom_segment(x=-0.5, xend=51.5, y=7.5, yend=7.5) +                   # put a line along the top
    geom_segment(x=0.5, xend=52.5, y=0.5, yend=0.5) +                    # …

对不起,如果这是一个愚蠢的标题,我不知道如何清楚地表达这一点

说我有一个记录特征:

trait Logging {
    def log(s:String)
}

然后一些实施

trait PrintlnLog extends Logging {
    def log(s:String) { println(s) }
}

我这样使用

class SomeProcess { this:Logging =>
   def doSomeJunk() {
      log("starting junk")
      ...
      log("junk finished")
   }
}

我可以像这样使用这个类

val p = new SomeProcess () with PrintLog
p.doSomeJunk()

现在怎么样,如果我有这个

class SubProcess { this:Logging => 
   def doSubJunk() {
      log("starting sub junk")
      ...
      log("finished sub junk")
   }
}

class ComplexProcess { this:Logging => 
   def doMoreJunk() {
       log("starting more junk")
       val s = new SubProcess …

所以说我的应用程序中有两个依赖项,一些pub子系统的连接,以及与数据库的连接.我可以做点什么

trait DB {
    def lookup(query:String):String
}

trait PubSub {
    def subscribe(key:String, callback:String => Any)
}

然后我就可以写出我的逻辑了

trait Functionality { this:DB with PubSub => 
    def doSomething() {
        val key = lookup("get key")
        subscribe(key, data => println(data))
    }
}

然后我的应用程序可以像

object Awesome extends App {

    object repository extends Functionality with DB with PubSub {
        def lookup(query:String) = "some key"
        def subscribe(key:String, callback:String => Any) {
            scala.concurrent.ops.spawn { while(true) { callback(key) ; Thread.Sleep(1000) } } 
        }
    }
    repository.doSomething()
}

这一切在世界上都很好.

但是,如果我想要连接两个在同一个应用程序中共享相同数据库实现的pub子系统呢？

我想做点什么 …

我有一些R代码,我想与我办公室里的其他人分享,也可以在我们的服务器上定期运行.我们都有Windows 7桌面,服务器运行Red Hat Enterprise Linux.

我一直在浏览文档,而且我被困住了.以下所有内容都没有完成所有必要步骤,详细说明正确的文件夹结构,或者告诉我如何构建Linux软件包,或者在Linux上构建Windows软件包.

• http://cran.r-project.org/doc/contrib/Leisch-CreatingPackages.pdf
• http://cran.r-project.org/doc/manuals/R-admin.html#Setting-up-a-package-repository
• 创建本地R包存储库

所以我的代码在git中.

$ mkdir ~/daveStuff
$ cd ~/daveStuff
$ git init
$ git remote add origin git@davez0r.co:/opt/git/daveStuff.git
$ git pull origin master

现在在我的主目录中我有这个文件夹结构:

daveStuff
|-- DESCRIPTION
|-- R
    |-- stuff.R
|-- exec
    |-- script.R

我的描述文件如下所示:

Package: daveStuff
Type: Package
Title: What the package does (short line)
Version: 1.0
Date: 2014-02-03
Author: Who wrote it
Maintainer: Who to complain to <yourfault@somewhere.net>
Description: More about what it does (maybe more than one line)
License: …

我经常处理java中包含以下内容的东西:

def printDbl(d:Double) { println("dbl: " + d) }
def printInt(i:Int) { println("int: " + i) }

当然,我想把它包装成一些scala,最终看起来像这样:

def print[T:Manifest] (t:T) {
  if (manifest[T] <:< manifest[Int]) { printInt(t.asInstanceOf[Int]) ; return }
  if (manifest[T] <:< manifest[Double]) { printDbl(t.asInstanceOf[Double]) ; return }

  throw new UnsupportedOperationException("not implemented: " + manifest[T])
}

但是当我运行以下内容时,我得到一个运行时异常:

print(1)
print(2.0)
print("hello")

我似乎记得有一种方法可以在编译时捕获它,但我似乎无法谷歌它.也许是一些聪明的隐含转换？