我目前正在尝试在Haskell中实现原语递归阶乘。我使用函数recNat作为递归函数。这就是:
recNat :: a -> (Nat -> a -> a) -> Nat -> a
recNat a _ Zero = a
recNat a h (Succ n) = h n (recNat a h n)
这是我们的尝试,但不能完全找出问题所在
factR :: Nat -> Nat
factR Zero = Succ Zero
factR (Succ m) = recNat (Succ m) (\ _ y -> y) (factR m)
我也试图实现指数
我试图创建一类固定大小的向量,主要用于几何目的,其中向量长度不会改变:
template<typename T, int n>
class FixedVector
{
private:
T m_rV[n]; // this is the only data member
public:
// class function members
...
}
这将具有编译器检查不兼容大小向量的操作的优点。
在为该类构建操作符*时,我遇到了问题(注意:它不是成员)。这个运算符应该把向量乘以一个标量,就像这个3*1,2,3
我想评估以下公式:
c = exp{x}*erfc{y}
(请参阅下面代码中x和y的定义。)
问题是x和y变得很大,我得到了非常大的exp{x}值和非常小的erfc(y)值。
import numpy as np
import scipy as sci
k = 5.7e-3
D = 1.53e-8
R = 1.5e-5
r = 1e-6
t = np.linspace(0.0,12,10)
x = (r/R) + (D/(R*R) - k)*t
y = (r/(2*np.sqrt(D*t))) + np.sqrt(D*t)/R
exp_x = np.exp(x)
erfc_y = s
我有这样的类型:
data Move a t = Emove a a
| Move a t a
我想让它成为一个函子
instance Functor Move where
fmap f (Emove x y) = Emove (f x) (f y)
fmap f (Move x c y) = Move (f x) c (f y)
但是,由于这类类型的错误,这并不能编译。有人能帮我解决这个问题吗?如何向此实例提供t类型?
inline int input()
{
int c;
int n = 0;
while ((c = getchar_unlocked()) >= '0' && c <= '9')
{
// n = 10 * n + (c - '0');
n = (n << 3) + ( n << 1 ) + c - '0';
}
return n;
}
有人能解释一下这种输入数字的方法是如何工作的
我是第一次使用PocketBeagle,我想知道如何使用beaglebone的PRU和Python进行矩阵乘法?
可以使用PRU运行下面的代码吗?
提前谢谢。
sigma = 2565/8192
mu = np.array(A)[3]
mu = mu[0]
#Aa = np.array((A)).T
Aa = A.T
Y = np.array((B/np.array(B)[3])).T
for i in range(10):
N = np.exp(-(Aa-mu)**2/(2*sigma**2))
dNds = N*(np.power((Aa-mu),2)/(sigma**3
我必须为pow做一个函数,但不能使用乘法。我知道我必须做一个乘法函数,然后再做一个求指数的函数。乘法函数可以工作,但是指数函数有问题。为什么它不能像for循环那样倍增呢?
#include <iostream>
using namespace std;
int multiply(int, int);
int exponent(int, int);
int main()
{
int a, b;
cout << "Please enter a base number: ";
cin >> a;
cout &
我有两个顾虑,
一个尾递归函数可以有两个以上的参数吗?
下面的实现是一个指数函数,它提高了它的能力,还有其他方法可以进一步改进下面的函数吗?
这是我的密码:
#include <stdio.h>
int power(int m,int n, int o);
int powerAux(int m, int n);
main() {
printf("%d\n", powerAux(2,3));
}
int power(int m, int n, int o) {
if (o == 1) {
return m;
函子可以是协变的,也可以是反变的。这种协变/逆变对偶性是否也适用于单模?
类似于:
class Monad m where
return :: a -> m a
(>>=) :: m a -> (a -> m b) -> m b
class ContraMonad m where
return :: a -> m a
contrabind :: m a -> (b -> m a) -> m b
ContraMonad类有意义吗?有什么例子吗?
从范畴的角度来看,函子是两个映射对(一个在对象之间,另一个在类别的箭头之间),遵循一些公理。
我假设,每个函子实例都类似于数学定义,即可以同时映射对象和函数,但是Haskell的Functor类只有映射函数的函数fmap。
为什么会这样呢?
换句话说,UPD:
每个Monad类型的M都有一个函数return :: a -> M a。
而函子类型F没有函数return :: a -> F a,只有F x构造函数。
我能够以如下方式将函子的定义从范畴理论映射到哈斯克尔的定义:由于Hask的对象是类型,函子F
将每个类型的a of Hask映射到新类型的F a,粗略地说,在它前面加上"F“。
使用a -> b将Hask的每个态射F a -> F b映射到新的态射F a -> F b。
到现在为止还好。现在我进入了Applicative,在教科书中找不到任何这样的概念。通过查看它添加到Functor,ap :: f (a -> b) -> f a -> f b中的内容,我试图给出自己的定义。
首先,我注意到由于(->)也是一种类型,Hask的态
给定一个函数f(N)=1^1*2^2*3^3.....N^N,我必须计算f(N)/f(r)*f(N-r)。下面给出了我的c代码,但它适用于小写N,如5或6。
#include<stdio.h>
unsigned long long power(long x, long y)
{
unsigned long long temp;
if( y == 0)
return 1;
temp = power(x, y/2);
if (y%2 == 0)
return temp*temp;
else
ret
在C++11中,线程对象可以被移动。众所周知,我们创建的每个线程都拥有一个函子。显然,移动一个未执行其函子的线程是合理的。但是,移动一个正在调用或已经执行了一段时间的函数的线程又如何呢?
为了更进一步,如果我实现了一个线程包装类,如:
//noncopyable is a tag class of which copy constructor and copy assignment are deleted.
class Thread:noncopyable{
private:
using ThreadFunc = std::function<void()>;
boo
我只是想找个单身汉,所以如果我问一个糟糕的问题,请耐心点,但是.
如果单元组只要求:
(a -> M a),其中M是一元型构造函数,并且
(M a -> (a -> M b) -> M b),它是绑定操作(我将其理解为将monad映射到非一元到一元值函数)。
.这不意味着
(M a -> a)和
(M (M a) -> M a)不是隐式要求的吗?
这不是经常会引起麻烦吗?
假设我们有一组函数,S,它的类型都是(x -> y),其中x和y是任意类型。
现在,假设我使用一组一元函数M进行编程,其中它们的类型是x -&
我正试图使Monad的绝对定义与我在其他一些教程/书籍中看到的其他一般表示/定义相一致。
下面,我正在(也许是有力地)试图把这两个定义联系起来,请指出错误,并在需要时提供更正。
所以从Monad的定义开始
单子只是内函子范畴中的一元。
只要稍微了解一下内射函数,我就认为Monad可以写成
((a->b)->Ma->Mb)->((b->c)->Mb->Mc)
LHS的'Type‘(左手边)是Mb,而RHS的类型是Mc,所以我想我可以按下面的方式写它
Mb-> (b->c)-> Mc, **which is how we
到目前为止,我已经解决了欧几里得,lCM,extGCD和铜绿。如何求解模逆(Minv)?我认为“假设n是相互作用的”使我感到困惑。
euclid :: Integer -> Integer -> Integer
euclid 0 0 = error "GCD(0,0) is undefined"
euclid a 0 = a
euclid a b = euclid b (a `emod` b)
-- Returns the least common multiple of a and b, using the definition of lcm
-- given
我用paillier密码系统加密了两个数字。这些数字的加密值是bigInteger,当我要除以它们时,值是十进制数,例如:第一个加密值是12446486760457687016046,加密值为3是98647617673416817617。除法的结果很可能是十进制。在这种情况下,最终的结果是0,因为paillier获得了bigInteger作为参数。我怎么能把它们分开呢?
public class Paillier {
/**
* p and q are two large primes.
* lambda = lcm(p-1, q-1) = (p-1)*(q-1)/gcd(p-1,
我有一个包装类CudaMatrix,它实现了几个cuBLAS操作,允许我调用在内部数据指针上运行sgemm操作的m1.multiply(m2)。
我想通过子矩阵上的运算来扩展这个类,比如
CudaMatrix a(100,100);
CudaMatrix b(100,100);
// fill a and b
int i=5, j=15;
CudaSubMatrix sa(a, i, j, i+10, j+10); // sa := a[5:15, 15:25]
i=50, j=60;
CudaSubMatrix sb(b, i, j, i+10, j+10); // sb := b[50