小编Mit*_*ops的帖子

我有以下数据:

> Data
          Date    Start       End
1   2011-11-15 12:01:27 12:30:15 
2   2011-11-16 12:01:25 12:32:15 
3   2011-11-17 12:01:02 12:39:12 
4   2011-11-19 12:01:12 12:30:18

我还附加了一个持续时间列

Data[,4] <- as.numeric(difftime(Data$End,Data$Start))
names(Data)[4] <- "Duration"

我脑子里有一个Start,End的可视化,看起来有点像股票烛台或OHLC图表,其中x值是Date,y是End - Start.

End位于顶部,矩形下降到Start ---矩形的高度随持续时间的变化而变化.也就是说,每个日期都有一个不同的矩形高度,由开始和结束之间的差异决定.

这里的x轴从2011-11-15到2011-11-19.y轴从12:00:00到12:40:00.

任何ggplot向导都能看到一个简单的方法吗？由于Start和End都随着时间的推移而变化,我是否必须使用geom_ribbon或geom_polygon而不是geom_bar或geom_area？

如果持续时间的值大于2个标准差,那么条形图的颜色会变为红色,这将是非常酷的!

我在R中有一个数据框,我想添加虚拟变量,以便绘制不同颜色的不同项目.

我的数据框df <-是这样的:

UID CategoryA  count
  1       AAA      2
  2       AAA      2
  3       BBB      1
  4       CCC      1
  5       DDD      1

我有另一个清单, special <- c("AAA", "DDD")

我想最终得到df类似的东西:

UID CategoryA  count dummy
  1       AAA      2     1
  2       AAA      2     1
  3       BBB      1     0
  4       CCC      1     0
  5       DDD      1     1 

所以dummy = 1,无论在哪里CategoryA == special

我试图搜索这个,但我怀疑它需要%in%谷歌很难.

我可以做这误导的原因,所以也许你可以帮我的短路问题---我在创造这个虚拟变量的目标是创建一个条形图是那种横盘直方图通过计数列出所有类别.我希望这个变量提供一个group颜色为dummy == 1 red的那些和dummy == 0 green的那些.我将使用ggplot2.

我习惯于在pymongo中这样做,作为访问特定数据库的一种方法:

import pymongo

connection = pymongo.MongoClient()
db = connection.DBNAME

然后,我现在想要能够连接到通过变量命名的数据库,并着眼于循环一系列数据库.所以类似于:

dbname = 'DBNAME'

connection = pymongo.MongoClient()
db = eval('connection.' + dbname)

我被告知eval()偶尔会成为魔鬼,应该避免.如何使用setattr()或其他解决方案执行此操作？就像是...

dbname = 'DBNAME'

connection = pymongo.MongoClient()
db = setattr(connection, '??name??', dbname)

我试图关闭图案非常简单的参数语法分析这个例子.第一个参数应该是一个double,第二个参数应该是一个整数,如果它们不是这两个类型,我想对else中指定的两个使用默认参数.这就是我所拥有的:

parseArgs :: [String] -> (Double, Integer)
parseArgs args = do
  if length(args) == 2 then do
    let v1 = read (args !! 0) :: Double
    let v2 = read (args !! 1) :: Integer
    return (v1, v2)
  else do
    let v1 = read ("0.5") :: Double 
    let v2 = read ("5") :: Integer
    return (v1, v2)

我知道有更复杂的方法来解析使用optparse灵感设计的参数Applicative,但我还没有.

这是我得到的错误:

myscript.hs:186:5-31: error: …
    • Couldn't match type ‘(Double, Integer)’ with ‘Integer’
      Expected type: (Double, Integer)
        Actual type: …

我试图更好地理解手动指定 Haskell 函数签名，但我不理解这种上下文中的 => 运算符。

这是我的例子：

Prelude> add a b = a + b 
Prelude> add 1 2
3

Haskell 已经推断出这个函数签名：

Prelude> :info add
add :: Num a => a -> a -> a 

这看起来很棒，因为如果我手动定义它，我会这样做：

add :: Int -> Int -> Int
add a b = a + b

所以，我理解推断类型更好，因为它允许：

Prelude> add 1.0 2.0
3.0
Prelude> add 1.0 2
3.0

但是我应该如何阅读正在发生的事情

Num a => a -> a -> a

?

例如，为什么不写为：

add :: Num -> Num -> Num

或者

add …

我有一个图像：

>>> image.shape
(720, 1280)

我的图像是 0 和 255 的二进制数组。我已经完成了一些粗略的边缘检测，现在我想通过这些点拟合多项式。

我想在图像空间中的原始图像上看到这些点。

据我所知，执行此操作的标准方法是通过重塑来展开 x,y 图像，适合展开的版本，然后重新重塑回原始图像。

pts = np.array(image).reshape((-1, 2))
xdata = pts[:,0]
ydata = pts[:,1]
z1 = np.polyfit(xdata, ydata, 1) 
z2 = np.polyfit(xdata, ydata, 2)  # or quadratic...
f = np.poly1d(z)

现在我有了这个功能，f我该如何使用它在原始图像空间中绘制线条？

尤其：

1. .reshape() 返回图像空间的正确反向索引是什么？
2. 这似乎有点麻烦。这种重塑重塑舞蹈是图像处理中常见的事情吗？上面描述的是执行此操作的标准方法，还是有不同的方法？
3. 如果映射到 720, 1280, 1 数组上称为图像空间，那么重塑后的空间称为什么？数据空间？线性空间？

我是从这样的问题理解这个和这个，使用PRAGMA OverloadedStrings的手段，我应该能够使用文字作为我的字符串类型。

但是，当我使用文本测试数据类型时，出现以下错误：

$ stack ghci
Prelude> :l myfile.hs
Ok, one module loaded.
*Main> Rec "asd" "m"

<interactive>:46:5: error:
    • Couldn't match expected type ‘Text’ with actual type ‘[Char]’
    • In the first argument of ‘Rec’, namely ‘"asd"’
      In the expression: Rec "asd" "m"
      In an equation for ‘it’: it = Rec "asd" "m"

<interactive>:46:11: error:
    • Couldn't match expected type ‘Text’ with actual type ‘[Char]’
    • In the second argument of …

我正在解析一个看起来像这样的文件：

Good
id123
^
Bad
id456
^
Middle
id789

记录由分隔^\n，该记录中的字段仅由分隔newlines。

读取该文件并拆分后，最终得到的列表列表如下所示：

[["Good","id123",""],["Bad","id456",""],["Middle","id789",""]]

但是，我无法将其转换为Rec类型的列表。

这是我的代码：

{-# LANGUAGE DeriveGeneric,  OverloadedStrings #-}
import Data.Text as T
import Data.Text.IO as T

data Rec = Rec Text Text Text deriving Show  -- simple

main :: IO ()
main = do
    contents <- T.readFile "./dat.txf" 
    let seps = splitOn "^\n" contents
    let recs = fmap (splitOn "\n") seps
    print recs

main

产生

[["Good","id123",""],["Bad","id456",""],["Middle","id789",""]]

如预期的那样。但是尝试将其下一步，并将其转换为Recs，方法如下：

main_ :: IO ()
main_ = do
    contents …

我下面有三个例子。我试图理解为什么在第一种情况下，我可以分配变量，但不能打印它。在第二个中，如果我将整个内容分配为字符串，则以后可以打印它。但是在第三种情况下，如果我进行计算然后尝试打印，则将失败：

{-# LANGUAGE DeriveGeneric,  OverloadedStrings, RankNTypes, KindSignatures, FlexibleContexts, AllowAmbiguousTypes #-}
:ext OverloadedStrings 

import Data.Text as T
import Data.Text.IO as T

-- This works
mm1 x = do 
        T.putStrLn "Testing m1"
        let m = T.pack $ show x
            y = x * 2
        T.putStrLn "Here is m"
        T.putStrLn m
        T.putStrLn "y has been assigned successfully, but not printed."

mm1 10

-- This also works
mm2 x = do 
        T.putStrLn "Testing m2"
        let m = T.pack $ show x
            y = T.pack …

将字符串打印为字节数组的 fmt 代码是什么？

如果我有一个编组的 json 对象，我可以像这样打印字节：

type Fakejs struct {
    Fake string `json:"fake"`
}

fjs := Fakejs {Fake:"abc"}
mjs, err := json.Marshal(fjs)
fmt.Println(mjs)

生产

[123 34 102 97 107 101 34 58 34 97 98 99 34 125]

这就是我想要的。但是，使用常规字符串，我尝试这样做：

mystr := "{\"fake\":\"abc\"}"
fmt.Printf("mystr:\t %x \n", []byte(mystr))

这产生：

7b2266616b65223a22616263227d

这不是我想要的。什么是类似于“%x”的格式代码，它将字符串打印为字节数组。