标签: symmetric

我有一个C#类型,从逻辑比较来比较与int的相等性.叫这种类型Number.

但是,我不能使Equals对称,因为我无法改变Int32.Equals(object other).那么,我应该允许非对称相等,如下所示:

Number numberThree = new Number(3);
int intThree = 3;

bool equal;
equal = numberThree.Equals(intThree); // equal is true
equal = intThree.Equals(numberThree); // equal is false

或者,如果类型匹配以及数值,我应该只允许相等吗？

我有一个矩阵如下;

   1  2  3  4  5  
1  0  1  1  0  0  
2  0  0  1  1  0  
3  1  0  0  0  1  
4  0  0  1  0  0   
5  0  1  0  0  0  

我需要得到对称矩阵如下,对角线0;

   1  2  3  4  5  
1  0  1  1  0  0  
2  1  0  1  1  1  
3  1  1  0  1  1  
4  0  1  1  0  0   
5  0  1  1  0  0  

我用for循环尝试了它,当矩阵的大小很小时它很好.但对于大尺寸,需要时间.在R中有没有有效的方法呢？

编辑:第一行在第二和第三列中有1,第一行在第三行中有1.但是对称的第一列也需要在第二行中有1个.类似地,每个行和列应该考虑1来维持对称矩阵.

我想在R中测试矩阵是否为正定.我使用R函数is.positive.definite但是仍然得到以下错误消息,尽管我的矩阵是对称的函数isSymmetric显示.这是因为舍入错误吗？

Error in is.positive.definite(S) : argument x is not a symmetric matrix

我的工作代码附在下面.有人可以帮帮我吗？谢谢.

library(Matrix) # isSymmetric
library(matrixcalc) # is.positive.definite
library(expm) # sqrtm

###################################################################################################

theta0 <- c(0.2, 10)

###################################################################################################

OS.mean <- function(shape, rank, n=10){
  term1 <- factorial(n)/(factorial(rank-1)*factorial(n-rank))
  term2 <- beta(n-rank+1, rank) - beta(n-rank+shape+1, rank)
  term1*term2/shape
}

OS.mean.theta0.10 <- as.matrix(OS.mean(theta0[1], rank=seq(1, 10, by=1)))

###################################################################################################

OSsq.mean <- function(shape, rank, n=10){
  term1 <- factorial(n)/(factorial(rank-1)*factorial(n-rank))
  term2 <- beta(n-rank+1, rank) - 2*beta(n-rank+shape+1, rank) + beta(n-rank+2*shape+1, rank)
  term1*term2/(shape*shape)
}

OSsq.mean.theta0.10 <- as.matrix(OSsq.mean(theta0[1], rank=seq(1, …

我正在尝试使用 R 制作一个对称矩阵。我已经有了一个矩阵。我的矩阵非常大，所以下面是一个简单的例子。

前任。

1 2 3

4 5 6

7 8 9

我需要让它们像这样。

1 2+4 3+7

4+2 5 6+8

7+3 8+6 9

//所以我尝试了这个。// mat 是我正在使用的矩阵。

lowervector <- square_07[lower.tri(square_07, diag = FALSE)]

uppervector <- square_07[upper.tri(square_07, diag = FALSE)]

lowermat <- square_07 uppermat <- square_07

lowermat[lower.tri(lowermat, diag = FALSE)] <- t(square_07)[lower.tri(square_07, diag = FALSE)]

uppermat[upper.tri(uppermat, diag = FALSE)] <- t(square_07)[upper.tri(square_07, diag = FALSE)]

当我执行最后两行时，出现错误；

下标 'upper.tri(uppermat, diag = FALSE)' 是一个矩阵，数据 't[upper.tri(square_07, diag = FALSE)]' 的大小必须为 1。

你应该知道。上面的矩阵只是一个例子。我的实际矩阵要大得多。它是一个248*248的矩阵。

我怎么解决这个问题？

我有这个标记:

<div class="container">
   <figure></figure>   
   <figure></figure>
   <figure></figure>
</div>

现在:我需要为每个figures对称元素添加,但具有不同的高度和宽度值.对于下一个项目,我需要删除大约10%的宽度和高度.因此,第一个具有90%,第二个具有80%,第三个具有70%的初始尺寸.我使用以下代码,但它不起作用,有人可以帮忙吗？

var inside_element = $(figure);
var indx = 10;
inside_element.each(function(indx){
    $(this).css({
        width: '90%' - indx,
        height: '90%' - indx
    });
});

谢谢.

我有一张这样的桌子:

_id sender_id receiver_id text
1   1         2           xxx
2   2         1           yyy
3   1         2           xyz
4   3         1           abc

我需要对sender_id和receiver_id列进行GROUP BY ,但它应该是对称的,因此{1,2}和{2,1}应该被视为同一个组.

此查询可以在随机DBMS上执行,因此它应尽可能最标准.

因此该函数应检查列表是否对称; 如果列表为空或具有一个整数,则它是对称的.

否则,该函数应检查第一个和最后一个整数是否相同并以递归方式继续.如果没有,请返回False.

代码似乎是正确的,但我无法弄清楚什么是错的以及为什么它不会返回False.

def symm(lst):

    t = len(lst)
    if t == 0 or 1:
        return True

    if t>1:
        if lst[0] == lst[-1]:
            return symm(lst[1:-2])
        else:
            return False

print symm([6,6,6,6,7])

比方说，我有一个对称矩阵A，例如

> A <- matrix(runif(16),nrow = 4,byrow = T)
> ind <- lower.tri(A)
> A[ind] <- t(A)[ind]
> A
          [,1]      [,2]      [,3]       [,4]
[1,] 0.4212778 0.6874073 0.1551896 0.46757640
[2,] 0.6874073 0.5610995 0.1779030 0.54072946
[3,] 0.1551896 0.1779030 0.9515304 0.79429777
[4,] 0.4675764 0.5407295 0.7942978 0.01206526

我也有一个4 x 3矩阵B，给出矩阵的特定位置A，例如：

> B<-matrix(c(1,2,4,2,1,3,3,2,4,4,1,3),nrow=4,byrow = T)
> B
      [,1] [,2] [,3]
[1,]    1    2    4
[2,]    2    1    3
[3,]    3    2    4
[4,]    4    1    3

的 …

有没有办法测试任意列表是否对称？

例如:

?- symmetric([a,b,b,a]).
true.

?- symmetric([a,b,c,a]).
false.

?- symmetric([a,a]).
true.

我的尝试是将第一个元素与最后一个元素进行比较,如果它们相等则删除它们并继续执行列表的其余部分; 否则失败.如果列表有2个元素且它们相等,则成功.否则失败.

但是,使用此谓词"查找"列表的结尾并不是真正的高效:

last(L,[L]).
last(L,[H|T]):-last(L,T).

有谁知道这样做的好方法？真的很感激任何帮助!

顺便说一句:我不关心元素数量不均的列表.

请告诉我们 Rijndael 对称加密算法的安全性。密钥存储在 Web 配置文件中。