All perguntas(coding)

Na minha empresa temos muitos Enums que implementam uma interface como esta:

public interface DomainEnum {
    String getDomainId();
}

@Getter
@AllArgsConstructor
public enum ExampleEnum implements DomainEnum {
  A("1"), B("2"), C("3");

  private final String domainId;
}

Gostaria de usar o MapStruct para mapear Strings para qualquer Enum implementado DomainEnumusando o domainId. Nos documentos, vi que você pode implementar uma estratégia de nomeação de enum personalizada que descreve exatamente o que eu quero. Meu problema atual é que não tenho certeza de como obter o domainIddo enum. Este é meu código até agora:

public class CustomEnumMappingStrategy extends DefaultEnumMappingStrategy {

  // other methods like in example from docs
 
  protected String getCustomEnumConstant(TypeElement enumTypeElement, String enumConstant) {
    var enumValue = getEnumValue(enumTypeElement, enumConstant);
    // How can I now get the domainId from the ElementKind?
  }

  protected ElementKind getEnumValue(TypeElement enumTypeElement, String enumConstant) {
    return enumTypeElement.getEnclosedElements().stream()
      .filter(it -> it.getKind().equals(ElementKind.ENUM_CONSTANT))
      .filter(it -> it.toString().equals(enumConstant))
      .findFirst()
      .orElse(null);
  }
}

Então, como eu poderia começar domainIddo ElementKindagora para finalizar minha estratégia de mapeamento?

Uma pergunta semelhante é feita aqui

No entanto, não pareceu funcionar no meu caso.

Tenho um dataframe com 3 colunas, data, grupos, prob. O que quero é criar uma média móvel de 3 dias dos valores da coluna prob agrupados por grupos e data. No entanto, seguindo a resposta vinculada acima, obtive todos os nulos retornados.

import polars as pl
from datetime import date
import numpy as np

dates = pl.date_range(date(2024, 12, 1), date(2024, 12, 30), "1d", eager=True).alias(
    "date")
len(dates)
days = pl.concat([dates,dates])
groups = pl.concat([pl.select(pl.repeat("B", n = 30)).to_series(),
           pl.select(pl.repeat("A", n = 30)).to_series()]).alias('groups')

data = pl.DataFrame([days, groups])

data2 = data.with_columns(pl.lit(np.random.rand(data.height)).alias("prob"))

data2.with_columns(
    rolling_mean = 
    pl.col('prob')
    .rolling_mean(window_size = 3)
    .over('date','groups')
)

"""
shape: (60, 4)
┌────────────┬────────┬──────────┬──────────────┐
│ date       ┆ groups ┆ prob     ┆ rolling_mean │
│ ---        ┆ ---    ┆ ---      ┆ ---          │
│ date       ┆ str    ┆ f64      ┆ f64          │
╞════════════╪════════╪══════════╪══════════════╡
│ 2024-12-01 ┆ B      ┆ 0.938982 ┆ null         │
│ 2024-12-02 ┆ B      ┆ 0.103133 ┆ null         │
│ 2024-12-03 ┆ B      ┆ 0.724672 ┆ null         │
│ 2024-12-04 ┆ B      ┆ 0.495868 ┆ null         │
│ 2024-12-05 ┆ B      ┆ 0.621124 ┆ null         │
│ …          ┆ …      ┆ …        ┆ …            │
│ 2024-12-26 ┆ A      ┆ 0.762529 ┆ null         │
│ 2024-12-27 ┆ A      ┆ 0.766366 ┆ null         │
│ 2024-12-28 ┆ A      ┆ 0.272936 ┆ null         │
│ 2024-12-29 ┆ A      ┆ 0.28709  ┆ null         │
│ 2024-12-30 ┆ A      ┆ 0.403478 ┆ null         │
└────────────┴────────┴──────────┴──────────────┘
""""

Na documentação, encontrei .rolling_mean_by e tentei usá-lo, mas em vez de fazer uma média móvel, ele parece apenas retornar o valor prob para cada linha.

data2.with_columns(
    rolling_mean = 
    pl.col('prob')
    .rolling_mean_by(window_size = '3d', by = 'date')
    .over('groups', 'date')
)

"""
shape: (60, 4)
┌────────────┬────────┬──────────┬──────────────┐
│ date       ┆ groups ┆ prob     ┆ rolling_mean │
│ ---        ┆ ---    ┆ ---      ┆ ---          │
│ date       ┆ str    ┆ f64      ┆ f64          │
╞════════════╪════════╪══════════╪══════════════╡
│ 2024-12-01 ┆ B      ┆ 0.938982 ┆ 0.938982     │
│ 2024-12-02 ┆ B      ┆ 0.103133 ┆ 0.103133     │
│ 2024-12-03 ┆ B      ┆ 0.724672 ┆ 0.724672     │
│ 2024-12-04 ┆ B      ┆ 0.495868 ┆ 0.495868     │
│ 2024-12-05 ┆ B      ┆ 0.621124 ┆ 0.621124     │
│ …          ┆ …      ┆ …        ┆ …            │
│ 2024-12-26 ┆ A      ┆ 0.762529 ┆ 0.762529     │
│ 2024-12-27 ┆ A      ┆ 0.766366 ┆ 0.766366     │
│ 2024-12-28 ┆ A      ┆ 0.272936 ┆ 0.272936     │
│ 2024-12-29 ┆ A      ┆ 0.28709  ┆ 0.28709      │
│ 2024-12-30 ┆ A      ┆ 0.403478 ┆ 0.403478     │
└────────────┴────────┴──────────┴──────────────┘
""""

Arquivo de entrada.

44

55



14
15

16

Quero obter um arquivo de saída.

44
44
55
55
55
55
14
15
15
16
16 

Tentei.

awk '{print $NF-1}' plik 
43
-1
54
-1
-1
-1
13
14
-1
15

Tenho um ggplotgráfico de barras com uma barra de erro, que estou colocando em ggplotly. Minha preferência é mostrar apenas o topo da barra de erro. Em ggplot2, eu simplesmente especifico o y_minda barra de erro para ser o valor da barra e ploto a barra de erro primeiro, de modo que o bigode inferior fique escondido atrás do geom_bar. No entanto, depois que executo o gráfico em ggplotly, a barra de erro é mostrada no topo. Existe uma maneira de não mostrar o bigode inferior? Procurei maneiras de alterar a ordem dos 2 traços ou opções para barras de erro "somente superiores", mas não consegui encontrar nada.

library(dplyr)
library(ggplot2)
library(plotly)

df <- data.frame(y = c(5, 10), group = c("a", "b"))
p <- ggplot(df) +
        geom_errorbar(aes(x = group, ymin = y, ymax = y + 10), linewidth = 0.1, width = 0.7) +
        geom_bar(aes(x = group, y = y), stat = "identity", fill = "lightgrey") 

# only top whisker is shown     
p 

# both top and bottom are showing
ggplotly(p) 

Span se refere a uma memória contínua, por exemplo, uma matriz;

template <typename T>
class Span {
public:
    Span(T first, size_t s) ...;
    Span(T first, T lasst) ...;
public:
    // iterating underlying continuous memory;
    begin() ...
    end() ...
    T & operator[](idx) ...
private:
    T first;
    T last;
};

A função de loop pode iterar todos os intervalos de passagem, como um loop de bolhas aninhado;

template <typename Func, typename ...Spans>
void loop(Func func, Spans &&...spans) {
    // question: how to implements ?
}

exemplo

int main() {
    int arr[] {1, 2, 3};
    float arr2[] {1.1, 2.2};
    int arr3[] {-1, -2, -3};
    
    loop(func, Span(arr, 3), Span(arr2, 2));
    /*
        we can get:
        func(1, 1.1);
        func(1, 2.2);
        func(2, 1.1);
        func(2, 2.2);
        func(3, 1.1);
        func(3, 2.2);
    */

    loop(func, Span(arr, 3), Span(arr2, 2), Span(arr3, 3));
    /*
        we can get:
        func(1, 1.1, -1);
        func(1, 1.1, -2);
        func(1, 1.1, -3);
        func(1, 2.2, -1);
        func(1, 2.2, -2);
        func(1, 2.2, -3);
        func(2, 1.1, -1);
        func(2, 1.1, -2);
        ...
    */
}

como implementar a função de loop, usando recursos da linguagem C++ até C++20 está ok, mas sem biblioteca padrão ou biblioteca de terceiros, apenas implementando manualmente;

nenhuma chamada de função de recursão, melhor for loop; faz com que a recursão facilmente cause estouro de pilha;

usando vetor e tupla, a ligação de estrutura está ok;

Quero adicionar uma propriedade CSS integer personalizada (neste exemplo eu uso -fx-foo) ao meu Label personalizado. Este é meu código:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javafx.application.Application;
import javafx.beans.property.IntegerProperty;
import javafx.css.CssMetaData;
import javafx.css.Styleable;
import javafx.css.StyleableIntegerProperty;
import javafx.css.converter.SizeConverter;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class NewMain extends Application {

    public static class FooLabel extends Label {

        private static final CssMetaData<FooLabel, Number> FOO_PROPERTY = new CssMetaData<FooLabel, Number>("-fx-foo",
                SizeConverter.getInstance(), 10) {

            @Override
            public boolean isSettable(FooLabel label) {
                return true;
            }

            @Override
            public StyleableIntegerProperty getStyleableProperty(FooLabel label) {
                return (StyleableIntegerProperty) label.fooProperty();
            }
        };

        private static final List<CssMetaData<? extends Styleable, ?>> CSS_META_DATA;

        static {
            List<CssMetaData<? extends Styleable, ?>> list = new ArrayList<>(Label.getClassCssMetaData());
            list.add(FOO_PROPERTY);
            CSS_META_DATA = Collections.unmodifiableList(list);
        }

        public static List<CssMetaData<? extends Styleable, ?>> getClassCssMetaData() {
            return CSS_META_DATA;
        }

        private final StyleableIntegerProperty foo = new StyleableIntegerProperty(10) {

            @Override
            public CssMetaData getCssMetaData() {
                return FOO_PROPERTY;
            }

            @Override
            public Object getBean() {
                return FooLabel.this;
            }

            @Override
            public String getName() {
                return "foo";
            }
        };

        public FooLabel() {
            super();
            foo.addListener((observable, oldValue, newValue) -> {
                System.out.println("NEW VALUE:" + newValue);
            });
        }

        public IntegerProperty fooProperty() {
            return foo;
        }

        public void setFoo(int foo) {
            this.foo.set(foo);
        }

        public int getFoo() {
            return foo.get();
        }
    }

    /**************** MAIN APP  *****************/

    @Override
    public void start(Stage primaryStage) {
        var fooLabel = new FooLabel();
        fooLabel.getStyleClass().add("test");
        fooLabel.setText("abc");
        VBox root = new VBox(fooLabel);
        root.getStylesheets().add(NewMain.class.getResource("test.css").toExternalForm());
        Scene scene = new Scene(root, 100, 100);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

e CSS:

.test {
    -fx-foo: 100;
    -fx-background-color: yellow;
}

O código é compilado e quando funciona não gera nenhuma exceção. O rótulo é amarelo. No entanto, a foopropriedade nunca muda, parece que -fx-fooé apenas ignorada. Alguém poderia dizer como consertar isso?

Estou tentando obter todas as combinações de linhas de uma coluna para ela mesma, mantendo os valores de uma segunda coluna.

library(dplyr)
library(tidyr)

dt0 <-
  data.frame(
    row = letters[1:10],
    n1 = c(2, 2, 1, 3, 1, 5, 1, 3, 2, 2)
  )

dt0 |>
  expand(
    row1 = row,
    row2 = row
  ) |>
  filter(row1 < row2) |>
  left_join(
    dt0 |>
      rename(n1.x = n1),
    by = join_by(row1 == row)
  ) |>
  left_join(
    dt0 |>
      rename(n1.y = n1),
    by = join_by(row2 == row)
  )

o resultado esperado é:

# A tibble: 45 × 4
   row1  row2   n1.x  n1.y
   <chr> <chr> <dbl> <dbl>
 1 a     b         2     2
 2 a     c         2     1
 3 a     d         2     3
 4 a     e         2     1
 5 a     f         2     5
 6 a     g         2     1
 7 a     h         2     3
 8 a     i         2     2
 9 a     j         2     2
10 b     c         2     1
# ℹ 35 more rows
# ℹ Use `print(n = ...)` to see more rows

Mas não sei como generalizar isso para gerar todas as combinações dos elementos das linhas do data.frame tomadas mde uma vez, então minha pergunta é: Como posso generalizar esse padrão para qualquer número de linhas em expand(...)? Por exemplo, com três

dt0 |>
  expand(
    row1 = row,
    row2 = row,
    row3 = row
  ) |>
  filter(row1 < row2) |>
  filter(row2 < row3) |>
  left_join(
    dt0 |>
      rename(n1.x = n1),
    by = join_by(row1 == row)
  ) |>
  left_join(
    dt0 |>
      rename(n1.y = n1),
    by = join_by(row2 == row)
  ) |>
  left_join(
    dt0 |>
      rename(n1.z = n1),
    by = join_by(row3 == row)
  )

# A tibble: 120 × 6
   row1  row2  row3   n1.x  n1.y  n1.z
   <chr> <chr> <chr> <dbl> <dbl> <dbl>
 1 a     b     c         2     2     1
 2 a     b     d         2     2     3
 3 a     b     e         2     2     1
 4 a     b     f         2     2     5
 5 a     b     g         2     2     1
 6 a     b     h         2     2     3
 7 a     b     i         2     2     2
 8 a     b     j         2     2     2
 9 a     c     d         2     1     3
10 a     c     e         2     1     1
# ℹ 110 more rows
# ℹ Use `print(n = ...)` to see more rows

Digamos que eu tenha uma estrutura

struct s
{
    int a;
}

e uma função principal como esta

int main()
{
    struct s s1 = {.a = 10};
    
    struct s *sptr = &s1;
    
    sptr->a--;
    printf("%d\n", sptr->a);
    
    s1.a = 10;
    
    --sptr->a;
    printf("%d\n", sptr->a);
    
    return 0;
}

Saída :

9
9

De acordo com a precedência do operador, ->eles --têm a mesma precedência e associatividade esquerda->direita.

No caso de sptr->a--, posso entender sptr->aque foi feito primeiro e depois --aplicado.

Mas no caso de --sptr->a, --deve ser aplicado a sptrprimeiro. Isso pode levar a um comportamento indefinido, mas deve ser o caso. Por que isso ainda funciona da mesma forma que sptr->a--?

Estou tentando usar polarsdataframe onde gostaria de selecionar a linha firste lastpor grupo. Aqui está um exemplo simples selecionando a primeira linha por grupo:

import polars as pl

df = pl.DataFrame(
    {
        "a": [1, 2, 2, 3, 4, 5],
        "b": [0.5, 0.5, 4, 10, 14, 13],
        "c": [True, True, True, False, False, True],
        "d": ["Apple", "Apple", "Apple", "Banana", "Banana", "Banana"],
    }
)
result = df.group_by("d", maintain_order=True).first()
print(result)

Saída:

shape: (2, 4)
┌────────┬─────┬──────┬───────┐
│ d      ┆ a   ┆ b    ┆ c     │
│ ---    ┆ --- ┆ ---  ┆ ---   │
│ str    ┆ i64 ┆ f64  ┆ bool  │
╞════════╪═════╪══════╪═══════╡
│ Apple  ┆ 1   ┆ 0.5  ┆ true  │
│ Banana ┆ 3   ┆ 10.0 ┆ false │
└────────┴─────┴──────┴───────┘

Isso funciona bem e podemos usar .lastpara fazer isso na última fileira. Mas como podemos combinar essas duas em uma group_by?

Se eu tiver o sinal de menos ao lado de uma variável como:

int a;
int b = -a; // UNARY OPERATOR
b = - a; // UNARY OPERATOR

O menos antes do 'a' é considerado um operador unário e o valor negativo de a é tomado. No entanto, neste:

int a, b;
a -b; // SUBTRACTION
a - b; // SUBTRACTION

Então, disso deduzo que:

1. É irrelevante se o operador está ou não separado do operando por um espaço.
2. A dedução de se é uma subtração ou um operador unário depende da presença de um operando anterior e é altamente contextual.

Alguém pode dar um resumo simples das regras de como o compilador decide isso?