小编Dar*_*ver的帖子

我使用Persistent orm和scotty web框架.

我希望通过id从db获取值.这些ID来自GET请求

有"获取"功能,它接受"密钥实体"变量并返回"可能实体".

我使用以下代码从db获取值

k <- keyFromValues $ [(PersistInt64 myOwnIntVarFromRequest)]
case k of
    Left _ -> {-some processing-}
    Right x -> do
    t <- liftIO . runDb $ get (x::Key Post) --Post is one of my models
    case t of
        Nothing -> {-processing-}
        Just x -> {-processing-}

这些代码非常丑陋.但我不知道如何做得更好

所以我的问题是如何在不调用keyFromValues的情况下获取"Key Entity"类型的变量.

PS抱歉我的英语不好

我已经实现了一个密集的光流算法,我想用以下颜色模型可视化它

(颜色表示某点的流动方向,强度表示位移矢量的长度)

我已经实现了可视化的脏版本

def visualizeFlow(u, v):
    colorModel = cv2.imread('../colormodel.png')
    colorModelCenter = (colorModel.shape[0]/2, colorModel.shape[1]/2)
    res = np.zeros((u.shape[0], u.shape[1], 3), dtype=np.uint8)
    mag = np.max(np.sqrt(u**2 + v**2)) 
    if mag == 0:
        return res, colorModel
    for i in xrange(res.shape[0]):
        for j in xrange(res.shape[1]):
            res[i, j] = colorModel[
                        colorModelCenter[0] + (v[i, j]/mag*colorModelCenter[0]),
                        colorModelCenter[1] + (u[i, j]/mag*colorModelCenter[1])
                    ]
    return res, colorModel

它在一般案例图片中产生很好但是它确实很慢

所以我的问题是,任何人都可以帮我更快地实现这种可视化 如果有人知道可视化密集流动的更好方法,那么它可能很酷

我对内在函数很陌生，我面对的代码使用GCC-7.4和GCC-8.3的行为不同

我的代码很简单

b.cpp：

#include <iostream>
#include <xmmintrin.h>

void foo(const float num, const float denom)
{
    const __v4sf num4 = {
        num,
        num,
        num,
        num,
    };
    const __v4sf denom4 = {
        denom,
        denom,
        denom,
        denom,
    };
    float res_arr[] = {0, 0, 0, 0};

    __v4sf *res = (__v4sf*)res_arr;
    *res = num4 / denom4;
    std::cout << res_arr[0] << std::endl;
    std::cout << res_arr[1] << std::endl;
    std::cout << res_arr[2] << std::endl;
    std::cout << res_arr[3] << std::endl;
}

在b.cpp中，我们基本上只是__v4sf从float变量构造两个并执行除法

bh：

#ifndef B_H
#define B_H …

任何人都可以建议我建立有效的面部分类器,可以分类许多不同的面孔(约1000)？

我每张脸只有1-5个例子

我知道opencv face分类器,但它对我的任务很糟糕(许多类,一些样本).对于具有少量样本的一个面部分类,它可以正常工作.但我认为1k单独的分类器并不是一个好主意

我阅读了一些关于人脸识别的文章,但是这些文章中的方法重新考虑了每个班级的大量样本

PS对不起我的写作错误.英语不是我的母语.

在尝试获取NumPy矩阵之外的值时,是否可以接收指定值(例如0)？

例如:

#getItem - some method which do what i want
a = numpy.array([[1, 2], [3, 4]])
getItem(a, 1, 1) # == 4
getItem(a, -1, 1) # == 0

当然我可以手工完成,但在Python中这些方法可能会有不好的表现.

我有一些向量 vec，我想通过沿向量维度复制值来获得新的“表达式”vec2

Eigen::VectorXf vec(5);
vec << 1, 2, 3, 4, 5;
const auto vec2 = vec.someAwesomeEigenMagic<3>();
//vec2 should contains (1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5)^T
//Not (1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5)^T

当然，我可以手动创建这样的向量，或者通过 Eigen::Map 使用复制+向量化来创建这样的向量：

MatrixXf tmp = vec.replicate(1, 3).transpose();
const Map<VectorXf> vec2(tmp.data(), vec.rows() * 3, 1);

但我想vec2成为某种没有分配的“特征模板表达式”（vec 可能很大，我会经常调用这个例程）并立即计算值。（vec 包含每个顶点的权重，我想将它用于加权最小二乘）

我考虑过带有 1 向量的克罗内克乘积技巧，但我不确定它是否针对 1 乘积进行了优化。我也更喜欢避免不受支持的模块

PS对不起我的英语

Eigen 具有惊人的快速 GEMM 实现，因此我想在我的宠物项目张量库中使用它。如果我理解正确的话，可以通过 Eigen::Map 来实现。我编写了简单的示例并进行了定义EIGEN_NO_MALLOC，以确保没有不需要的分配。

它适用于简单的矩阵乘法，例如C += A * B. 但不幸的是它无法处理C += alpha * A * B（GEMM 之类）情况。

#include <iostream>
#include <vector>

#define EIGEN_NO_MALLOC
#include "Eigen/Core"

int main()
{
    using Scalar = float;
    using namespace Eigen;
    std::vector<Scalar> aDat = {1, 2, 3, 4};
    std::vector<Scalar> bDat = {1, 2, 3, 4};
    std::vector<Scalar> cDat = {1, 2, 3, 4};
    Map<Matrix<Scalar, -1, -1, RowMajor>, Unaligned> a(aDat.data(), 2, 2);
    Map<Matrix<Scalar, -1, -1, RowMajor>, Unaligned> b(bDat.data(), 2, 2); …

我是Rust的新手,我正在尝试编写自己的简单泛型函数.

fn templ_sum<T>(x : T, y : T) -> T
    where T : std::ops::Add
{
    let res : T = x + y;
    res
}

fn main()
{
    let x : f32 = 1.0;
    let y : f32 = 2.0;
    let z = templ_sum(x, y);
    println!("{}", z);
}

但编译失败的消息

错误:不匹配的类型:expected T,found <T as core::ops::Add>::Output(期望的类型参数,找到的关联类型)[E0308] main.rs:12让res:T = x + y;

我有点困惑.谁能向我解释我做错了什么？

rustc --version:rustc 1.2.0(082e47636 2015-08-03)