Reinhard Männer's questions

A configuração:
Meu aplicativo tem uma função genérica que espelha pontualmente uma matriz quadrática de elementos arbitrários em seu centro:

func pointMirroredMatrix<T>(_ matrix: inout [[T]]) {
    assert(matrix.count > 0 && matrix[0].count > 0) // Ensure matrix is not empty
    assert(matrix.count == matrix[0].count) // Ensure matrix is quadratic
    let n = matrix.count // The matrix is n x n
    for row in 0 ..< n/2 {
        for col in 0 ..< n {
            // Swapping elements
            (matrix[row][col], matrix[n - 1 - row][n - 1 - col]) = (matrix[n - 1 - row][n - 1 - col], matrix[row][col])
        }
    }
}

Quero escrever um teste Swift que verifique se func pointMirroredMatrixfunciona corretamente.
Assim, defini primeiro:

typealias PointMirroredMatrixParams = (matrix: [[Any]], expectedResult: [[Any]])
let pointMirroredMatrixArgs: [PointMirroredMatrixParams] = [(matrix:         [[0, 1], [0, 0]], 
                                                             expectedResult: [[0, 0], [1, 0]])]

struct VisionTests {
    
    @Test("pointMirroredMatrix", arguments: pointMirroredMatrixArgs)
    func pointMirroredMatrix(p: PointMirroredMatrixParams) throws {
        // see below
    }  

Observe que os elementos da matriz são do tipo Any, porque @Testnão permite usar genéricos.
O teste deve fazer algo como o seguinte:

var mirroredMatrix = deepCopyMatrix(p.matrix) // Make deep copy
vision.pointMirroredMatrix(&mirroredMatrix) // Mirror the copy
let mirroredCorrectly = maticesAreEqual(p.expectedResult, mirroredMatrix)
#expect(mirroredCorrectly)  

O problema:
Não consigo escrever func maticesAreEqual, porque as matrizes passadas pelos parâmetros de teste são do tipo Any. Tentei o seguinte sem sucesso:

func maticesAreEqual(_ matrix1: [[Any]], _ matrix2: [[Any]]) -> Bool {
    guard matrix1.count == matrix2.count else { return false }
    guard matrix1[0].count == matrix2[0].count else { return false }
    guard !matrix1.isEmpty else { return true }
    guard type(of: matrix1[0][0]) == type(of: matrix2[0][0]) else { return false }
    guard type(of: matrix1[0][0]) == (any Equatable).self else { return false }
    // Here it is known that both matrices have the same dimension, their elements are of the same type and are equatable
    // But how to find out if they are equal?
    for i in 0 ..< matrix1.count {
        for j in 0 ..< matrix1[i].count {
            if matrix1[i][j] != matrix2[i][j] { return false } // Build error
        }
    }
    return true
}  

mas a instrução no loop interno não compila devido ao tipo Any. Eu recebo o erro Type 'Any' cannot conform to 'Collection'.

Minha pergunta:
Como posso testar func pointMirroredMatrixcom matrizes que possuem elementos de tipos diferentes, passados ​​por @Test?

Não entendo a seguinte situação:

let a1: [[Double]] = [[1]]
let equ1 = a1 == a1 // This builds

let t1: (Double, Double) = (1, 1)
let equ2 = t1 == t1 // This builds also

let a2: [[(Double, Double)]]  = [[(1,1)]]
let equ3 = a2 == a2 // This gives a build error

O erro de construção é

Binary operator '==' cannot be applied to two '[[(Double, Double)]]' operands  

Por que posso verificar a igualdade para uma matriz de dois dim de Double, para uma tupla de 2 Doubles, mas não para uma matriz de dois dim desta tupla?

Meu aplicativo usa uma classe Ae suas subclasses SubA_x. Apossui uma propriedade estática serialNumberque só é modificada pela classe Aquando uma subclasse é inicializada. Ele define uma propriedade let namepara que cada subclasse tenha um nome exclusivo. Aqui está o código:

class A {
    static var serialNumber = 0
    let name: String

    init( /* some parameters */ ) {
        A.serialNumber += 1
        self.name = "\(A.serialNumber)"
    }
}

final class SubA_1: A {
    init( /* some parameters */ ) {
        super.init( /* some parameters */ )
    }
}

Com a verificação estrita de simultaneidade do Swift 6, a linha onde serialNumberé inicializada fornece o erro

A propriedade estática 'serialNumber' não é segura para simultaneidade porque é um estado mutável compartilhado global não isolado

Entendo que cada subclasse Apode ser modificada var serialNumberem qualquer thread, portanto, corridas de dados são possíveis.

Mas como consigo essa funcionalidade de maneira segura para a simultaneidade?

Tentei fornecer serialNumberpor um ator:

actor SerialNumberManager {
    private var serialNumber = 0
    
    func getNextSerialNumber() -> Int {
        serialNumber += 1
        return serialNumber
    }
}

mas não consigo ligar getNextSerialNumber(), initexceto quando inité assíncrono. Mas então posso inicializar uma subclasse apenas em um contexto assíncrono, etc.

Provavelmente eu poderia fornecer minha própria sincronização baseada em GCD, mas deveria haver uma maneira de fazer isso dentro da simultaneidade do Swift.

Estou aprendendo Python3. Ele é executado no MacOS/Terminal executando python3.
Consegui executar alguns exemplos do livro "Deep Learning with Python, Second Edition", mas agora estou preso a um problema simples de editor:
Se eu inserir as seguintes instruções

>>> with tf.GradientTape as tape:
...     tape.watch(input_const)
...     result = tf.square(input_const)
... 

Não consigo encerrar o bloco de recuo.
Se eu simplesmente digitar return, recebo o erro

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: __enter__
>>> 

Tentei encerrar o recuo usando Shift [, Shift tabe Control [, mas isso não funciona.
Como faço para dedentar um bloco?

Encontrei uma pergunta semelhante aqui , mas sem solução.

Meu aplicativo possui uma matriz handde uma estrutura com uma propriedade let blatt: Image. Durante init, an Imageé atribuído a esta propriedade.

Para exibir tal array horizontalmente, eu uso o seguinte código ( scaledWidthé alguma constante):

HStack(spacing: 10) {
    ForEach((0 ..< hand.count), id: \.self) {
        hand[$0].blatt
            .resizable()
            .scaledToFit() 
            .frame(height: scaledWidth)
            .border(.black)
    }
}

Isso fornece a seguinte saída:

Isso é o que eu esperava.

Outra matriz deve ser exibida verticalmente. Para isso, estou utilizando o seguinte código:

VStack(spacing: 10) {
    ForEach((0 ..< hand.count), id: \.self) {
        hand[$0].blatt
            .resizable()
            .scaledToFit() 
            .rotationEffect(Angle(degrees: 90))
            .frame(width: scaledWidth, height: scaledWidth)
            .border(.black)
    }
}

Isso fornece adicionalmente a seguinte saída:

Aqui, a altura de cada quadro, indicada pelo quadro com borda, é a altura da imagem não girada.

Como conheço a proporção aspectRatioBlattdas imagens, posso ajustar a saída usando .frame(width: scaledWidth, height: scaledWidth / aspectRatioBlatt). Então, os quadros têm as dimensões corretas e o espaçamento correto, mas as imagens internas são muito pequenas. Novamente, a altura do quadro é igual à altura da imagem interna não girada.

Tentei muitos modificadores de visualização e várias combinações, mas falhei. Até tentei usar um layout personalizado como sugerido aqui para o Text vertical , mas também não funcionou.
Claro que eu poderia usar um segundo conjunto de imagens transformadas, mas deveria ser possível sem ele no SwiftUI.

Como fazer certo?

Eu quero produzir algum texto em todos os 4 lados da exibição. Este é o meu código:

   var body: some View {
        Spacer()
        Text("AA BB CC DD EE FF GG HH")
        Spacer()
        HStack {
            Text("AA BB CC DD EE FF GG HH").rotationEffect(Angle(degrees: -90))
            Spacer()
            Text("AA BB CC DD EE FF GG HH").rotationEffect(Angle(degrees: 90))
        }.frame(height: 200)
        Spacer()
        Text("AA BB CC DD EE FF GG HH")
        Spacer()
    }
}

e esta é a saída:

Questões:

• Por que o texto é quebrado à esquerda, mas o mesmo texto não? E como posso evitar embrulhar?
• Por que o texto deixou uma margem diferente da direita do texto? E como posso torná-los iguais?