Perguntas[math](coding)

Estou usando o Cairo Graphics junto com o RichClient6 (que é um wrapper), mas acredito que esse fato não seja tão importante.

Preciso obter as extensões de um caminho. Isso funciona bem, mas não quando a matriz é rotacionada. Não entendo o que acontece neste caso, e ainda não consegui resolver sozinho.

Gostaria de perguntar se alguém vê o que preciso fazer de diferente para obter as extensões de forma confiável, mesmo quando a matriz é rotacionada.

Obrigado.

Aqui estão algumas saídas que mostram como as extensões mudam:

Angle: 1, Path Extents:    -2,8         -6     343,8         169 
Angle: 2, Path Extents:    -5,7         -11,9   346,7        174,9 
Angle: 3, Path Extents:    -8,5         -17,8   349,5        180,8 
Angle: 4, Path Extents:    -11,3         -23,7  352,3        186,7 
Angle: 5, Path Extents:    -14,2         -29,6  355,2        192,6 
Angle: 6, Path Extents:    -16,9         -35,4  357,9        198,4 
Angle: 7, Path Extents:    -19,7         -41,2  360,7        204,2 
Angle: 8, Path Extents:    -22,5         -47    363,5        210 
Angle: 9, Path Extents:    -25,2         -52,7  366,2        215,7 
Angle: 10, Path Extents:   -27,9         -58,3  368,9       221,3 
Angle: 11, Path Extents:   -30,5         -63,9  371,5       226,9 
Angle: 12, Path Extents:   -33,2         -69,4  374,1       232,3 
Angle: 13, Path Extents:   -35,7         -74,7  376,7       237,7 
Angle: 14, Path Extents:   -38,3         -80    379,3        243 
Angle: 15, Path Extents:   -40,7         -85,2  381,7       248,3 
Angle: 16, Path Extents:   -43,2         -90,4  384,2       253,4 
Angle: 17, Path Extents:   -45,6         -95,3  386,6       258,3 
Angle: 18, Path Extents:   -47,9         -100,2           388,9  263,2 
Angle: 19, Path Extents:   -50,2         -105  391,2        268 
Angle: 20, Path Extents:   -52,4         -109,6           393,4  272,6 
Angle: 21, Path Extents:   -54,5         -114,1           395,5  277,1 
Angle: 22, Path Extents:   -56,6         -118,4           397,6  281,4 
Angle: 23, Path Extents:   -58,6         -122,6           399,6  285,6 
Angle: 24, Path Extents:   -60,6         -126,7           401,6  289,7 
Angle: 25, Path Extents:   -62,4         -130,6           403,4  293,6 
Angle: 26, Path Extents:   -64,2         -134,4           405,2  297,4 
Angle: 27, Path Extents:   -65,9         -137,9           406,9  300,9 
Angle: 28, Path Extents:   -67,6         -141,4           408,6  304,4 
Angle: 29, Path Extents:   -69,1         -144,6           410,1  307,6 
Angle: 30, Path Extents:   -70,6         -147,7           411,6  310,7 
Angle: 31, Path Extents:   -72          -150,5  413        313,5 
Angle: 32, Path Extents:   -73,3         -153,2           414,3  316,2 
Angle: 33, Path Extents:   -74,5         -155,8           415,5  318,8 
Angle: 34, Path Extents:   -75,6         -158,1           416,6  321,1 
Angle: 35, Path Extents:   -76,6         -160,2           417,6  323,2 
Angle: 36, Path Extents:   -77,5         -162,2           418,5  325,2 
Angle: 37, Path Extents:   -78,3         -163,9           419,3  326,9 
Angle: 38, Path Extents:   -79,1         -165,4           420,1  328,4 
Angle: 39, Path Extents:   -79,7         -166,8           420,7  329,8 
Angle: 40, Path Extents:   -80,3         -167,9           421,3  330,9 
Angle: 41, Path Extents:   -80,7         -168,8           421,7  331,8 
Angle: 42, Path Extents:   -81,1         -169,6           422,1  332,6 
Angle: 43, Path Extents:   -81,3         -170,1           422,3  333,1 
Angle: 44, Path Extents:   -81,5         -170,4           422,5  333,4 
Angle: 45, Path Extents:   -81,5         -170,5           422,5  333,5 
Angle: 46, Path Extents:   -81,5         -170,4           422,5  333,4 
Angle: 47, Path Extents:   -81,3         -170,1           422,3  333,1 
Angle: 48, Path Extents:   -81,1         -169,6           422,1  332,6 
Angle: 49, Path Extents:   -80,7         -168,8           421,7  331,8 
Angle: 50, Path Extents:   -80,3         -167,9           421,3  330,9 
Angle: 51, Path Extents:   -79,7         -166,8           420,7  329,8 
Angle: 52, Path Extents:   -79,1         -165,4           420,1  328,4 
Angle: 53, Path Extents:   -78,3         -163,9           419,3  326,9 
Angle: 54, Path Extents:   -77,5         -162,2           418,5  325,2 
Angle: 55, Path Extents:   -76,6         -160,2           417,6  323,2 

E este é o código:

 Public Sub DrawTo(ByRef uDestCC As cCairoContext, ByVal uLeft As Long, ByVal uTop As Long)

    Dim dblOffx As Double: Dim dblOffy As Double

    ' Calculate offsets based on alignment and scaling
    dblOffx = Me.AlignmentFactorX * ((m_Img.width * Me.ScaleFactorW) / 2)
    dblOffy = Me.AlignmentFactorY * ((m_Img.height * Me.ScaleFactorH) / 2)

    Dim dblNewX1 As Double :  Dim dblNewY1 As Double
    dblNewX1 = (uLeft + dblOffx)
    dblNewY1 = (uTop + dblOffy)
    
    Dim dblNewX2 As Double : Dim dblNewY2 As Double
    dblNewX2 = -(m_Img.width / 2) - (Me.CenterOffsetX / 2)
    dblNewY2 = -(m_Img.height / 2) - (Me.CenterOffsetY / 2)

    m_Matrix.TranslateCoords dblNewX1, dblNewY1
    m_Matrix.RotateCoordsDeg m_sngAngleDeg
    m_Matrix.ScaleCoords Me.ScaleFactorW, Me.ScaleFactorH
    m_Matrix.TranslateCoords dblNewX2, dblNewY2
    
    ' Set the final transformation
    Set uDestCC.Matrix = m_Matrix
    
    ' Now draw the image with the same transformations
    uDestCC.RenderSurfaceContent m_Img, 0, 0

    ' Define a rectangle path representing the image area after rotation is set
    uDestCC.Rectangle 0, 0, m_Img.width, m_Img.height

    ' Get the extents now, with rotation already applied
    uDestCC.GetPathExtents m_dblTopX, m_dblTopY, m_dblBottomRightX, m_dblBottomRightY

    ' Clear the path
    uDestCC.ClearPath False
    
    m_Matrix.ResetToIdentity
    
    Debug.Print "Angle: " & m_sngAngleDeg & ", Path Extents:", Round(m_dblTopX, 1), Round(m_dblTopY, 1), Round(m_dblBottomRightX, 1), Round(m_dblBottomRightY, 1)
    
End Sub

Alguém sugere usar o CopyPath.

No invólucro encontrei isto:

Function CopyPath([AsFlatPath As Boolean], [FlatPrecision As Double = 0,1]) As cCairoPath
    Member of RC6.cCairoContext

A classe cCairoPath oferece o seguinte:

Function CalculateDistances(Distances() As Double) As Double
Property EntriesCount As Long
Function GetPathEntry(IndexZeroBased As Long, EntryType As cairo_path_data_type_enm, [X0 As Double], [Y0 As Double], [X1 As Double], [Y1 As Double], [X2 As Double], [Y2 As Double])
Sub ProjectPathData_Using(FlattenedBasePath As cCairoPath, [ScaleX As Double], [ScaleY As Double])
Sub ProjectPathData_Using(FlattenedBasePath As cCairoPath, [ScaleX As Double], [ScaleY As Double])

Tenho o seguinte latex que estou usando no aplicativo Lucidchart:

\omega_{11}^{\ell}

Quero que o primeiro 1seja vermelho e o segundo 1verde. Como faço isso?

Eu tentei o seguinte:

\omega_{1{red}1{green}}^{\ell}

mas isso não leva ao resultado certo.

Gostaria de avaliar a função definida simbolicamente abaixo e plotar os resultados usando Julia.

f(x) = 2*x*(1-x/10)para x em (0,20].

Como eu faria isso?

Aqui está meu código Coq.

Eu esperava Check x ∪ y.shows , x ∪ ymas ∪ {x, y}.

Por que? Ou existe outra ideia para definir a notação?

Minha versão do Coq é 8.16.1.

Section Test.
  Variable set:Type.
  Variable In : set -> set -> Prop.
  Notation "x ∈ y" := (In y x) (at level 50).

  Structure class φ := {
    class_base :> set;
    class_row : forall x, x ∈ class_base <-> φ x;
  }.

  Axiom build_union : forall F, class (fun x => exists Y, x ∈ Y /\ Y ∈ F).
  Notation "∪ F" := (build_union F) (at level 50).

  Axiom build_non_ordered_pair_set : forall x y, class (fun w => w = x \/ w = y).
  Notation "{ x , y }" := (build_non_ordered_pair_set x y) (at level 45).

  Notation "x ∪ y" := (∪ {x, y}) (at level 50).

  Variable F x y:set.

  Check ∪ F.
  (* ∪ F                                                          *)
  (*      : class (fun x : set => exists Y : set, x ∈ Y /\ Y ∈ F) *)

  Check {x, y}.
  (* {x, y}                                       *)
  (*      : class (fun w : set => w = x \/ w = y) *)

  Check x ∪ y.
  (* ∪ {x, y}   <- Why is not x ∪ y ?                                    *)
  (*      : class (fun x0 : set => exists Y : set, x0 ∈ Y /\ Y ∈ {x, y}) *)
End Test.

Eu sei que o código abaixo funciona bem.

  Axiom build_two_union : forall x y, class (fun z => exists Y, z ∈ Y /\ Y ∈ {x, y}).
  Notation "x ∪ y" := (build_two_union x y) (at level 2).
  Check x ∪ y.

Sou iniciante em Julia e estou trabalhando com a biblioteca Nemo para fazer coisas em campos finitos.

Eu gostaria de calcular os caracteres de um determinado corpo finito e para isso tenho que calcular quantidades como

exp(2*pi*im*absolute_tr(a)/p)

No entanto, o tipo de absolute_tr(a)é FqFieldElem, pois é um elemento do subcampo principal (aqui Z/pZ) do meu campo finito, portanto, isso gera um erro.

Gostaria de transformar esse inteiro módulo p em um int mas não consigo encontrar nenhum método para fazer isso (apesar de estar impresso no console como um inteiro...).

Estou tentando escrever uma função uint32_to_float em lua onde estou usando math.ldexp em uma condição. Ao verificar o script usando luacheck, recebo o seguinte erro:

 scripts/CAN test.lua:58:21: accessing undefined field ldexp of global math

Como resolvo o problema e alguém poderia me sugerir uma alternativa?

Estou implementando um recurso para girar formas usando alças de canto. A rotação funciona bem para formas quadradas, mas estou enfrentando um problema com formas não quadradas (retângulos com proporções diferentes de 1:1). Ao girar essas formas arrastando uma alça de canto, elas "encaixam" ou giram inesperadamente, sem levar em conta a proporção da forma. Isso resulta em um desalinhamento entre o ponto de clique inicial do cursor e o comportamento de rotação da forma.

Suspeito que o problema esteja no meu cálculo de rotação, que não considera a proporção, levando a deslocamentos de ângulo incorretos durante a rotação.

Como posso calcular corretamente a rotação, levando em consideração a proporção da forma, para garantir um comportamento suave e esperado quando os usuários giram formas não quadradas?

Talvez eu também esteja tentando resolver um problema de um problema, então o problema principal que quero resolver é basicamente como girar um retângulo em torno do centro por meio de alças de canto. Você pode ver o comportamento neste vídeo .

Código:

pub fn handle_rotating(
    composition: &CompositionRes,
    selected_nodes_query: &mut Query<
        (
            &mut RelativeTransformMixin,
            &AbsoluteTransformMixin,
            &mut DimensionMixin,
        ),
        With<Selected>,
    >,
    event: &CursorMovedOnComposition,
    corner: u8,
    initial_rotation: f32,
) {
    let CursorMovedOnComposition {
        position: cursor_position,
        ..
    } = event;
    let cursor_position = transform_point_to_view_box(composition, cursor_position, true);

    selected_nodes_query.for_each_mut(
        |(mut relative_transform_mixin, absolute_transform_mixin, dimension_mixin)| {
            let relative_pivot_point = Vec2::new(
                dimension_mixin.width as f32 / 2.0,
                dimension_mixin.height as f32 / 2.0,
            );
            let absolute_pivot_point =
                apply_transform_to_point(absolute_transform_mixin.0, relative_pivot_point);

            // Determine rotation offset based on corner
            let rotation_offset_in_radians: f32 = match corner {
                _ if corner == (HandleSide::Top as u8 | HandleSide::Left as u8) => {
                    (-135.0 as f32).to_radians()
                }
                _ if corner == (HandleSide::Top as u8 | HandleSide::Right as u8) => {
                    (-45.0 as f32).to_radians()
                }
                _ if corner == (HandleSide::Bottom as u8 | HandleSide::Right as u8) => {
                    (45.0 as f32).to_radians()
                }
                _ if corner == (HandleSide::Bottom as u8 | HandleSide::Left as u8) => {
                    (135.0 as f32).to_radians()
                }
                _ => 0.0,
            };

            // Calculate rotation based on the corner
            let rotation_angle =
                calculate_rotation(initial_rotation, &cursor_position, &absolute_pivot_point);
            let final_rotation_angle =
                rotation_angle + rotation_offset_in_radians - initial_rotation;
            relative_transform_mixin.0 = set_rotation(
                relative_transform_mixin.0,
                final_rotation_angle,
                relative_pivot_point,
            );
        },
    );
}

fn calculate_rotation(
    initial_angle_in_radians: f32,
    cursor_point: &Vec2,
    pivot_point: &Vec2,
) -> f32 {
    // Calculate the angle from the pivot point to the current cursor position
    let current_angle = (cursor_point.y - pivot_point.y).atan2(cursor_point.x - pivot_point.x);

    // Calculate the raw angle difference
    let angle_diff = current_angle - initial_angle_in_radians;

    return -angle_diff;
}

Sou novo no Rust e estou tentando usar o Rust para executar produtos kronecker sequenciais para múltiplas matrizes, ou seja, quero fazer

Em python, eu sei que posso fazer

import numpy as np
from functools import reduce

X = np.array([[0, 1], [1, 0])
matrices = [X for _ in range(8)]
product = reduce(np.kron, matrices)

e obtenha o resultado desejado. Como fazer o mesmo no Rust?

Meu código Rust está parecido com o seguinte por enquanto:

use ndarray::{array, ArrayBase, OwnedRepr, Dim};
use ndarray::linalg::kron;
use num::complex::Complex64 as Complex;



fn X() -> ArrayBase<OwnedRepr<Complex>, Dim<[usize; 2]>> {
    array![
        [Complex::new(0.0, 0.0), Complex::new(1.0, 0.0)],
        [Complex::new(1.0, 0.0), Complex::new(0.0, 0.0)]
    ]
}

fn main() {    
    let mut matrices = Vec::new();
    for _ in 0..8 {
        matrices.push(X());
    }
    let product = matrices
        .iter()
        .reduce(|g1, g2| kron(g1, g2));

}

Aqui está a matriz de erro que obtive:

Aqui estão as coisas que não entendo:

• OwnedRepr: Não tenho certeza para que serve exatamente, mas foi isso que o analisador de ferrugem me sugeriu fazer
• Tentei modificar meu código de acordo com a sugestão da mensagem de erro, mas não obtive mais sugestões de como processar.

Gostaria de saber como consertar isso e agradeceria se houvesse alguma sugestão de arquivos de exemplo de nível iniciante sobre como usar o Rust para fazer cálculos científicos.

Executando um notebook Jupyter no VSCode, estou tendo um comportamento bizarro com a diretiva de divisão desprotegida do Cython. Iniciando a sessão com %load_ext cython, execute:

%%cython
import math
cimport cython

@cython.cdivision(True)
def simpleTest(int d):
    cdef double c = 1/math.exp(math.log(math.sqrt(2/d)))
    return c

Agora execute simpleTest(x)e para qualquer valor x>= 3 eu recebo:

ValueError: erro de domínio matemático

Mas rodando sem a @cython.cdivision(True)diretiva funciona bem para todos x> 0, como deveria. Porque é que a directiva quebra este cálculo? Existe uma abordagem melhor?

Em uma parábola de imagem n^2 x=1000 corresponderá a y=1. Ainda tem que haver algum coeficiente? É a*N^2 ou (aN)^2? Como resolver corretamente em matemática pura?