All perguntas(coding)

Acabei de atualizar para o OpenLayers 10.4 da versão 4.5. Preciso obter todos os recursos no ponto em que o usuário clica. Então eu uso

map.forEachFeatureAtPixel(pixel, function (feature, layer) { .... }));

Funciona bem quando uma cor de preenchimento para um polígono naquele local é especificada.

new ol.style.Style({
    fill: new ol.style.Fill({ color: [0xfb, 0x7f, 0x7f, 0.7] }),
    stroke: new ol.style.Stroke({ color: "#ff0000", width: 1 })
})

Não retorna polígonos com estilo de preenchimento igual a nulo:

new ol.style.Style({
    fill: null,
    stroke: new ol.style.Stroke({ color: "#F44444", width: 1 })
})

Funcionou bem usando a versão 4.5. Alguém poderia me dar uma dica de como resolver isso?

Quando ploto meus dados sem definir explicitamente o intervalo de coordenadas x (o quarto e mais baixo gráfico na captura de tela, "Sonntag"), o programa par("usr")me informa qual intervalo o R usa por padrão:

> par("usr")
[1]  -68.912 1797.112    0.000   87.400

Mas quando defino o intervalo de coordenadas x para esses valores usando xlim = c(-68.912, 1797.112), o gráfico fica mais estreito (o terceiro gráfico na captura de tela, "Samstag"). E quando defino um intervalo mais estreito que o padrão, o eixo x se estende além da janela do gráfico (o primeiro e o segundo gráficos na captura de tela).

Os dados no eixo x são um fator:

steps$time <- factor(format(steps$start_time, "%H:%M"),
                     levels = format(seq(as.POSIXct("2020-02-20 00:00:00"),
                                         as.POSIXct("2020-02-20 23:59:00"),
                                         by = "1 min"),
                                     "%H:%M"
                                     )
                     )

Quero limitar o gráfico ao "tempo" entre 6h e 23h, que deve corresponder aos níveis de fator 360 e 1380 (usados ​​nos dois gráficos superiores). Como posso fazer isso?

Aqui está o código completo do enredo:

par(mfrow = c(4, 1), mar = c(5.1, 2.1, 4.1, 2.1))
barplot(count ~ time, dat[dat$group == "A",], xlim = c(360, 1380), ylim = c(0, max(dat$count)), col = "violet", border = NA, xlab = "", ylab = "", yaxt = "n", main = "Montag bis Donnerstag")
barplot(count ~ time, dat[dat$group == "B",], xlim = c(360, 1380), ylim = c(0, max(dat$count)), col = "violet", border = NA, xlab = "", ylab = "", yaxt = "n", main = "Freitag")
barplot(count ~ time, dat[dat$group == "C",], xlim = c(-68.912, 1797.112), ylim = c(0, max(dat$count)), col = "violet", border = NA, xlab = "", ylab = "", yaxt = "n", main = "Samstag")
barplot(count ~ time, dat[dat$group == "D",], ylim = c(0, max(dat$count)), col = "violet", border = NA, xlab = "", ylab = "", yaxt = "n", main = "Sonntag")

Os dados estão aqui: https://pastebin.com/tnNwFywX

Tenho um campo em um arquivo csv que tem valores como:

243 56,
1 673 22,
33 45 789 15

Agora, quero carregar este arquivo usando o IICS para uma tabela MySQL, mas removendo todos os espaços, exceto o último. O último espaço precisa ser substituído por um ponto (.). Assim, os dados ficariam assim:

243.56,
1673.22,
3345789.15

Ignore as vírgulas no final de cada valor. Adicionei-as para maior clareza.

// lib.h
#pragma once
static inline int static_inline(int x) { return x; }
inline int extern_inline(int x) { return static_inline(x); }

// lib.c
#include "lib.h"
extern inline int extern_inline(int x);

// app.c
#include "lib.h"

Ao compilar app.c, o gcc emite este aviso:

'static_inline' é estático, mas é usado na função inline 'extern_inline', que não é estática.

Por que isso é um problema? Meu raciocínio é: em app.c, se extern_inline não for incorporado, torna-se uma chamada de função e seus detalhes de implementação (chamadas static_inline) podem ser ignorados. Se extern_inline for incorporado, tem a definição completa e as definições em outras unidades de tradução também podem ser ignoradas.

Estou tentando criar um tema escuro com base em um tema claro existente usando lightTheme.copyWith(brightness: Brightness.dark). No entanto, o aplicativo parece ignorar o brilho do tema escuro.

Meu main.dart usa o seguinte código:

@override
Widget build(BuildContext context) {
  return MaterialApp(
      theme: Themes.lightTheme,
      darkTheme: Themes.darkTheme,
      themeMode: ThemeMode.dark,
      ...
  );
}

onde Themes.lightThemee Themes.darkThemesão definidos da seguinte forma:

class Themes {
  static ThemeData get lightTheme => ThemeData(
        colorSchemeSeed: Colors.green,
      );

  static ThemeData get darkTheme => lightTheme.copyWith(
        brightness: Brightness.dark,
      );
}

O depurador mostra que o tema escuro contém brightness: Brightness.dark.

Entretanto, tudo funciona bem quando defino o tema escuro da seguinte forma, sem copyWith:

class Themes {
  static ThemeData get lightTheme => ThemeData(
        colorSchemeSeed: Colors.green,
      );

  static ThemeData get darkTheme => ThemeData(
        colorSchemeSeed: Colors.green,
        brightness: Brightness.dark,
      );
}

Alguém poderia me apontar meu ponto cego de conhecimento sobre Dart/Flutter e explicar o que acontece?

Ambiente:

Doctor summary (to see all details, run flutter doctor -v):
[✓] Flutter (Channel stable, 3.29.3, on Microsoft Windows [Version 10.0.22631.5262], locale xx-XX)
[✓] Windows Version (11 Home 64-bit, 23H2, 2009)
[✓] Android toolchain - develop for Android devices (Android SDK version 35.0.1)
[✓] Chrome - develop for the web
[✓] Visual Studio - develop Windows apps (Visual Studio Community 2022 17.13.6)
[✓] Android Studio (version 2024.3)
[✓] VS Code (version 1.99.3)
[✓] Connected device (3 available)
[✓] Network resources

No momento, estou tentando entender metaclasses e, por isso, voltei para atualizar meu conhecimento sobre super() e type.

Enquanto atualizava, me deparei com um artigo super() do geeksforgeeks e ele tinha um exemplo um tanto estranho.

aqui está o exemplo

class Animals:
    # Initializing constructor
    def __init__(self):
        self.legs = 4
        self.domestic = True
        self.tail = True
        self.mammals = True

    def isMammal(self):
        if self.mammals:
            print("It is a mammal.")

    def isDomestic(self):
        if self.domestic:
            print("It is a domestic animal.")

class Dogs(Animals):
    def __init__(self):
        super().__init__()

    def isMammal(self):
        super().isMammal()                        <- Why do this?

Entendo que, ao herdar de uma classe pai, funções como essa __init__precisam ser chamadas para serem inicializadas, daí a pergunta: " super().__init__()mas por que fazer isso também na função?"? Eu pensava que funções eram herdadas. Isso é para que possamos executar a função pai junto com as modificações?

Por que não chamar uma função pai dentro de uma nova função?

def mammal_can_dance(self):
    self.isMammal()
    print("and can dance")

Estou tentando criar um gráfico que mostre alguns pontos de dados importantes destacados.

Conjunto de dados:

df <- structure(list(its = 1:20, pd = c(-0.521, -1.866, -0.11, 0.296, 
-0.14, -0.303, 0.141, 0.181, -0.116, 0.475, -0.117, 0.135, -0.139, 
-0.062, -0.098, 1.601, -0.093, -1.993, 2.249, 0.48)), class = "data.frame", row.names = c(NA, -20L))

Plotagem:

ggplot(df, aes(x = its, y = pd)) + 
  geom_point(size = 2, shape = 1) +
  geom_hline(yintercept = c(-1.5, 1.5)) +
  theme_bw() +
  labs(x = "", y = "")
  scale_x_discrete(limits = factor(its))

Entendi o enredo abaixo.

Meu objetivo é adicionar rótulos a vários pontos de dados com base em uma condição (pd < -1,5 ou pd > 1,5).

Então, o resultado desejado está abaixo (aviso: os rótulos não vêm apenas do itsvetor. Também quero adicioná I-los).

Estou tentando exibir dados usando rxResource. No entanto, os dados retornados são sempre indefinidos. Ao inspecionar as guias de rede, porém, vejo que os dados estão sendo buscados e que estou apenas fazendo algo errado no meu componente. Qual é o problema com este código? Porque não consigo encontrar o problema.

Serviço de API

import { HttpClient } from '@angular/common/http';
import { inject, Injectable } from '@angular/core';
import { httpResource } from "@angular/common/http";

@Injectable({
  providedIn: 'root'
})
export class ApiService {
  private readonly httpClient = inject(HttpClient);

  public GET<T>(path: string, options?: any) {
    return this.httpClient.get<T>(path, options);
  }

Arquivo de componente:

import { Component, inject, signal } from '@angular/core';
import { ApiService } from '@services/api.service';
import { rxResource, toSignal } from '@angular/core/rxjs-interop';
import { distinctUntilChanged, map } from 'rxjs';

@Component({
  selector: 'app-blogs',
  templateUrl: './blogs.component.html',
  styleUrl: './blogs.component.scss'
})
export class BlogsComponent {

  apiService = inject(ApiService)
  query = signal('')

  rxBlog = rxResource({
    request: () => this.query(),
    loader: () =>
    this.apiService.GET(`https://api.nationalize.io/?name=${this.query()}`)
    .pipe(
      distinctUntilChanged(),
      map((blogs) => blogs),
    )
  })

  search(event: Event) {
    const { value } = event.target as HTMLInputElement;
    this.query.set(value);
  }
} 
 

// Template
<p>blogs works!</p>

<input (input)="search($event)" placeholder="Search user..."/>
    
    <br />
    <ul>
      @let error = rxBlog.error();

      @if (error) {
        <p>{{ error }}</p>
      }

      @if (rxBlog.isLoading()) {
        <p>Loading Blogs...</p>
      }

      @for (blog of (rxBlog.value()).country) {
        {{blog.country_id}}
      }
      
    </ul>

Os dados JSON têm a seguinte aparência:

{
  "count": 22997,
  "name": "steve",
  "country": [
    {
      "country_id": "KE",
      "probability": 0.0728971981962264
    },
  ]
}

Tenho iterado com o Claude 3.7 Sonnet e o ChatGPT 4o por dias e dias, tentando fazer com que fique exatamente como eu quero, mas ele continua cometendo erros no algoritmo e, de vez em quando, cometendo os mesmos erros, basicamente em um círculo vicioso.

Como faço para criar um "layout" (matriz de inteiros), que representa uma grade, que tem as seguintes restrições:

1. A função é generateGridLayout(n, minColumns, maxColumns), onde na prática ela é normalmente chamada de gen(n, 3, 7), mas em teoria poderia ser qualquer coisa que formaria uma grade legal, gen(n, 2, 256)como o intervalo máximo.
2. Ele deve manipular um número arbitrário de elementos (digamos, até Number.MAX_SAFE_INTEGER, que é 9007199254740991, mas, na prática, meus "layouts de grade" terão apenas até 1000 itens).
3. Se o número de itens nfor ímpar, cada linha deverá ter apenas um número ímpar de valores. Se nfor par, cada linha poderá ter números pares ou ímpares (pense em 30, podem ser 10 linhas de 3, ou 3 linhas de 10).
4. As linhas só podem diferir 2em tamanho, sempre decrescente. Elas nunca podem diferir em 3, 4, etc. Isso significa que 7 NÃO PODE ser [5, 2] ou [4, 4, 1], pois esses têm saltos > 2. Só pode ser [7] ou [3, 3, 1], se gen(7, 3, 7).
5. (nota meta: isso é para um layout de interface de usuário, então é baseado no tamanho da janela de visualização/contêiner, então se dissermos "máximo 7", mas houver espaço apenas para 5, ele definirá o máximo como 5, mas esse fato não é realmente relevante para a solução)
6. Se dissermos "máximo é 7", mas houver um número par de itens, e o número par não puder satisfazer "todas as linhas pares ou ímpares", então tente maxColumns - 1, e assim por diante, até minColumns.
7. Importante: deve minimizar o número de linhas pequenas. Portanto, para 29, com 6 maxColumns, deve ser [5, 5, 5, 5, 5, 3, 1], e não [5, 5, 5, 5, 3, 3, 3]. Ou seja, maximiza o número de linhas grandes e minimiza o número de linhas pequenas. Da mesma forma, para 29, definitivamente não deve ser [5, 5, 5, 5, 3, 3, 1, 1, 1].

Aqui estão alguns exemplos para demonstrar o objetivo:

31
[5, 5, 5, 5, 5, 3, 3]
[3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1]

30
[5, 5, 5, 5, 5, 5]
[3, 3, 3, 3, 3, 3, 3, 3, 3, 3]

29
[5, 5, 5, 5, 5, 3, 1]
[3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 1]

28
[6, 6, 6, 6, 4]
[4, 4, 4, 4, 4, 4, 4]

27
[5, 5, 5, 5, 3, 3, 1]
[3, 3, 3, 3, 3, 3, 3, 3, 3]

26
[6, 6, 6, 4, 2, 2]
[4, 4, 4, 4, 4, 4, 4]

23
[5, 5, 5, 5, 3]
[3, 3, 3, 3, 3, 3, 3, 1, 1]

Elas mostram, se 5 ou 6 forem o máximo de colunas, o que ele faria, e o que deveria fazer se 4 ou 3 forem o máximo de colunas.

Por exemplo, 26 em 7 colunas no máximo NÃO devem ser:

[6, 6, 6, 6, 2] # jumps more than 2
[4, 4, 4, 4, 4, 4, 2] # doesn't maximize maxColumns

O ideal seria:

[6, 6, 6, 4, 2, 2] # jumps max 2, maximizes large columns, minimizes small columns.

Aqui está minha solução atual:

log(29, 2, 7)
log(29, 2, 6)
log(29, 2, 5)
log(29, 2, 4)
log(44, 2, 3)

function distributeGridLayout(
  length,
  minColumns,
  maxColumns
) {
  function recur(
    dp,
    length,
    width,
  ) {
    if (length == 0) {
      return []
    }

    if (length < width - 2 || width <= 0) {
      return
    }

    if (dp[width].has(length)) {
      return
    }

    dp[width].add(length)

    for (let i = 0; i < 2; i++) {
      let result = recur(dp, length - width, width)
      if (result) {
        return [width, ...result]
      }
      width -= 2
    }

    return
  }

  if (length <= maxColumns) {
    return [length]
  }

  if (maxColumns >= 3 && length === 7) {
    return [3, 3, 1]
  }

  if (maxColumns >= minColumns && length % maxColumns === 0) {
    const result = []
    while (length) {
      result.push(maxColumns)
      length -= maxColumns
    }
    return result
  }

  if (maxColumns > 4) {
    if (maxColumns > minColumns && length % (maxColumns - 1) === 0) {
      const result = []
      maxColumns--
      while (length) {
        result.push(maxColumns)
        length -= maxColumns
      }
      return result
    }
  }

  const dec = 2 - (length % 2)

  maxColumns -= maxColumns % dec

  const dp = Array.from(
    { length: maxColumns + 1 },
    () => new Set(),
  )

  for (let width = maxColumns; width > 0; width -= dec) {
    const result = recur(dp, length - width, width)
    if (result) {
      if (width <= minColumns) {
        return
      }
      return [width, ...result]
    }
  }

  return
}

function log(n, min, max) {
  const grid = distributeGridLayout(n, min, max)
  console.log(`gen(${n}, ${min}, ${max})`, grid)
}

Isso funciona para a maioria, como este layout tibetano (29 caracteres):

Mas não está funcionando para este layout tailandês (44 caracteres, em 2-3 colunas), aqui está o final (na minha interface, se o algoritmo retornar indefinido, ele volta para um layout de grade básico):

O que preciso mudar exatamente para que isso sempre se ajuste às minhas regras? O layout 44 de 3 no máximo e 2 minutos deve ser basicamente um layout de 2 colunas...

A comparação de iteradores begin()e de dois s que apontam para a mesma memória está bem definida?end()std::span

#include <span>
#include <cassert>

int main() {
    int arr[5]{1,2,3,4,5};
    std::span s1{arr};
    std::span s2{arr};
    assert(s1.begin() == s2.begin());
    assert(s1.end() == s2.end());
    assert(s1.begin() + s1.size() == s2.end());
}

Todas as afirmações passam em todas as implementações std::spanaté agora, mas há algo que eu possa estar esquecendo que torna isso um bug, por exemplo, UB?

Para contextualizar, isso pode ocorrer se você tiver uma classe que tenta esconder seus componentes internos com um span.

class some_class
{
public:
  std::span<int> vec_view() { return vec; }
private:
  std::vector<int> vec;
};

int main() {
    some_class c;
    std::for_each(c.vec_view().begin(), c.vec_view().end(), [](auto&){});
}

Isso está relacionado a C++ permite comparação entre std::span::iterators quando um span é um subspan do outro?, mas esta questão não é sobre um std::subspan, e além disso a std::spanversão também passa asserções MSVC, diferente da versão com o std::subspan.