• 笛卡尔积运算： function[D]=cartesian_product(A,B) [m1,n1]=size(A); [m2,n2]=size(B); if m1m21 C=A’; for i=1:n1 for j=1:n2 if C(i,1)<B(1,j) D(i,j)= C(i,1); else D(i,j)= B(1,j); end end end else ...
1.模糊关系最大-最小合成：
function [T]=max_minCompound(R,S) [m1,n1]=size®; [m2,n2]=size(S); if n1==m2 for i=1:m1 for j=1:n2 T(i,j)=max(min(R(i,:),S(:,j)’)); end end else fprint(‘矩阵输入错误’); end
2.模糊向量笛卡尔积：  function[D]=cartesian_product(A,B) [a1,a2]=size(A); [b1,b2]=size(B); if a1==b1 C=A’; for i=1:a2 for j=1:b2 D(i,j)=min(A(i,1),B(1,j)) end end else
    fprintf('输入矩阵不规范')

end
3.模糊向量的内积：
function[e]=inner_product(A,B) [m,n]=size(A); if size(A)==size(B) C=B’; for i=1:n D(i)=min(A(i),B(i)); end e = max(D’) else fprintf(‘输入矩阵不规范’) end
展开全文
• 已知两个模糊向量分别如下所示，求它们的笛卡尔乘积。MATLAB程序可直接运行，有注释。
• 首先，我将向您展示一个递归版本。// Cartesion product of vector of vectors#include #include #include // Types to hold vector-of-ints (Vi) and vector-of-vector-of-ints (Vvi)typedef std::vector Vi;...

首先，我将向您展示一个递归版本。
// Cartesion product of vector of vectors
#include
#include
#include
// Types to hold vector-of-ints (Vi) and vector-of-vector-of-ints (Vvi)
typedef std::vector Vi;
typedef std::vector Vvi;
// Just for the sample -- populate the intput data set
Vvi build_input() {
Vvi vvi;
for(int i = 0; i < 3; i++) {
Vi vi;
for(int j = 0; j < 3; j++) {
vi.push_back(i*10+j);
}
vvi.push_back(vi);
}
return vvi;
}
// just for the sample -- print the data sets
std::ostream&
operator<
{
os << "(";
std::copy(vi.begin(), vi.end(), std::ostream_iterator(os, ", "));
os << ")";
return os;
}
std::ostream&
operator<
{
os << "(\n";
for(Vvi::const_iterator it = vvi.begin();
it != vvi.end();
it++) {
os << "  " << *it << "\n";
}
os << ")";
return os;
}
// recursive algorithm to to produce cart. prod.
// At any given moment, "me" points to some Vi in the middle of the
// input data set.
//   for int i in *me:
//      add i to current result
//      recurse on next "me"
//
void cart_product(
Vvi& rvvi,  // final result
Vi&  rvi,   // current result
Vvi::const_iterator me, // current input
Vvi::const_iterator end) // final input
{
if(me == end) {
// terminal condition of the recursion. We no longer have
// any input vectors to manipulate. Add the current result (rvi)
// to the total set of results (rvvvi).
rvvi.push_back(rvi);
return;
}
// need an easy name for my vector-of-ints
const Vi& mevi = *me;
for(Vi::const_iterator it = mevi.begin();
it != mevi.end();
it++) {
// final rvi will look like "a, b, c, ME, d, e, f"
// At the moment, rvi already has "a, b, c"
cart_product(rvvi, rvi, me+1, end); add "d, e, f"
rvi.pop_back(); // clean ME off for next round
}
}
// sample only, to drive the cart_product routine.
int main() {
Vvi input(build_input());
std::cout << input << "\n";
Vvi output;
Vi outputTemp;
cart_product(output, outputTemp, input.begin(), input.end());
std::cout << output << "\n";
}
现在，我将向您展示我无耻地从@John偷走的递归迭代版本：
程序的其余部分几乎相同，只显示了cart_product功能。
// Seems like you'd want a vector of iterators
// which iterate over your individual vectors.
struct Digits {
Vi::const_iterator begin;
Vi::const_iterator end;
Vi::const_iterator me;
};
typedef std::vector Vd;
void cart_product(
Vvi& out,  // final result
Vvi& in)  // final result
{
Vd vd;
// Start all of the iterators at the beginning.
for(Vvi::const_iterator it = in.begin();
it != in.end();
++it) {
Digits d = {(*it).begin(), (*it).end(), (*it).begin()};
vd.push_back(d);
}
while(1) {
// Construct your first product vector by pulling
// out the element of each vector via the iterator.
Vi result;
for(Vd::const_iterator it = vd.begin();
it != vd.end();
it++) {
result.push_back(*(it->me));
}
out.push_back(result);
// Increment the rightmost one, and repeat.
// When you reach the end, reset that one to the beginning and
// increment the next-to-last one. You can get the "next-to-last"
// iterator by pulling it out of the neighboring element in your
// vector of iterators.
for(Vd::iterator it = vd.begin(); ; ) {
// okay, I started at the left instead. sue me
++(it->me);
if(it->me == it->end) {
if(it+1 == vd.end()) {
// I'm the last digit, and I'm about to roll
return;
} else {
it->me = it->begin;
++it;
}
} else {
// normal
break;
}
}
}
}

展开全文
• 编辑：这个答案可行，但我认为埃里克的答案更好，因为它更容易概括。在为了帮助那些可能无意中发现这个问题的人。这里有一个很简单的方法来回答上述问题。它雇佣np.哪里求满足一定条件的矩阵的所有指数。...

编辑：这个答案可行，但我认为埃里克的答案更好，因为它更容易概括。在
为了帮助那些可能无意中发现这个问题的人。这里有一个很简单的方法来回答上述问题。它雇佣np.哪里求满足一定条件的矩阵的所有指数。在这里，我们的标准是所有矩阵都满足的。这相当于上面的问题。这仅适用于上面所述的例子，但将其推广到N维应该不会太困难。在import numpy as np
dim=3
gran=5
def vec_powerset(dim, gran):
#returns a list of all the vectors for a three dimensional vector space
#where the elements of the vectors are the naturals up to gran
size=tuple([gran]*dim)
a=np.zeros(size)
return [[np.where(a>(-np.inf))[0][x],np.where(a>(-np.inf))[1][x],
np.where(a>(-np.inf))[2][x]] for x in
range(len(np.where(a>(-np.inf))[0]))]
print vec_powerset(dim,gran)
[[0, 0, 0], [0, 0, 1], [0, 0, 2], [0, 0, 3], [0, 0, 4], [0, 1, 0], [0, 1, 1], [0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 2, 0], [0, 2, 1], [0, 2, 2], [0, 2, 3], [0, 2, 4], [0, 3, 0], [0, 3, 1], [0, 3, 2], [0, 3, 3], [0, 3, 4], [0, 4, 0], [0, 4, 1], [0, 4, 2], [0, 4, 3], [0, 4, 4], [1, 0, 0], [1, 0, 1], [1, 0, 2], [1, 0, 3], [1, 0, 4], [1, 1, 0], [1, 1, 1], [1, 1, 2], [1, 1, 3], [1, 1, 4], [1, 2, 0], [1, 2, 1], [1, 2, 2], [1, 2, 3], [1, 2, 4], [1, 3, 0], [1, 3, 1], [1, 3, 2], [1, 3, 3], [1, 3, 4], [1, 4, 0], [1, 4, 1], [1, 4, 2], [1, 4, 3], [1, 4, 4], [2, 0, 0], [2, 0, 1], [2, 0, 2], [2, 0, 3], [2, 0, 4], [2, 1, 0], [2, 1, 1], [2, 1, 2], [2, 1, 3], [2, 1, 4], [2, 2, 0], [2, 2, 1], [2, 2, 2], [2, 2, 3], [2, 2, 4], [2, 3, 0], [2, 3, 1], [2, 3, 2], [2, 3, 3], [2, 3, 4], [2, 4, 0], [2, 4, 1], [2, 4, 2], [2, 4, 3], [2, 4, 4], [3, 0, 0], [3, 0, 1], [3, 0, 2], [3, 0, 3], [3, 0, 4], [3, 1, 0], [3, 1, 1], [3, 1, 2], [3, 1, 3], [3, 1, 4], [3, 2, 0], [3, 2, 1], [3, 2, 2], [3, 2, 3], [3, 2, 4], [3, 3, 0], [3, 3, 1], [3, 3, 2], [3, 3, 3], [3, 3, 4], [3, 4, 0], [3, 4, 1], [3, 4, 2], [3, 4, 3], [3, 4, 4], [4, 0, 0], [4, 0, 1], [4, 0, 2], [4, 0, 3], [4, 0, 4], [4, 1, 0], [4, 1, 1], [4, 1, 2], [4, 1, 3], [4, 1, 4], [4, 2, 0], [4, 2, 1], [4, 2, 2], [4, 2, 3], [4, 2, 4], [4, 3, 0], [4, 3, 1], [4, 3, 2], [4, 3, 3], [4, 3, 4], [4, 4, 0], [4, 4, 1], [4, 4, 2], [4, 4, 3], [4, 4, 4]]

展开全文
• Julia通常在嵌套循环中非常快,所以如果它们对你正常工作,你应该可以检查性能,或者只是坚持下去.其他选项是使用repmat(这个比使用repeat更快一点)：[repmat(x,1,length(y))'[:] repmat(y,length(x),1)[:]]对这两种...

Julia通常在嵌套循环中非常快,所以如果它们对你正常工作,你应该可以检查性能,或者只是坚持下去.
其他选项是使用repmat(这个比使用repeat更快一点)：
[repmat(x,1,length(y))'[:] repmat(y,length(x),1)[:]]
对这两种方法进行了一些快速测试：
x=rand(1000)
y=rand(1000)
function withrepeat(x,y)
[repeat(x, inner=[size(y,1)]) repeat(y, outer=[size(x,1)])]
end
function withrepmat(x,y)
[repmat(x,1,length(y))'[:] repmat(y,length(x),1)[:]]
end
withrepeat(x,y)
elapsed time: 0.21556302 seconds (95986112 bytes allocated)
with repmat(x,y)
elapsed time: 0.075604488 seconds (56000560 bytes allocated)
不知道为什么会有这么大的差异,我认为还有改进的余地.
没有尝试过Iterators.jl包中的产品功能.
希望这可以帮助.
尝试了几个嵌套循环,确实更快：
function withloops (x,y)
leny=length(y)
lenx=length(x)
m=leny*lenx
OUT = zeros(Float64, m,2)
c=1
for i = 1:lenx
for j = 1:leny
OUT[c,1] = x[i]
OUT[c,2] = y[j]
c+=1
end
end
return OUT
end
并且,对于x和y,相同的兰特(1000).
withloops(x,y)
elapsed time: 0.011350679 seconds (16000128 bytes allocated)

展开全文
• 计算多个集合的笛卡尔积，有规律可循，算法和代码也不难，但是很多语言都没有提供直接计算笛卡尔积的方法，需要自己写大段大段的代码计算笛卡尔积，python提供了一种最简单的计算笛卡称积的方法(只需要一行代码)，...
• 它使用向量作为函数参数，而不是元组。此版本不构建临时元组，而是使用lambda。现在，它不会进行不必要的复制/移动，并且似乎已成功优化。#include#include// cross_imp(f, v...) means "do f for each element of...
• sets={[12],[12],[45]};[xyz]=ndgrid(sets{:});cartProd=[x(:)y(:)z(:)];cartProd=114214124224115215125225或者，...
• X,YX,Y 为离散型随机变量，XX 有 6 种可能的状态（值），YY 有 5 种可能的状态。以上的 P(X,Y)=P(X)⋅P(Y)P(X,Y) = P(X)\cdot ...笛卡尔积 矩阵向量乘法：C6×5=A6×1⋅B1×5C_{6\times 5}=A_{6\times 1}\cdot B_{1\tim
• I would like to generate all the possible combinations of the elements of a given number of vectors.For example, for [1 2], [1 2] and [4 5] I want to generate the elements:[1 1 4; 1 1 5;...
• X = CARTPROD(A,B,C,...) 返回集合 A、B、C 等的笛卡尔积，其中 A、B、C 是数值向量。 例子：A = [-1 -3 -5]; B = [10 11]; C = [0 1]; X = 购物车（A、B、C） X = -5 10 0 -3 10 0 -1 10 0 -5 11 0 -3 11 0 -1 ...
• meshgrid() 的包装器，它创建所有元素的组合存储在元胞数组“字段”中的向量。 输出是 i) a 组合的元胞数组，每个以字符串形式给出，其中原始元素由 'delim' 分隔，或 ii) 行索引矩阵原始元素的组合。 所有分量向量...
• 第一中，可以看做是横向的，即一个一个list遍历，遍历最后一个list时，才能获取到笛卡尔积 import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * 算法工具类 * * Project Name：erp-...
• 例如，已知两个模糊向量分别为：
• ## hive中的笛卡尔积

万次阅读 2018-08-27 16:14:22
Hive本身是不支持笛卡尔积的，不能用select T1.*, T2.* from table_1, table_2这种语法。但有时候确实需要用到笛卡尔积的时候，可以用下面的语法来实现同样的效果： select T1.*, T2.* from (select * from table...
• x y ('a','b')怎么得到一个data.frame等于x,y的笛卡尔积,也就是 1,a; 1,b; 2,a; 2,b; 3,a; 3,b 下面是一个实现方法:as.data.frame(cbind(rep(x, each=2),rep(y,3)))
• colors = ['black', 'white'] sizes = ['L', 'M', 'S'] shirts = [(color, size) for color in colors for size in sizes] print(shirts)
• 笛卡尔积在数学上是一种二元关系，笛卡尔积作用的双方是两个集合，作用的结果是一个新的集合。 A×B={(a,b)|a∈Aandb∈B} ...倘若我们想得到如下的二元组（也即对两向量做了一次笛卡尔积）构成的矩阵： 1.0000 ...
• 递归实现 $arr = array( array(1), array(2,3), array(4,5,6) ); fun($arr); print_r($res); function fun($arr, $tmp = array()) { foreach(array_shift($arr) AS $v) {$tmp[] = $v;... fun • 所谓数组(或向量)a和b的外,指的是a的每一个元素和b的每一个元素搭配在一起相乘得到的新元素.当然运算规则也可自定义.外预算符为 %o%(注意:百分号中间的字母是小写的o).例如:> a > b > d > d [,1] [,2] [,3] ... • 笛卡尔乘积是指在数学中，两个集合X和Y的笛卡尓积（Cartesian ...假设集合A={a, b}，集合B={0, 1, 2}，则两个集合的笛卡尔积为{(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)}。 笛卡尔积是关系代数里的概念 • 笛卡尔积的含义有$N$个向量，按固定顺序从每个向量中取出一个元素排列成新的向量，所有新的向量的集合，就是这$N$个向量笛卡尔积。比如有三个向量$A,B,C$：$A$$B$$C$$a_1$$b_1$$c_1$$a_2$$b_2$$c_2a_3$则$...

...