精华内容
下载资源
问答
  • 笛卡尔积运算: 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"

    rvi.push_back(*it);  // add ME

    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 {

    // cascade

    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计算笛卡尔积

    千次阅读 2018-05-29 15:38:17
    计算多个集合的笛卡尔积,有规律可循,算法和代码也不难,但是很多语言都没有提供直接计算笛卡尔积的方法,需要自己写大段大段的代码计算笛卡尔积,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) 行索引矩阵原始元素的组合。 所有分量向量...
  • java做笛卡尔积的两种方式

    千次阅读 2020-01-13 01:25:53
    第一中,可以看做是横向的,即一个一个list遍历,遍历最后一个list时,才能获取到笛卡尔积 import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * 算法工具类 * * Project Name:erp-...
  • 每个向量都有超过10000个元素,我必须得到这些向量笛卡尔积。我有一个代码,正在工作,但只有1000个元素和4个向量下。我想将笛卡尔积写入一个文件,但如果输出文件大于1GB,我得到的是:“在抛出'std::bad戡alloc'what()...
  • 用matlab求模糊向量笛卡尔乘积

    千次阅读 2014-04-17 10:43:44
    例如,已知两个模糊向量分别为:
  • 本质上是两个二维数组的笛卡尔积。在在Python中,实现这一点的最快方法是什么?在我当前的实现如下所示:def cartesian_product(arrays):broadcastable = np.ix_(*arrays)broadcasted = np.broadcast_arrays(*...
  • hive中的笛卡尔积

    万次阅读 2018-08-27 16:14:22
    Hive本身是不支持笛卡尔积的,不能用select T1.*, T2.* from table_1, table_2这种语法。但有时候确实需要用到笛卡尔积的时候,可以用下面的语法来实现同样的效果: select T1.*, T2.* from (select * from table...
  • R语言中实现笛卡尔积的一个方法

    千次阅读 2016-08-01 16:41:49
    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)
  • List<String> list1 = new ArrayList(); list1.add(“A”); list1.add(“B”); list1.add(“C”); List<String> list2 = new ArrayList(); list2.add(“D”); list2.add(“E”);...输出:AD,AE,AF,BD
  • 笛卡尔积在数学上是一种二元关系,笛卡尔积作用的双方是两个集合,作用的结果是一个新的集合。 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_2$$a_3$则 $...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,274
精华内容 1,309
关键字:

向量笛卡尔积

友情链接: wm9712_wm9715.rar