All perguntas(coding)

Aqui está meu composível

@Composable
fun CounterScreen(viewModel: MyViewModel = viewModel()) {
    val uiState by viewModel.uiState.collectAsState()

    Column(
        modifier = Modifier.fillMaxSize(),
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Text(text = "Counter: ${uiState.count}")
        Spacer(modifier = Modifier.height(16.dp))
        FloatingActionButton(
            onClick = {
                viewModel.increment()
            },
        ) {
            Icon(imageVector = Icons.Default.Add, contentDescription = "Increment")
        }
    }
}

Por que o estado é preservado com recomposição quando escrevi fun CounterScreen(viewModel: MyViewModel = viewModel()), mas não com fun CounterScreen(viewModel: MyViewModel = MyViewModel()). No entanto, ambos criam uma nova instância de MyViewModel. Alguém pode me explicar? Obrigado

Eu fiz uma macro que funciona perfeitamente para inserir o espaço que preciso abaixo de um certo intervalo. Ela seleciona as células e então usa insert para mover os dados abaixo. Ela então faz um loop para fazer isso por mais algumas vezes

Aqui está;

i = 3
Do While i < 19
    Set Rng1 = Worksheets("Sheet1").Range("A" & i & ":C" & i + 1)
    Rng1.Insert Shift:=xlDown
    i = i + 3
Loop

O problema é que quando eu alterei para que funcionasse não importa onde eu colocasse a tabela (já que ela geralmente fica em colunas diferentes, mas sempre na extremidade direita), de repente ela insere apenas 20 linhas completas e não faz mais nada.

i = 3
Set rng1 = Worksheets("Sheet1").Range("BZ6").End(xlToLeft).Offset(0, -2)
Do While i < 19
    Set rng2= Worksheets("Sheet1").Range(rng1.Offset(i, 0) & ":" & rng1.Offset(i + 1, 2))
    rng2.Insert Shift:=xlDown
    i = i + 3
Loop

Isso deve considerar rng1 como o canto superior esquerdo da tabela e rng2 como as 6 células que desejo inserir 6 células acima.

É a primeira vez que tento usar Offset, então posso estar implementando errado. Qualquer ajuda seria muito apreciada

Criei um bloco Python que recebe cinco entradas do usuário e gera um arquivo .txt contendo registros de data e hora na coluna 1 e dados de desvio Doppler na coluna 2 com base nas entradas.

As duas primeiras entradas são elementos de duas linhas, a terceira é a frequência de um CubeSat, a quarta é um registro de data e hora e a última especifica o destino do arquivo onde o arquivo .txt será armazenado, semelhante ao bloco "File Sink".

Por exemplo, no bloco padrão "File Sink" do GNU Radio, clicar nos três pontos abre uma janela para navegar e selecionar o destino final do arquivo. No entanto, não consegui replicar esse comportamento no meu código.

Além disso, é possível executar este bloco antes que todo o fluxograma comece ao clicar em "Executar o fluxograma"?

Exemplo: Etapa 1. Entrada 1: "1 49263U 21088D 24308.92471420 .00079255 00000+0 26750-2 0 9998"

Entrada 2: "2 49263 97.4796 14.7363 0010511 313.1417 46.8944 15.30328253170926"

Entrada 3: 437.250e6

Entrada 4: 1730713098

Entrada 5: ---clique nos três pontos para abrir o navegador de arquivos e salvar o arquivo---

Etapa 2. Clique em "Executar o fluxograma" ---executa o bloco python antes do fluxograma principal---

import scipy.constants
import skyfield.api
from skyfield.api import wgs84, EarthSatellite
import numpy as np
import datetime
from tkinter import filedialog
import tkinter as tk
from gnuradio import gr

class DopplerBlock(gr.sync_block):
  
    
    def __init__(self, tle_line1='', tle_line2='', frequency=0, timestamp=0):
        gr.sync_block.__init__(
            self,
            name='Doppler Shift Generator',
            in_sig=None,
            out_sig=None
        )
        
        self.tle_line1 = tle_line1
        self.tle_line2 = tle_line2
        self.frequency = frequency
        self.timestamp = timestamp  # User-provided timestamp
        self.ts = skyfield.api.load.timescale()
        self.groundstation = wgs84.latlon(53.1111, 8.8583, 0)  # ESTEC ground station
        self.output_file_path = self.get_file_path()

    def get_file_path(self):
        """Opens a file dialog to let the user choose a file."""
        root = tk.Tk()
        root.withdraw()  # Hide the root window
        file_path = filedialog.asksaveasfilename(title="Select file to save data")
        return file_path if file_path else None

    def compute_doppler(self):
        if not self.tle_line1 or not self.tle_line2:
            raise RuntimeError("Both TLE lines must be provided.")
        
        satellite = EarthSatellite(self.tle_line1, self.tle_line2, 'satellite', self.ts)
        
        unix_epoch = datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc)
        t0 = unix_epoch + datetime.timedelta(seconds=self.timestamp)
        t0 = self.ts.from_datetime(t0)

        # Generate time steps
        duration_s = 25 * 60  # 25 minutes in seconds
        time_steps = np.arange(0, duration_s, 0.1)  # Every 0.1 sec
        t = t0 + time_steps / (24 * 3600)  # Convert seconds to fractional days
        
        # Compute Doppler shift
        topocentric = satellite.at(t).observe(self.groundstation)
        _, _, range_rate = topocentric.apparent().velocity.km_per_s
        range_rate *= 1e3  # Convert to m/s

        doppler_shift = -range_rate / scipy.constants.c * self.frequency

        # Save to file if path is provided
        if self.output_file_path:
            with open(self.output_file_path, 'w') as output_file:
                for time, shift in zip(time_steps, doppler_shift):
                    output_file.write(f'{self.timestamp + time}\t{shift}\n')

    def work(self, input_items, output_items):
        """This block does not process streaming signals, so work does nothing."""
        return 0

Sou novo no uso do Angular.

Ao usar um layout de grade, não estou obtendo o que quero. Para depurar, criei o seguinte elemento:

    <div *ngFor=" let tableVersionHeader of tableVersion.xAxis.tableVersionHeaders"
         class="grid-cell text"
         [ngStyle]="{
          'height': 'auto',
          'text-align': 'center !important',
          'border': '1px solid black',
          'padding': '8px',
          'grid-column': tableVersionHeader.columnIndex + 2 + ' / span ' + tableVersionHeader.breadth,
          'grid-row':  tableVersionHeader.level + ' / span ' + ((tableVersionHeader.children!.length === 0 || !tableVersionHeader.isAbstract)) ? (tableVersion.xAxis.rowCount - (tableVersionHeader.level ?? 0)) : 1
         }">
      <p>{{tableVersionHeader.headerVersion?.code}} - {{tableVersionHeader.headerVersion?.label}}</p>
      <p>grid-column: {{tableVersionHeader.columnIndex + 2}} / span {{tableVersionHeader.breadth}}</p>
      <p>grid-row: {{tableVersionHeader.level}} / span {{((tableVersionHeader.children!.length === 0 || !tableVersionHeader.isAbstract)) ? (tableVersion!.xAxis.rowCount - (tableVersionHeader.level ?? 0)) : 1}}</p>
    </div>

Como você pode ver, estou imprimindo os valores que espero para grid-columne grid-rowem meus divs.

Minha saída é, por exemplo:

0008 - Internal rating scale

grid-column: 2 / span 1

grid-row: 1 / span 1

Enquanto o estilo definido no elemento é:

height: auto;
border: 1px solid black;
padding: 8px;
grid-area: 3 / 2 / auto / span 1;

De alguma forma, angular (?) reescreve os valores grid-columne para, mas não da maneira correta.grid-rowgrid-area

Não consegui encontrar uma referência sobre o porquê do angular estar fazendo isso e como pará-lo. Verifiquei duas vezes com o Firefox e o Chrome, ambos mostram o mesmo comportamento.

Agradecemos antecipadamente sua ajuda.

Editar: código de exemplo do Stackblitz https://angular-3plybjxk.stackblitz.io

Gostaria de importar elementos opcionais da GUI definidos em arquivos Mod1.py/ Mod2.py/etc separados e adicioná-los/remover dinamicamente da GUI principal. Os arquivos separados que definem esses elementos opcionais da GUI contêm kvstrings. No meu caso de uso, esses elementos da GUI podem ser descarregados/recarregados várias vezes. Descobri que se eu tiver classes com nomes idênticos nos Modx.pyarquivos, isso cria uma conversa cruzada entre os módulos porque Builder.load_stringfunciona cumulativamente. O pano de fundo para essa descoberta está aqui - Importando vários módulos contendo classes com nomes idênticos em python

A documentação do Kivy Builder sugere que uma determinada kvstring pode ser seletivamente descarregada mais tarde se um pseudo nome de arquivo for fornecido, por exemplo Builder.load_string("""<kv string>""", filename="myrule.kv") , e mais tarde para descarregar - Builder.unload_file("myrule.kv") No entanto, quando tento isso, parece funcionar apenas na primeira vez que um módulo é descarregado e outro é carregado. Depois disso, os elementos opcionais da GUI não aparecem mais quando recarregados. O exemplo a seguir demonstra isso.

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.button import Button
from kivy.lang import Builder
import importlib

Builder.load_string('''
<MainWidget>:
    orientation: 'vertical'
    BoxLayout:
        Button:
            text: "Load Mod 1"
            on_press: 
                root.load_module(self.text)
        Button:
            text: "Load Mod 2"
            on_press: 
                root.load_module(self.text)
        Button:    
            text: "Unload all"
            on_press: 
                dock.clear_widgets()
    FloatLayout: 
        id: dock
''')
    
class MainWidget(BoxLayout):
    
    def load_module(self, hint):

        self.ids.dock.clear_widgets()
        Builder.unload_file("foo.kv")

        if "1" in hint:
            self.module = importlib.import_module("Mod1").Module()
        if "2" in hint:
            self.module = importlib.import_module("Mod2").Module()
        
        self.ids.dock.add_widget(self.module)

class MyApp(App):
    def build(self):
        return MainWidget()
      
if __name__ == '__main__':
    MyApp().run()

Mod1.py

from kivy.uix.floatlayout import FloatLayout
from kivy.lang import Builder

Builder.load_string('''
<Module>:  
    size_hint: None, None
    size: self.parent.size if self.parent else self.size
    pos: self.parent.pos if self.parent else self.pos
    Button:
        size_hint: None, None
        width: self.parent.width / 3
        height: self.parent.height
        pos: self.parent.pos
        text: "Mod 1"
        on_press: print(root); print([x for x in dir(root) if 'method' in str(x)])
''', filename="foo.kv")

class Module(FloatLayout):

    def __init__(self, **kwargs):
        super(FloatLayout, self).__init__(**kwargs)
        
    def dummymethod1(self):
        pass

Mod2.py

from kivy.uix.floatlayout import FloatLayout
from kivy.lang import Builder

Builder.load_string('''
<Module>:
    size_hint: None, None
    size: self.parent.size if self.parent else self.size
    pos: self.parent.pos if self.parent else self.pos
    Button:
        size_hint: None, None
        width: self.parent.width / 3
        height: self.parent.height
        pos: (self.parent.x + self.parent.width / 2) , self.parent.y
        text: "Mod 2"
        on_press: print(root); print([x for x in dir(root) if 'method' in str(x)])
''', filename="foo.kv")

class Module(FloatLayout):

    def __init__(self, **kwargs):
        super(FloatLayout, self).__init__(**kwargs)
        
    def dummymethod2(self):
        pass

Gostaria de saber se há uma maneira de fazer isso funcionar corretamente. Talvez eu esteja esquecendo de algo sobre a maneira como o Kivy builder funciona?

Eu estava percorrendo algum código e me deparei com o seguinte snippet para evitar que o StrictMode chame um efeito duas vezes. Embora geralmente não seja recomendado implementar tal recurso, fiquei mais confuso sobre o porquê de ele realmente funcionar. Veja o seguinte:

export const useApiDemo = (param: string) => {
  let strictModeRerun = false;

  useEffect(() => {
    !strictModeRerun && fetchApi(param);
    return () => {
      strictModeRerun = true;
    };
  }, [param]);
};

Pelo que entendi, em strictmode, ganchos e componentes são chamados duas vezes para que possamos identificar quaisquer configurações incorretas ou limpezas defeituosas. Se useApiDemo (ou o componente em que é usado) renderiza duas vezes, eu presumo que strictModeReruntambém seria falso duas vezes porque é definido em linha no escopo de renderização. Ele não é persistido entre renderizações, então eu presumo que isso faz com que a segunda execução também chame a API. No entanto, a chamada da API é disparada apenas uma vez. Se eu remover a strictModeRerunAPI, ela dispara duas vezes. Por que isso realmente funciona?

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Player2 : MonoBehaviour
{
    [SerializeField] KeyCode keyOne;
    [SerializeField] KeyCode keyTwo;
    [SerializeField] Vector3 moveDirection;

    private void FixedUpdate()
    {
        if (Input.GetKey(keyOne))
        {
            GetComponent<Rigidbody>().linearVelocity += moveDirection;
        }

        if (Input.GetKey(keyTwo))
        {
            GetComponent<Rigidbody>().linearVelocity -= moveDirection;
        }
    }
}

Este código é exatamente o que estava na lição no YouTube, onde o cubo se movia para cima e para baixo, mas para mim ele não se move com a mesma configuração de botão.Unity 6000.0.44f1

Tento comparar dois campos em COBOL depois de usar as funções intrínsecas upper-case e trim.

Quando comparo esses dois campos sem mover o resultado para novos campos, a comparação diz que os campos são iguais, embora não sejam, por exemplo, "Wert1" <> "wert1 x", como no meu exemplo.

Por que a comparação funciona como eu espero quando uso campos, mas não quando uso as funções intrínsecas diretamente?

programa de exemplo:

       program-id. tintr.
       data division.
       working-storage section.

       01  ws-feld1   pic x(10).
       01  ws-feld2   pic x(10).
       01  ws-feld3   pic x(10).
       01  ws-feld4   pic x(10).

       procedure division.

           move "Wert1 " to ws-feld1
           move "wert1 x" to ws-feld2
      *
           display "<" function upper-case(ws-feld1) ">"
           display "<" function upper-case(ws-feld2) ">"
      *
           display "<" function trim(ws-feld1) ">"
           display "<" function trim(ws-feld2) ">"
      *
           display "<" function upper-case
           (function trim(ws-feld1)) ">"
           display "<" function upper-case
           (function trim (ws-feld2)) ">"
      * Compare WS-Feld1/WS-Feld2
           if ws-feld1 = ws-feld2
           then
              display " felder1-2 identical"
           else
              display " felder1-2 not identical"
           end-if
      * Compare Functions uppercase/Trim
           if function upper-case
           (function trim(ws-feld1))
           =
            function upper-case
           (function trim(ws-feld2))
           then
              display " felder1-2/function identical"
           else
              display " felder1-2/function not identical"
           end-if
      * moving result of functions into field
           move function upper-case
           (function trim(ws-feld1))
           to ws-feld3
           
           move function upper-case
           (function trim(ws-feld2))
           to ws-feld4
      * Compare WS-Feld3/WS-Feld4
           if ws-feld3 = ws-feld4
           then
              display " felder3-4 identical"
           else
              display " felder3-4 not identical"
           end-if
      *

           stop run.

      *

Este é o resultado:

<WERT1     >
<WERT1 X   >
<Wert1>
<wert1 x>
<WERT1>
<WERT1 X>
felder1-2 not identical
felder1-2/function identical
felder3-4 not identical

O que eu não esperava é o resultado "felder1-2/function identical":

Alguma explicação para esse comportamento?

Estou testando o armazenamento de sinais Ngrx. Assisti a alguns tutoriais e li a documentação oficial. Os vídeos no YouTube são bem simples e os documentos não cobrem isso. Estou tentando usar withHooks onInito método para buscar dados no store init, mas o problema é que o endpoint da API que estou usando requer param, mas passar params para o método não é coberto, ou pelo menos não consegui encontrar a solução. Devo abandonar a busca signalStore onInite mudar para o componente padrão ngOnInit? Além disso, esse prop é passado para o componente sobre signal input. Código de exemplo abaixo.

export const PostsStore = signalStore(
  withState<PostsStateInterface>({
    post: {},
    error: null,
    isLoading: false
  }),
  withMethods((store, postsService = inject(PostsService)) => ({
    loadPosts: rxMethod<number>(
      pipe(
        switchMap((id) => {
          return postsService.getPost(id).pipe(
            tap((posts) => {
              patchState(store, { post })
            })
          )
        })
      )
    )
  })),
  withHooks({
    onInit(store) {
      store.loadPost(id) // Call the loadPost method with the id, how to get the id?
    },
  })
)

@Component({
  ...
  standalone: true,
  providers: [PostsStore],
  imports: [
    ...
  ],
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class ImageProcessing360ContainerComponent {
  id = input.required<number>()
  store = inject(PostsStore)
}

Criei um tipo anulável como este, que encontrei em uma resposta do SO, não lembro qual.

unit NullableType;

interface

uses
  System.SysUtils, System.Rtti;

type
  TNullable<T> = record
 private
    FValue: T;
    FHasValue: IInterface;
    function GetHasValue: Boolean;
    function GetValue: T;
    procedure SetValue(const AValue: T);
  public
    constructor Create(AValue: T);
    function ToString: string; // <-- add this for easier use!
    property HasValue: Boolean read GetHasValue;
    property Value: T read GetValue write SetValue;
  end;


implementation


constructor TNullable<T>.Create(AValue: T);
begin
   SetValue(AValue);
end;

function TNullable<T>.GetHasValue: Boolean;
begin
  Result := FHasValue <> nil;
end;

function TNullable<T>.GetValue: T;
begin
  if HasValue then
    Result := FValue
  else
    Result := Default(T);
end;

procedure TNullable<T>.SetValue(const AValue: T);
begin
  FValue := AValue;
  FHasValue := TInterfacedObject.Create;
end;

function TNullable<T>.ToString: string;
begin
  if HasValue then
  begin
    if TypeInfo(T) = TypeInfo(TDateTime) then
      Result := DateTimeToStr(PDateTime(@FValue)^)
    else if TypeInfo(T) = TypeInfo(TDate) then
      Result := DateToStr(PDateTime(@FValue)^)
    else if TypeInfo(T) = TypeInfo(TTime) then
      Result := TimeToStr(PDateTime(@FValue)^)
    else
      Result := TValue.From<T>(FValue).ToString;
  end
  else
    Result := 'null';
end;

end.

Meu problema é que não sei como defini-lo como nulo.
Por exemplo

var
  id : TNullable<integer>;
begin
  if Edit1.Text <> '' then
    id.Value := StrToInt(Edit1.Text)
  else
    id.Value := null;  // runtime error

isso me dá erro de tempo de execução

Não foi possível converter a variante do tipo (Null) em tipo (Integer)

Já faz um tempo que programo em Delphi e não consigo descobrir como definir o valor da idvariável paranull

id.Value := nil;

dá erro de compilador

Tipos incompatíveis: 'integer' e 'pointer'

Somente não definindo o valor de ideu consigo ter seu valor null, mas e se eu quiser defini-lo para qualquer valor, incluindo null? Como fazer isso?