FluidMechanics Potential Flows's questions

No livro C#12 In a Nutshell, diz:

Ao executar aplicativos WPF ou Windows Forms no Visual Studio, a saída do Console é redirecionada automaticamente para a janela de saída do Visual Studio (no modo de depuração)

No entanto, tentei isso no código por trás:

using System.Diagnostics;
using System.Windows;

namespace WPFHelloWorld
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            Debug.WriteLine("Hello rr Debug");
            Console.WriteLine("Hello rr");
        }
    }
}

E eu só vejo a saída de Debug.WriteLine(então o código é alcançado).

Verifiquei a Outputaba e a Immediate Windowaba.

Não vejo o "Hello rr" em nenhum deles. Vejo "Hello rr Debug" na Outputaba.

Por que isso não está funcionando como o livro diz que deveria?

Isso é um bug do Visual Studio? Sei que a boa prática é usar Debug.WriteLine("Hello rr Debug");em aplicativos WPF, já que não há Console. Minha pergunta é por que a saída do Console não é redirecionada quando diz que deveria.

Coisas que já fiz:

• Certifiquei-me de que estava executando no Modo de Depuração.
• Reiniciei meu computador.
• Reinstalei o Visual Studio.
• Eu reinstalei meu .NET sdk
• Eu tentei dotnet 8.0.401 e 9.0.101
• Verifiquei o Windows Update.

Quando faço uma multiplicação de matrizes com numpy(Python 3.12.1, numpy 1.26.4, PyCharm 2024.3.1 (Professional Edition)), recebo este aviso que acredito estar errado:

Referência de atributo não resolvida 'all' para a classe 'bool'

Prova:

Exemplo Mínimo Reproduzível

import numpy as np

a_matrix = np.array([[1, 2], [3, 4]])
b_matrix = np.array([[10], [20]])
a = [5.0]
b = [2.0]

if ((a_matrix @ np.array([[round(a[0], 0)], [round(b[0], 0)]])) == b_matrix).all():
    print("Success")

Aqui está um MRE:

FileAccessPermissions permissions = FileAccessPermissions.Read | FileAccessPermissions.Special;

Console.WriteLine(permissions.ToString("G"));
Console.WriteLine(permissions.ToString("F"));
Console.WriteLine(permissions.ToString("D"));
Console.WriteLine(permissions.ToString("X"));

[Flags]
enum FileAccessPermissions
{
    None = 0,
    Read = 1,
    Write = 2,
    Execute = 4, 
    Delete = 8,
    Special = 16,
    ReadWrite = Read | Write,
}

Para minha surpresa, não consigo encontrar um exemplo singular em que o especificador de formato Ge o Fproduzem saídas diferentes. Eu obtenho isso para este exemplo:

Read, Special
Read, Special
17
00000011

Se eu fizer: FileAccessPermissions permissions = FileAccessPermissions.ReadWrite; Eu recebo:

ReadWrite
ReadWrite
3
00000003

Estou tentando entender a utilidade prática do G9especificador de formato em C# ao lidar com números de ponto flutuante de ida e volta.

O livro C#12 em poucas palavras menciona que G9é útil evitar perda de precisão ao converter a floatpara a stringe de volta para a float(página 324). Mas não consigo encontrar um exemplo que mostre um caso em que G9a formatação tenha sucesso em preservar a igualdade, enquanto a formatação padrão falharia.

Por exemplo:

using System;

class Program
{
    static void Main()
    {
        float originalNumber = 0.1f;

        string defaultFormatted = originalNumber.ToString();

        float defaultRoundTrip = float.Parse(defaultFormatted);
        Console.WriteLine("Default Formatting:");
        Console.WriteLine("Original: " + originalNumber);
        Console.WriteLine("Formatted: " + defaultFormatted);
        Console.WriteLine("Round-trip Equal: " + (originalNumber == defaultRoundTrip));

        string g9Formatted = originalNumber.ToString("G9");

        float g9RoundTrip = float.Parse(g9Formatted);
        Console.WriteLine("\nG9 Formatting:");
        Console.WriteLine("Original: " + originalNumber);
        Console.WriteLine("Formatted: " + g9Formatted);
        Console.WriteLine("Round-trip Equal: " + (originalNumber == g9RoundTrip));
    }
}

Me dá

Default Formatting:
Original: 0.1
Formatted: 0.1
Round-trip Equal: True

G9 Formatting:
Original: 0.1
Formatted: 0.100000001
Round-trip Equal: True

Eu esperava algo do tipo:

Default Formatting:
Original: 0.1
Formatted: 0.100000000001
Round-trip Equal: False

G9 Formatting:
Original: 0.1
Formatted: 0.1
Round-trip Equal: True

Estou bastante familiarizado com o tratamento de entrada em configurações de Programação Competitiva, mas não consigo fazê-lo funcionar em Python para esse problema ( https://www.spoj.com/problems/MINDIST/ ) (minha solução funciona em C++, então o problema em si não está quebrado). Qual é a maneira padrão de ler a entrada na plataforma SPOJ?

Aqui está o que será alimentado ao stdin:

A primeira linha da entrada contém um único inteiro T, o número de casos de teste. Blocos T seguem.

Para cada caso de teste, a primeira linha contém dois inteiros separados por espaços N (1<=N<=100000) e S (0<=S<=100000000). N-1 linhas seguem, cada uma contém três inteiros X (1<=X<=N), Y (1<=Y<=N) e Z (1<=Z<=1000), denota que há uma aresta ponderada (não direcionada) Z entre o nó X e Y. A entrada está correta.

E um exemplo de entrada alimentada seria:

2
5 2
1 2 5
2 3 2
2 4 4
2 5 3
8 6
1 3 2
2 3 2
3 4 6
4 5 3
4 6 4
4 7 2
7 8 3

ERM:

Isso (apenas o tratamento de entrada) obtém "erro de tempo de execução, código de saída diferente de zero" (mas funciona localmente e em compiladores online como o ideone):

def get_int():
    return int(input())

def get_ints():
    return map(int, input().split())

T = get_int()
for _ in range(T):
    N, S = get_ints()
    for _ in range(N-1):
        X, Y, Z = get_ints()

Parece que a get_ints()chamada é o problema porque isto:

def get_int():
    return int(input())

def get_ints():
    return map(int, input().split())

T = get_int()
for _ in range(T):
    N, S = 2, 3
    for _ in range(N-1):
        X, Y, Z = 1, 2, 3

recebe (como esperado) "resposta errada".

Não sei por que isso acontece.

No livro C#12 In A Nutshell, os autores escrevem este código:

UnsafeClass a = new UnsafeClass ("Christian Troy");

unsafe struct UnsafeUnicodeString
{
    public short Length;
    public fixed byte Buffer[30];
}

unsafe class UnsafeClass
{
    UnsafeUnicodeString uus;
    public UnsafeClass (string s)
    {
        uus.Length = (short)s.Length;
        fixed (byte* p = uus.Buffer)
            for (int i = 0; i < s.Length; i++)
                p[i] = (byte) s[i];
    }
}

Eles então mencionam

A palavra-chave fixed também é usada neste exemplo para fixar o objeto no heap que contém o buffer (que será a instância de UnsafeClass)

Não tenho certeza se entendi o que eles querem dizer / sobre o que estão falando. Se estão falando sobre a, por que precisariam aser fixados. Se estão falando sobre uus, por que diriam "fixar o objeto no heap", uusdeveria estar na pilha, certo? (apenas tipos de valor) Ou talvez estejam falando sobre p? Mas pestá na pilha, se entendi corretamente?

No livro C#12 In a Nutshell (p. 259 Capítulo Sobrecarga de verdadeiro e falso), eles nos fornecem este exemplo para ilustrar como sobrecarregar os operadores verdadeiro e falso.

SqlBoolean a = SqlBoolean.Null;
if (a)
    Console.WriteLine ("True");
else if (!a)
    Console.WriteLine ("False");
else
    Console.WriteLine ("Null");

public struct SqlBoolean
{
    public static bool operator true (SqlBoolean x)
    {
        return  x.m_value == True.m_value;
    }

    public static bool operator false(SqlBoolean x)
    {
        return x.m_value == False.m_value;
    }

    public static SqlBoolean operator ! (SqlBoolean x)
    {
        if (x.m_value == Null.m_value) return Null;
        if (x.m_value == False.m_value) return True;
        return False;
    }

    public static readonly SqlBoolean Null = new SqlBoolean (0);
    public static readonly SqlBoolean False = new SqlBoolean (1);
    public static readonly SqlBoolean True = new SqlBoolean (2);

    SqlBoolean (byte value) { m_value = value; }
    byte m_value;
}

Estou tentando entender quando a falsesobrecarga é chamada, e pelo meu entendimento (e confirmando brincando com o depurador), parece que ela nunca é chamada. Por que a falsesobrecarga seria útil então? Já que só usamos while (a)or , etc ... Sobrecarregar and while (!a)não seria o suficiente?true!

Aqui está um exemplo mínimo reproduzível:

// Implicit and explicit conversions are overloadable operators:

Note note = new Note (9);
Console.WriteLine(note);

Note n = (Note)554.37;
double x = n;
Console.WriteLine(n);
Console.WriteLine(x);

public struct Note
{
    int value;
    public int SemitonesFromA { get { return value; } }

    public Note (int semitonesFromA) { value = semitonesFromA; }

    // Convert to hertz
    public static implicit operator double (Note x) => 440 * Math.Pow (2, (double)x.value / 12);

    // Convert from hertz (accurate to the nearest semitone)
    public static explicit operator Note (double x) =>
        new Note ((int)(0.5 + 12 * (Math.Log (x / 440) / Math.Log (2)))); 
    
    public override string ToString() => $"{SemitonesFromA} semitones from A";
}

Eu esperaria

9 semitones from A
4 semitones from A
554.3652619537442

Mas eu entendo

739.9888454232688
554.3652619537442
554.3652619537442

Acho que é porque na "ordem de prioridades" de Console.WriteLine, implícitar a conversão para double tem mais prioridade do que chamar .ToString() no tipo Object. Como isso funciona? Como posso saber, olhando a documentação ( https://learn.microsoft.com/en-us/dotnet/api/system.console.writeline?view=net-8.0#overloads ), qual sobrecarga está selecionada?

Considere este exemplo mínimo reproduzível.

Point point1 = new Point(1, 2, 3);
Point point2 = new Point(1, 2, 31);

Console.WriteLine(point1 == point2);  // True
Console.WriteLine(point1.Equals(point2));  // True

record Point(double X, double Y, double Z)
{
    public virtual bool Equals(Point other)
    {
        return other != null && X == other.X && Y == other.Y;
    }
}

Eu substituo o ==método por Equals? Parece que eu também (e não apenas substituo .Equals). Existe uma maneira de substituir apenas um deles?

Se eu clonar usando minha conta pessoal, não funciona. Diz que não consegue encontrar o repositório. Faz sentido, o repositório é privado e minha conta pessoal não está nele.

Então eu uso: git clone https://<token>@github.com/.../....gitcom um token que gerei na minha conta de trabalho no github.

Isso funciona.

Agora se eu fizer uma modificação e empurrar ( git add ., git commit -s -m "something", git push), funciona, mas no repo aparece como se minha conta pessoal tivesse feito os pushes mesmo que essa conta nem pertença ao repo. Insisto, o token que utilizo não está vinculado a essa conta pessoal.

Estou um pouco confuso sobre o que devo fazer. Acho que o gerenciador de credenciais git bagunça tudo, mas não sei como. Além disso, como isso funciona, já que eu nem deveria ter os "direitos" de inserir esse repositório com minha conta pessoal? O token é usado para contornar a segurança e então o que é exibido nem mesmo é “controlado”? Com isso quero dizer que o GitHub permite o evento push graças ao token, mas o próprio commit contém informações do autor da configuração local do Git que podem não corresponder?

Estou encontrando um AttributeError ao tentar usar o acessador .dt em uma série pandas, apesar de confirmar que a série contém apenas objetos Timestamp. Condensei meu problema em um Exemplo Mínimo Reprodutível (MRE) abaixo:

import pandas as pd

# Sample data
data = {'DateGreffe': ['25/10/2023', '26/10/2023', '27/10/2023']}
df = pd.DataFrame(data)

# Convert "DateGreffe" to datetime
df.loc[:, "DateGreffe"] = pd.to_datetime(df["DateGreffe"], dayfirst=True)

# Check data type of "DateGreffe" column
print(df["DateGreffe"].apply(type).unique())

# Convert "DateGreffe" back to string format "DD/MM/YYYY"
df.loc[:, "DateGreffe"] = df["DateGreffe"].dt.strftime("%d/%m/%Y")

print(df)

A saída da instrução print confirma que a coluna DateGreffe contém apenas objetos Timestamp. No entanto, quando tento usar .dt.strftime nesta coluna, recebo o seguinte erro:

AttributeError: só pode usar o acessador .dt com valores semelhantes a data e hora