相关疑难解决方法(0)

您是否知道一些简洁的Java库,允许您制作两个(或更多)集的笛卡尔积？

例如:我有三套.一个是Person类的对象,第二个是类Gift的对象,第三个是GiftExtension类的对象.

我想生成一个包含所有可能的三元组Person-Gift-GiftExtension的集合.

集的数量可能会有所不同,所以我不能在嵌套的foreach循环中执行此操作.在某些情况下,我的应用程序需要制作一个Person-Gift对的产品,有时它是三人Person-Gift-GiftExtension,有时甚至可能会设置Person-Gift-GiftExtension-GiftSecondExtension-GiftThirdExtension等.

我想生成给定数量的向量的元素的所有可能组合.

例如,对于[1 2],[1 2]和[4 5]我想要生成的元素:

[1 1 4; 1 1 5; 1 2 4; 1 2 5; 2 1 4; 2 1 5; 2 2 4; 2 2 5]

问题是我不知道我需要计算组合的向量的数量.在这种情况下可能有3个,或者可能有10个,我需要一个概括.你能帮我在MATLAB中帮助我吗？是否已有可以执行此任务的预定义功能？

在MATLAB中转置向量/矩阵时,我已经看过并使用了'(撇号)运算符很长一段时间.

例如:

>> v = [ 1 2 3 ]'

v = 

    1
    2
    3

然而,这是我最近发现的共轭转置,或者ctranspose.

这似乎只涉及涉及复杂数字的情况,如果您想要转换矩阵而不获取共轭,则需要使用.'opertator.

那么使用.'真实矩阵和向量是否是好习惯？我们应该怎样教MATLAB初学者？

我有以下问题.我需要重现0和1的所有独特组合,包括正好m个零和正好n个.例如,如果我有2个零和3个,我正在寻找的组合是以下10个:

1)0 0 1 1 1

2)0 1 0 1 1

3)0 1 1 0 1

4)0 1 1 1 0

5)1 0 0 1 1

6)1 0 1 0 1

7)1 0 1 1 0

8)1 1 0 0 1

9)1 1 0 1 0

10)1 1 1 0 0

现在,我使用A = perms([0 0 1 1 1])然后使用唯一(A,'rows')但如果向量的长度大于10,这实在是非常耗时.任何人都可以想到更高效的解决方案

我有一个代码,可以生成0到36之间4个整数的所有可能组合.

这将是37 ^ 4个数字= 1874161.

我的代码是用MATLAB编写的:

i=0;
for a = 0:36
    for b= 0:36
        for c = 0:36
            for d = 0:36
                i=i+1;
                combination(i,:) = [a,b,c,d];             
            end          
        end
    end
end

我用数字3而不是数字来测试这个,36它运行正常.

如果有1874161个组合,并且An过度警告猜测100个时钟周期来进行添加并写入值,那么如果我有一个2.3GHz的PC,那么:

1874161*(1/2300000000)*100 = 0.08148526086

几分之一秒.但到目前为止它已经运行了大约半个小时.

我确实收到了一个警告combination changes size every loop iteration, consider predefining its size for speed,但这不能影响那么多吗？

在MATLAB中,我有一个长度为n的向量x,其中n通常是O(10),我想构建一个大小为[n ^ m,m]的高矩阵A,其中m再次为0(10).矩阵具有一种特殊的形式:如果n = 4且m = 6,则让

x=[x1; x2; x3; x4]

那么A是

   x1 x1 x1 x1 x1 x1
   x2 x1 x1 x1 x1 x1
   x3 x1 x1 x1 x1 x1
   x4 x1 x1 x1 x1 x1
   x1 x2 x1 x1 x1 x1
   x2 x2 x1 x1 x1 x1
   x3 x2 x1 x1 x1 x1
   x4 x2 x1 x1 x1 x1
   x1 x3 x2 x1 x1 x1
   .               .         
   .               . 
   .               .
   x4 x4 x4 x4 x4 x4

实际上,每列都是通过重复x的元素获得的,每列的步幅越来越大.我怎样才能做到这一点？如果可能的话,我更喜欢有效的(矢量化)解决方案,因为正如您所看到的,A的行数随m呈指数增长.非常感谢,

塞尔吉奥 …

我有一个参数列表,我需要在此列表中评估我的方法.现在,我这样做

% Parameters
params.corrAs = {'objective', 'constraint'};
params.size = {'small', 'medium', 'large'};
params.density = {'uniform', 'non-uniform'};
params.k = {3,4,5,6};
params.constraintP = {'identity', 'none'};
params.Npoints_perJ = {2, 3};
params.sampling = {'hks', 'fps'};   

% Select the current parameter
for corrAs_iter = params.corrAs
    for size_iter = params.size
        for density_iter = params.density
            for k_iter = params.k
                for constraintP_iter = params.constraintP
                    for Npoints_perJ_iter = params.Npoints_perJ
                        for sampling_iter = params.sampling
                            currentParam.corrAs = corrAs_iter;
                            currentParam.size = size_iter;
                            currentParam.density = density_iter;
                            currentParam.k = k_iter;
                            currentParam.constraintP = constraintP_iter;
                            currentParam.Npoints_perJ …

UPD:我想对StackOverflow社区提出问题表示抱歉,他自己提出问题而没有努力解决问题.从现在开始,只有在我真的遇到严重问题时才会提问

我现在正在开发生成字符串元素的所有可能排列的程序:

我开始时:

A = ['Bridge','No Bridge'];
B = ['Asphalt','Concrete','Combined'];
C = ['Fly Ash',' Sulphur','Nothing'];
D = ['Two lanes','Four lanes with barriers'];
E = ['Paid','Non-paid'];
F = ['Mobile','Non-mobile'];
N = length(A)*length(B)*length(C)*length(D)*length(E)*length(F);
out = zeros(N,6);

但现在我仍然坚持下一步该做什么.所需的输出类似于:

out = 

    'Bridge' 'Asphalt' 'Fly Ash' 'Two lanes' 'Paid' 'Mobile'
    'Bridge' 'Asphalt' 'Fly Ash' 'Two lanes' 'Paid' 'Non-mobile'
    'Bridge' 'Asphalt' 'Fly Ash' 'Two lanes' 'Non-paid' 'Mobile'
    'Bridge' 'Asphalt' 'Fly Ash' 'Two lanes' 'Non-paid' 'Non-mobile' etc

拜托,您能建议最有效的方法吗？

假设我们有2 x N形式的矩阵

A=| a1 a2 ... aN |
  | b1 b2 ... bN |

有2 ^ N种组合如何重新排列行.我想找到B包含所有组合的矩阵.

%% N=2
B=|a1 a2|
  |a1 b2|
  |b1 a2|
  |b1 b2|
%% N=3
B=|a1 a2 a3|
  |a1 a2 b3|
  |a1 b2 a3|
  |a1 b2 b3|
  |b1 a2 a3|
  |b1 a2 b3|
  |b1 b2 a3|
  |b1 b2 b3|

这与用于学习布尔代数基础知识的表(ai = 0,bi = 1)非常相似.

这个问题可能会扩展到创建M^N x N矩阵M x N.