Question

我正在尝试使用矩阵代数来操纵字符串。这意味着能够使用字符串或字符串数组的连接和粘贴来实现多个类似矩阵的结构。

我之前曾试图在R上实现这个东西，但由于矩阵只能有一个维度条目，所以不可能。

我希望能够与语言无关并且抽象，但为了清晰起见，我将使用类似R的代码。我应该明确指出我不需要真正的矩阵，而是矩阵式结构，我们可以在其上进行矩阵式乘法并检索结构的（ij）元素。

{+，*} MATRICES MULTIPLICATION

维度n的两个方阵 A 和 B 的{+，*} - 乘积是由元素定义的矩阵 C ： C _i，j = Sum _{k = 1，...，n} A _{i， k} * B _k，j。

例如，考虑矩阵M <- matrix(c(a,b,0,0,c,d,0,0,e),3,3)。那么M次M是M <- matrix(c(a^2,a*b+b*c,b*d,0,c^2,c*d+d*e,0,0,e^2),3,3)。

{c（，），paste0（，）} MATRICES MULTIPLICATION

我想要实现的这个操作的规则与先前所述的乘法相同，其中基本突变是总和应该是串联，并且产品应该是粘贴。换句话说，在上一个公式中我们找到了a+b，现在输出应该是“c（a，b）”，当我们找到a*b时，现在我们应该将其读作{{1} }}

必须遵守一些常用属性，即分布属性和0元素属性。因此，如果paste0(a,b)和a <- c("q",0,"w")然后b <- c("e")（我们应该自由地忘记0元素，删除它不会影响计算。

此外，我们乘以等尺寸矩阵，因此每个元素 C _i，j = Sum _{k = 1，...，n} A _i，k * B _k，j现在读作a*b <- c("qe",0,"we")

最后，结果矩阵式结构应该是我们可以再次用于计算的东西（例如，将更复杂的计算作为多（mult（A，B），C）等等）。

简单案例

为简单起见，让我们从c("A[i,1]B[1,j]",...,"A[i,n]B[n,j]")，mult(A,A)等形式的产品计算开始。我们也可以将 A 强加为简单矩阵，这意味着它的每个元素都是一维字符串，而不是字符串的连接。

我们举个例子。让我们 A 定义为mult(mult(A,A),A)的3维矩阵，然后 A 乘以 A 的乘法应为A <- matrix(c("a","b",0,0,"c","d",0,0,"e"),3,3) A ³应为mult(A,A) = matrix(c("aa",c("ab","bc"),"bd",0,"cc",c("cd","de"),0,0,"ee"),3,3)。

问题

你会如何实现这个？哪种语言更合适？

Answer 1

以下是R中符号多重矩阵的一些想法：

首先，我们需要定义行和列的内积。这可以通过以下方式完成：

wrap <- function(x) paste0("(",x,")")

rowcol <- function(row,col) paste(wrap(row),wrap(col),sep="*",collapse="+")

示例：

> rowcol(c("A","B","C"),c("D","E","F"))
[1] "(A)*(D)+(B)*(E)+(C)*(F)"

我必须在括号中“包裹”每个元素，因为大于2的幂可能比单个变量或数字（零）具有更复杂的表达式。另外，请注意零将正常显示，即，它不知道（还）可以简化这些：

> rowcol(c("A","B"),c("0","X+Y"))
[1] "(A)*(0)+(B)*(X+Y)"

由于这些是R中的有效表达式，因此可以使用此事实来编写简化函数来消除零和冗余括号。我会到那儿。

现在矩阵乘法和幂只是：

symprod <- function(A,B) sapply(1:ncol(B), function(j)sapply(1:nrow(A), function(i)rowcol(A[i,],B[,j])))

sympow <- function(A,n) { B <- A; for( i in seq_len(n-1) ) B <- symprod(B,A); B }

他们创建有效（虽然笨拙）的表达式：

> A <- matrix(LETTERS[1:4],2,2)
> diag(A) <- 0
> sympow(A,3)
     [,1]                                          [,2]                                         
[1,] "((0)*(0)+(C)*(B))*(0)+((0)*(C)+(C)*(0))*(B)" "((0)*(0)+(C)*(B))*(C)+((0)*(C)+(C)*(0))*(0)"
[2,] "((B)*(0)+(0)*(B))*(0)+((B)*(C)+(0)*(0))*(B)" "((B)*(0)+(0)*(B))*(C)+((B)*(C)+(0)*(0))*(0)"

现在让我们谈谈简化。这些字符串可以解析为有效的R表达式，因为它们符合R标准。不需要定义变量，因为我们不打算评估表达式。实际上我只想解析它们以简化简化。

检查以下功能。它删除多余的括号，用零替换零次，并删除零的包裹（另外）：

simplify <- function(e)
{
    if( mode(e) %in% c("name","numeric") ) return(e)

    if( as.character(e[[1]])=="+" )
    {
        x <- simplify(e[[2]])

        y <- simplify(e[[3]])

        if( identical(x,0) ) return(y)

        if( identical(y,0) ) return(x)

        return(call("+", x, y))
    }

    if( as.character(e[[1]])=="*" )
    {
        x <- simplify(e[[2]])

        if( identical(x,0) ) return(0)

        y <- simplify(e[[3]])

        if( identical(y,0) ) return(0)

        return(call("*", x, y))
    }

    if( as.character(e[[1]])=="(" )
    {
        x <- simplify(e[[2]])

        if( mode(x) %in% c("name","numeric") ) return(x)

        return(call("(", x))
    }
}

此函数适用于call对象。要使用字符串，我们需要

simplify_text <- function(s) deparse(simplify(parse(text=s)[[1]]))

示例：

> simplify_text("(x)+(0*(a+b))+(z)")
[1] "x + z"

如果需要，可以将其用作rowcol：

的包装

rowcol <- function(row,col) simplify_text(paste(wrap(row),wrap(col),sep="*",collapse="+"))

结果是：

> sympow(A,3)
     [,1]          [,2]         
[1,] "0"           "(C * B) * C"
[2,] "(B * C) * B" "0"

可以编写其他一些简化，这取决于计划如何使用它们。但是，如果输入矩阵是有效表达式的字符串，则最终结果仍然有效。

编辑：rowcol的另一个approch：

考虑以下功能：

cellprod <- function(r, s)
{
    z <- expand.grid(r,s, stringsAsFactors=FALSE)

    filter <- (z$Var1 != 0) & (z$Var2 != 0)

    paste(z$Var1[filter], z$Var2[filter], sep="*", collapse="+")
}

rowcol <- function(row,col)
{
    x <- strsplit(row, "\\+")

    y <- strsplit(col, "\\+")

    L <- vapply(seq_along(x), function(i) cellprod(x[[i]],y[[i]]), character(1))

    filter <- nzchar(L)

    if( ! any(filter) ) return("0")

    paste(L[filter], collapse="+")
}

使用这些函数而不是上面的函数，我们可以处理表达式为x*y*z+a*b+f，i的矩阵。例如，每个单元格中的产品总和。这些函数自动应用分布律，保留形式（产品总和）并自动删除零。上面的最后一个例子变成：

> sympow(A,3)
     [,1]    [,2]   
[1,] "0"     "C*B*C"
[2,] "B*C*B" "0"

不需要简化！另一个例子：

> A <- matrix(LETTERS[1:9],3,3)
> B <- matrix(LETTERS[10:18],3,3)
> A[2,3] <- 0
> A[3,2] <- 0
> B[1,3] <- 0
> B[3,1] <- 0
> A
     [,1] [,2] [,3]
[1,] "A"  "D"  "G" 
[2,] "B"  "E"  "0" 
[3,] "C"  "0"  "I" 
> B
     [,1] [,2] [,3]
[1,] "J"  "M"  "0" 
[2,] "K"  "N"  "Q" 
[3,] "0"  "O"  "R"
> symprod(A,B)
     [,1]      [,2]          [,3]     
[1,] "A*J+D*K" "A*M+D*N+G*O" "D*Q+G*R"
[2,] "B*J+E*K" "B*M+E*N"     "E*Q"    
[3,] "C*J"     "C*M+I*O"     "I*R"

使用矩阵代数来操纵字符串：它可行吗？

1 个答案: