标签: cartesian-product

我有两个矢量x和y,各自的长度n和p的.是否有内置的方法来创建一个np x 2矩阵

x[1] y[1]
x[1] y[2]
...
x[1] y[p]
x[2] y[1]
...
x[n] y[p]

我可以用嵌套的for循环来做到这一点,但我正在寻找一个内置函数,如果它存在的话.

如何使用Java 8实现一个函数来获取一些流,并生成一个流,其中每个元素都是一个由流的笛卡尔积的一个成员组成的列表？

我已经看过这个问题 - 这个问题使用了一个聚合器BinaryOperator(采用类似类型的两个项目并生成相同类型的项目).我希望最终结果中的项目是Lists而不是输入流中的元素类型.

具体地说,假设我调用product了我想要的函数,如下:

Stream<List<String>> result =
    product(
        Stream.of("A", "B", "C", "D"), 
        Stream.of("I", "J", "K),
        Stream.of("Y", "Z")
    );

result.forEach(System.out::println);

应该打印:

[A, I, Y]
[A, I, Z]
[A, J, Y]
[A, J, Z]
[A, K, Y]
[A, K, Z]
[B, I, Y]
...
[D, K, Y]
[D, K, Z]

理想情况下,我希望这个操作尽可能地懒惰.例如,如果输入流是由生成的Stream.generate(),那么如果这些流的供应商在绝对需要之前没有被执行,那就太好了.

考虑以下函数,其输出应该是一系列迭代的笛卡尔积:

def cart(*iterables):
    out = ((e,) for e in iterables[0])
    for iterable in iterables[1:]:
        out = (e1 + (e2,) for e1 in out for e2 in iterable)
    return out

当生成器理解被列表推导替换时,工作正常.当只有2个迭代时也可以工作.但是,当我尝试

print(list(cart([1, 2, 3], 'ab', [4, 5])))

我明白了

[(1, 4, 4), (1, 4, 5), (1, 5, 4), (1, 5, 5),
 (2, 4, 4), (2, 4, 5), (2, 5, 4), (2, 5, 5),
 (3, 4, 4), (3, 4, 5), (3, 5, 4), (3, 5, 5)]

为什么这个而不是笛卡儿产品？

因此，我正在编写一个函数allCoords，该函数返回宽度w和高度h两者的网格中每个可能坐标的列表，width并且height必须是非负整数才能返回合理的结果。

示例：allCoords 3 2应该返回[(0,0),(0,1),(0,2),(1,0),(1,1),(1,2)]

到目前为止，这就是我所拥有的，但我什至不知道如何开始编写函数

type GridCoord = (Int, Int)

allCoords :: Int -> Int -> [GridCoord]

假设我有以下数据库架构：

class A(Base):
    __tablename__ = "a_table"

    id = Column(Integer, primary_key=True, autoincrement=True)
    version = Column(Integer, primary_key=True, default=1)

    # More columns...

    bs = relationship(
        "B", secondary="a2b_table", back_populates="as"
    )

class B(Base):
    __tablename__ = "b_table"

    id = Column(Integer, primary_key=True)

    as = relationship(
        A, secondary="a2b_table", back_populates="bs"
    )

class A2B(Base):
    __tablename__ = "a2b_table"

    a_id = Column(
        Integer(),
        primary_key=True,
    )
    a_version = Column(
        Integer,
        primary_key=True,
    )
    b_id = sa.Column(
        Integer,
        ForeignKey("b.id", name="b_fk"),
        primary_key=True,
    )

    __table_args__ = (
        ForeignKeyConstraint(
            [a_id, a_version],
            [A.id, A.version],
            name="a_fk",
        ),
        {},
    )
    

每个 …

#!/usr/bin/python
#
# Description: I try to simplify the implementation of the thing below.
# Sets, such as (a,b,c), with irrelavant order are given. The goal is to
# simplify the messy "assignment", not sure of the term, below.
#
#
# QUESTION: How can you simplify it? 
#
# >>> a=['1','2','3']
# >>> b=['bc','b']
# >>> c=['#']
# >>> print([x+y+z for x in a for y in b for z in c])
# ['1bc#', '1b#', '2bc#', '2b#', '3bc#', '3b#'] …

甲骨文似乎不时更倾向于MERGE JOIN CARTESIAN常规操作MERGE JOIN.知道数据并查看具体的执行计划,我可以看到这个操作通常不是问题,因为其中一个连接的实体只能在手头的查询中返回一个记录.

但是,由于历史原因,我们的DBA对笛卡尔产品普遍不满意.

所以我想更好地分析这些案例,并在我的论证中备份文档.是否有关于查询转换和CBO的官方Oracle文档,我可以在其中了解Oracle更喜欢MERGE JOIN CARTESIAN(或类似)操作的情况？

在这种情况下,我正在使用Oracle 11g(11.2.0.2.0)

更新:

这些是类似的问题,但它们没有解释为什么或何时 Oracle更喜欢MJC常规MERGE JOIN:

• 为什么此查询会导致Oracle中的MERGE JOIN CARTESIAN？
• 为什么此查询会导致Oracle中的Merge Cartesian Join

假设我有一些有限集: A, B, ..., K

我也有A1, A2, ... AnA的子集; B1, B2, ... Bn这是B等的子集

让我们说S是笛卡尔积A x B x ... x K

并且Sn是笛卡儿的产品An x Bn x ... x Kn

有没有一种算法可以有效地确定所有联合Sn是否相等S？

编辑

我也在理论计算机科学论坛上问了这个问题.答案证明问题是完全可靠的.如果答案的作者想在这里发布,我仍然可以提出问题以奖励赏金.

我认为这个问题可以使用itertools或者笛卡尔来解决,但我对Python很新,我正在努力使用它们:

我有5个股票的投资组合,其中每个股票的权重可以是-0.4,-0.2,0,0.2或0.4,权重加起来为0.我如何创建一个函数来生成每个可能组合的列表权重.例如[-0.4,0.2,0,0.2,0] ......等

理想情况下,该功能适用​​于n种股票,因为我最终希望对50种股票进行相同的处理.

编辑:为了澄清,我正在寻找长度为n的所有组合(在这种情况下为5),求和为0. 值可以重复:例如:[0.2,0.2,-0.4,0,0],[0.4,0 ,-0.2,-0.2,0.4],[0,0,0,0.2,-0.2],[0,0.4,-0.4,0.2,-0.2]等.[0,0,0,0,0]将是一个可能的组合.有5个可能的权重和5个股票的事实是巧合(我应该避免!),同样的问题可能是5个可能的权重和3个股票或7个股票.谢谢.

我是关系代数中的一员,我无法完全理解笛卡尔积的工作原理.

我想知道当我的两个表具有共同属性时笛卡尔积中会发生什么.当两个表没有任何共同属性时,我没有任何问题需要理解.

例如,我试图理解我自己做的例子.

T1                          T2
----------                  -----------
A   B   C                   A    B   D
1   4   7                   1    4   8
2   5   3                   2    9   5
4   7   1                   7    3   2

如果我想做T1 x T2,当我想写第一行T1 A=1 , B=4 , C=7和第二行T2 的串联时, A=2 ,B=9 ,C=5A列和B列会发生什么？

如果你能告诉我T1 x T2的结果,那将非常有用!