标签: diagonal

我一直试图弄清楚如何在applet窗口中对角线移动可见图像.

如果按向上,向下,向左或向右按​​下图像(gif)会相应移动,但是如果您尝试同时按下两个键(例如同时向上和向右),图像只会按您按下的方向移动第二(即使你同时按下按键仍有微观延迟).

可能有一种简单的方法可以解决这个问题,我只是不知道,或者某个人已经想到了解决方法......我感谢任何帮助或建议.

谢谢

英雄级(这个类定义了"英雄"是什么;在这种情况下是一个简单的像素人,他能做什么)

import objectdraw.*;
import java.awt.*;

public class Hero extends ActiveObject {

private DrawingCanvas canvas;
private VisibleImage player;

public Hero(Location initLocation, Image playerPic, DrawingCanvas aCanvas) {
canvas = aCanvas;

player = new VisibleImage(playerPic, canvas.getWidth()/3,
         canvas.getWidth()/3, canvas);
start();

}
public void run() 
{

}

public void move(double dx, double dy) 
{
player.move(dx, dy);
}
}

HeroGame类(此类创建"Hero"并指定位置,以及用于移动的键)

import objectdraw.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class HeroGame extends WindowController implements KeyListener {
private Hero theHero;
private Image playerPic; …

嗨,我想画这样的东西

形状有可能吗？

我想创建一个矩阵,其中中间对角线对称地减少到两侧,如下所示:

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

矩阵必须是100x100,值介于0和之间1.到目前为止,我只得到边缘和中间对角线,但无法了解如何自动填充其余部分.

v = ones(1,100);
green = diag(v);
green(:,1) = fliplr(0:1/99:1);
green(1,:) = fliplr(0:1/99:1);
green(100,:) = 0:1/99:1;
green(:,100) = 0:1/99:1;

我有一个Eigen::MatrixXd,我需要修改其对角线元素的值.特别是我有另一个Eigen::MatrixXd有一个单独的列和第一个矩阵的相同行数.

我需要减去第一个矩阵的对角线,第二个矩阵的元素的值.

例:

A
 1 2 3
 4 5 6
 7 8 9

B
 1
 1
 1


A'
 0 2 3
 4 4 6
 7 8 8

我能怎么做？

给定维度为 MxN 的矩阵 X。我想为 X 的每一行创建一个对角矩阵。结果应为 MxNxN。如何高效地做到这一点？谢谢你！

我惊讶地发现不可能简单地将 an 添加Eigen::DiagonalMatrix到 an Eigen::SparseMatrix：

#include <Eigen/Core>
#include <Eigen/Sparse>

int main()
{
  Eigen::Matrix4d M;
  M<<1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16;
  Eigen::SparseMatrix<double> S = M.sparseView();
  Eigen::DiagonalMatrix<double,Eigen::Dynamic> D = 
    Eigen::VectorXd::LinSpaced(4,1,4).asDiagonal();
  Eigen::SparseMatrix<double> T = D+S;
}

不会编译：

 error: invalid operands to binary expression ('Eigen::DiagonalMatrix<double, Eigen::Dynamic>' and 'Eigen::SparseMatrix<double>')
  Eigen::SparseMatrix<double> T = D+S;

似乎在 Eigen 3.3 中我可以使用：

  T.diagonal() = D.diagonal() + T.diagonal();

但这不适用于较旧（更稳定）的 Eigen 3.2.*：

error: no viable overloaded '='
  T.diagonal() = D.diagonal() + T.diagonal();

我真的必须遍历条目并一一插入吗？

 Eigen::SparseMatrix<double> T = S;
 for(int i = 0;i<T.rows();i++) T.coeffRef(i,i) += D.diagonal()(i); …

对于我正在开发的网站，我需要在上添加一些对角线形的边框div。这些是我需要重新创建的主要示例。

双对角线顶部边框，三角形

现在正在网上搜索如何实现此目的，我的第一个想法就是使用::before。但是，如果没有将其定位为绝对位置（弄乱整个页面），我将无法使其正常工作。

这是我尝试实现的代码：

.slider-container{
  background-color: $blue;
  width: 100%;
  overflow: hidden;
  position: relative;
  .col-md-3{
    img{
      padding: 40px;
      width: 100%;
      max-width: 400px;
      margin: auto;
    }
  }
  &::before {
    background: red;
    bottom: 100%;
    content: '';
    display: block;
    height: 100%;
    position: absolute;
    right: 0;
    transform-origin: 100% 100%;
    transform: rotate(-15deg);
    width: 150%;
  }
}

<section id="slider">
    <div class="container-fluid">
        <div class="row slider-container">
            <div class="col-md-3">
                <p>imgae 1</p>
            </div>
            <div class="col-md-3">
                <p>imgae 2</p>
            </div>
            <div class="col-md-3">
                <p>imgae 3</p>
            </div>
            <div class="col-md-3">
                <p>imgae 4</p> …

我在类似主题上发布了一个问题，并遇到了另一个更重要的问题。

当我将 SVD 应用于矩阵“A”（下面的代码）时，我得到的输出是预期的二维特征向量矩阵（“U”和“V”）和意外的一维奇异值数组“S”。

U,S,V=np.linalg.svd(A)

对于上下文：它出乎意料的原因是奇异值分解应该产生三个矩阵的乘积。中间矩阵（在本例中为一维数组）应该是对角矩阵，以降序保存非负奇异值。

为什么 Python 将矩阵“转换”为数组？有办法解决吗？

谢谢！

我正在尝试从原始形状重塑数组，以使每一行的元素沿对角线下降：

np.random.seed(0) 
my_array = np.random.randint(1, 50, size=(5, 3))

array([[45, 48,  1],
       [ 4,  4, 40],
       [10, 20, 22],
       [37, 24,  7],
       [25, 25, 13]])

我希望结果如下所示：

my_array_2 = np.array([[45,  0,  0],
                       [ 4, 48,  0],
                       [10,  4,  1],
                       [37, 20, 40],
                       [25, 24, 22],
                       [ 0, 25,  7],
                       [ 0,  0, 13]])

这是我能得到的最接近的解决方案：

my_diag = []
for i in range(len(my_array)):
    my_diag_ = np.diag(my_array[i], k=0)
    my_diag.append(my_diag_)
my_array1 = np.vstack(my_diag)

array([[45,  0,  0],
       [ 0, 48,  0],
       [ 0,  0,  1],
       [ 4, …

我有一串代表方形网格的布尔值。

0100001110000100

我正在尝试编写验证例程，该例程对角线检查网格，以确保其中不存在具有多个“1”值的对角线。

从这个例子中可以看出，第五组有两个。

为了做到这一点，我想将网格排列成集合，然后检查每个集合以查看它是否具有多个“1”值。

下面显示的是排列为集合的值，以及每个值在原始字符串中的位置。

0       0  
01      4  1
100     8  5  2
0010    12 9  6 3
101     13 10 7
00      14 11 
0       15 

我一直在试图找出字符串位置和它属于哪个组之间的数学关系。我尝试过各种公式，但我数学不太好，所以我被难住了。

作为参考，下面的方法是我用来水平验证字符串的方法。我想要提出的解决方案需要像这样，使用 LINQ 和基于集合的操作，而不是使用许多尴尬的循环。我正在进行的练习是关于在风电场中放置涡轮机的代码套路。

    public bool HorizontalValidate(string windfarm)
    {
        var farmSize = (int) Math.Sqrt(windfarm.Length);

        var rows = Enumerable.Range(0, farmSize)
            .Select(x => windfarm.Substring(x * farmSize, farmSize))
            .ToList();

        if (rows.Select(x => x.Count(y => y == '+')).Max() > 1)
            return false;

        return true;
    }

如果有人感兴趣，这里有一个链接： Windfarm Kata