All perguntas(coding)

Estou tentando Rcriar uma função wrapper que chame uma função interna específica (que é uma função existente) e execute algumas ações com ela. Minha função wrapper incluirá um argumento funcpara a função interna que desejo chamar, e essa função sempre terá uma estrutura padrão específica com um argumento específico de interesse, mas o argumento pode ser chamado por um nome diferente em casos diferentes. Portanto, também quero um argumento na minha função wrapper arg.nameque especifique o nome de um dos argumentos da função interna. Também quero poder especificar argumentos adicionais com reticências ...para permitir outras entradas gerais para a função interna. Aqui está um esboço do que quero fazer (mas este código não funciona):

#Example of the internal function
#This would be an existing function - not one that I program myself
#The variable n might be named something different in some cases
EXISTING.FUNCTION <- function(a, n) { a + n^2 }

#Example of the wrapper function
#It includes arg.name to specify the name of the variable
MY.WRAPPER.FUNCTION <- function(value, func, arg.name, ...) {
  
  #Evaluate the internal function using inputs wrapper inputs
  OUTPUT <- func(arg.name = value, ...)
  
  #Return the output
  OUTPUT }

Quero poder chamar a função wrapper assim:

MY.WRAPPER.FUNCTION(value = 4, func = EXISTING.FUNCTION, arg.name = 'n', a = 3)

#What I want to get
[1] 19

#What I actually get
Error in func(arg.name = value, ...) : unused argument (arg.name = value)

Não tenho certeza de como Rreconhecer a sequência de caracteres arg.namecomo o nome da variável no uso interno da função interna especificada dentro da função wrapper. Acredito que isso use uma ou mais funções de avaliação (por exemplo, substitute, quote, as.name, etc.), mas ainda não consegui modificar o código acima para que ele seja arg.namereconhecido como identificador do nome do argumento na função interna.

Informações adicionais: O texto acima foi escrito para simplificar o problema, mas, se for relevante, as funções existentes com as quais quero trabalhar são funções quantílicas para distribuições de probabilidade. Normalmente, elas terão um argumento de probabilidade chamado, pmas quero considerar a possibilidade de alguém programar uma função quantílica com um nome diferente para o argumento de probabilidade. Não tenho certeza se esse contexto é relevante para a solução, mas essa é a motivação para o problema.

Tenho um grande arquivo latex que contém uma infinidade de imagens de gráficos gerados usando as bibliotecas tikz e pstricks.

Por exemplo, imagine ter um documento como o mostrado abaixo com um número muito grande de gráficos desenhados usando tikz e psmatrix:

\documentclass{article}
\usepackage{tikz}

\usetikzlibrary{graphs}
\usetikzlibrary{graphs.standard}

\begin{document}

\begin{tikzpicture}[every node/.style={draw,circle,very thick}]
  \graph[clockwise, radius=2cm] {subgraph C_n [n=5,name=A]};
  \graph[clockwise, radius=1cm] {subgraph I_n [n=5,name=B]};

  \foreach \i in {1,2,3,4,5}{\draw (A \i) -- (B \i);}
  \newcounter{j}
  \foreach \i in {1,2,3,4,5}{%
  \pgfmathsetcounter{j}{ifthenelse(mod(\i+2,5),mod(\i+2,5),5)}
  \draw (B \i) -- (B \thej);
  }
\end{tikzpicture}

\end{document}

Preciso converter este arquivo em R Markdown. Como fazer isso?

No momento, estamos explorando a exibição de registros de data e hora com fuso horário para nossos usuários e decidimos usar essa Intl.DateTimeFormatopção timeZoneName: "shortOffset", mas agora percebemos que o valor é diferente entre os idiomas.

Quando executo esse snippet no Chrome imprimindo o fuso horário em diferentes idiomas:

["it-IT", "da-DK", "de-DE", "en-GB", "es-ES", "pl-PL", "fr-FR", "sv-SE", "nl-NL", "nb-NO", "el-GR", "fi-FI", "pt-PT", "cs-CZ", ].forEach((l) => {
  const tz = Intl.DateTimeFormat(l, {
      timeZone: "Asia/Kolkata",
      timeZoneName: "shortOffset",
    })
    .formatToParts(new Date())
    .find((p) => p.type === "timeZoneName").value;

  console.log(l, tz);
});

Obtenho este resultado:

então, por algum motivo, o francês e o finlandês estão usando o rótulo UTC e todos os outros idiomas testados estão usando GMT.

Eu realmente gostaria de saber o motivo disso. Existe alguma documentação ou banco de dados onde eu possa encontrar a configuração dos diferentes idiomas Intl.DateTimeFormat?

Sei que junções com DataFrames coparticionados não são consideradas transformações amplas. Aqui estão as definições de transformações amplas e estreitas do artigo original .

dependências estreitas, onde cada partição do RDD pai é usada por no máximo uma partição do RDD filho, dependências amplas, onde várias partições filho podem depender dela.

Mesmo que os DataFrames sejam coparticionados, isso não significa necessariamente que suas partições correspondentes estejam localizadas no mesmo nó. Por exemplo, a partição P1 de df1e P1 de df2podem residir em nós diferentes. Portanto, durante a junção, a transferência de dados (por exemplo, mover P1 de df1para o nó de P1 de df2) ainda é necessária. No entanto, isso não é considerado um embaralhamento.

Tenho duas perguntas?

1. Então, o que exatamente é um embaralhamento? Entendo que nem todas as transferências de dados de rede são consideradas embaralhadas.
2. Que tipos de transferências de dados são consideradas embaralhadas? São apenas aquelas envolvidas em transformações amplas?

TL;DR: muitas fontes citam a afirmação de que o uso excessivo de funções em linha pode, às vezes, prejudicar o desempenho do aplicativo devido ao excesso de código ou outros fatores. Existe algum exemplo real de programa que demonstre isso de forma mensurável?

Lembre-se: a missão de um microbenchmark na vida é ampliar algum aspecto do desempenho do seu programa. Por isso, qualquer pessoa pode facilmente gerar um microbenchmark que faça qualquer problema parecer um grande problema. // Dicas de Desempenho de Rico Mariani

Muitos programadores com quem converso têm a noção de que o inline de funções é incondicionalmente benéfico para o desempenho do aplicativo. O código C/C++ que analiso frequentemente tem inlinepalavras-chave (ou equivalente) aplicadas gratuitamente a funções, independentemente de seu tamanho, finalidade, popularidade ou posicionamento.

Em muitos casos, esse hábito estranho (chamado aqui de "doença do inline" ) é inofensivo para o desempenho geral: os compiladores modernos têm bom senso sobre o que realmente deve ser incorporado, e muito pouco código é quente o suficiente para que o (não)inline faça alguma diferença. Ainda assim, muitas vezes é prejudicial ao design do software resultante: mais coisas acabam nos cabeçalhos, os arquivos não são mais compiláveis ​​independentemente, etc.

Embora seja bastante fácil demonstrar que a aplicação aleatória sem benchmarking contínuo não faz nenhuma diferença mensurável no desempenho final, estou procurando um exemplo extremo em que forçar a questão prejudica estritamente o desempenho.

Um microbenchmark será suficiente; embora não prove nada sobre os efeitos do inline em aplicações do mundo real, deve demonstrar de forma comprovada que aplicá-lo cegamente não é uma boa ideia incondicional . Essa é realmente a ideia por trás de quase qualquer processo de otimização de código: pode ajudar, pode prejudicar e, às vezes, não faz diferença.

Alguns requisitos para tal exemplo de microbenchmark.

1. Deve ser um programa razoavelmente curto, de preferência em C ou C++; outras linguagens nas quais o inlining pode ser aplicado também são bem-vindas.
2. Não precisa ser um programa fazendo algo útil, ele pode fazer coisas "bobas" só para carregar/estressar o hardware subjacente.
3. Deve ser possível compilá-lo em dois modos: com inlining imposto e inlining desabilitado. Qualquer técnica para conseguir isso pode ser usada: compilação condicional para redefinir anotações de inlining, sinalizadores de backend do compilador para controlar o inlining, etc.
4. Ele deve ser bem formado e exibir o mesmo comportamento bem definido, independentemente de em qual dos dois modos ele for compilado.
5. Ele deve conter pelo menos duas funções, uma chamando a outra, com a intenção de afetar o inlining de pelo menos uma delas.
6. Pode conter qualquer técnica para garantir/impor a inclusão de funções em linha. Por exemplo, inlineextensões padrão de palavras-chave ou específicas do compilador ( __forceinline, __attribute__ ((always_inline))etc.) podem ser usadas para instruir o compilador a fazê-lo, independentemente de seu julgamento.
7. Ao executar, o desempenho (latência, tempo de execução ou métrica semelhante) pode ser facilmente reportado. Pode ser apenas usando time a.out, ou chamadas internas para um recurso de temporização em torno do código afetado.
8. Por fim, quando compilado por pelo menos um compilador específico de uma versão específica e executado em pelo menos um sistema de destino, as duas variantes resultantes do programa exibem diferenças estatisticamente significativas, e a compilação forçada em linha é mais lenta do que a compilação não em linha .

Eu percebo que o desempenho depende muito dos parâmetros do host; o que é mais lento em uma máquina pode se tornar tão rápido quanto ou mais rápido em outra. Mas estou buscando o pior cenário, quando o inlining irrestrito for comprovadamente contraproducente.

O ideal é que outras opções de backend do compilador que não afetam o inlining (como nível geral de otimização etc.) sejam as mesmas para duas compilações, a fim de excluir a possibilidade de que a diferença observável seja explicada por elas e não pelo inlining aplicado/ignorado.

Tenho uma ideia de um ponto de partida para esse programa, mas preciso de mais ajuda para desenvolvê-lo:

1. Uma função interna é grande o suficiente para quase não caber no cache de instruções da CPU.
2. Uma função externa é grande o suficiente para que, se a função interna for incorporada à força, a seção de código resultante se torne maior que o cache de instruções da CPU.
3. O fluxo de controle do programa é organizado de tal forma que, quando tudo é incorporado, ele sofre uma frequência maior de falhas de cache de instruções, liberações de cache ou eventos semelhantes que não aconteceriam se o embutimento não fosse imposto.

Tenho dois ggplotobjetos como abaixo.

library(ggplot2)

set.seed(1)
dat1 = data.frame(x = rnorm(1000), y = rnorm(1000))
dat2 = data.frame(x = rt(5000, 2))

Plot1 = ggplot(data = dat1, aes(x = x, y = y)) + geom_point()
Plot2 = ggplot(dat2) + geom_histogram(aes(x = x))

Agora eu gostaria de sobrepor Plot2na Plot1parte central esquerda de Plot1. Saída desejada

Para melhor visibilidade, também desejo ter alguma transparência Plot2para que Plot1não fique completamente mascarado na região de sobreposição.

Existe alguma maneira de fazer isso? Pesquisei informações relevantes na internet, mas todas parecem se referir à adição de camadas. Meu gráfico final será diferente de apenas adicionar camadas.

Considerando que o tipo Aé definido assim:

typedef struct a { const int a; } A;

Eu sei que este código é válido:

A * foo = malloc(sizeof *foo); // Allocates uninitialized memory with no effective type
memcpy(foo, &(typeof(*foo)){ .a = 42, }, sizeof *foo); // Effectively initialize the value once

(veja https://stackoverflow.com/a/79012045/13242312 )

Mas ainda é válido com allocainstead of mallocse quisermos que o valor esteja na pilha em vez do heap?

Caso de uso: Quero um único caminho de retorno em minha função, então quero definir a variável de resultado no escopo da função

A A_new(void) {
  A * a = alloca(sizeof *a);

  if (/* something */) {
    memcpy(a, &(typeof(*a)){.a = 1}, sizeof *a);
  } else {
    memcpy(a, &(typeof(*a)){.a = 2}, sizeof *a);
  }

  return *a;
}

Não tenho certeza de qual é a utilidade do URL de login, como visto aqui:

https://learn.microsoft.com/en-us/entra/identity/enterprise-apps/media/add-application-portal-setup-sso/saml-configuration.png

(Fonte: https://learn.microsoft.com/en-us/entra/identity/enterprise-apps/add-application-portal-setup-sso )

Editar: Na imagem acima, o URL de login está marcado como required, mas no meu caso diz optional.

Pelo que entendi, se eu configurar essa URL, ela redirecionará a resposta SAML de volta para essa URL em vez do ACS para login posterior no lado do SP.

Então, se, por exemplo, meu aplicativo precisar de uma página de login após ser autenticado pelo IDP, ele será redirecionado para uma página de login.

Mas por que não posso simplesmente usar o ACS para redirecionar para uma página de login?

Tentando validar o tempo limite de consultas ao banco de dados, não é possível obtê-lo via HttpTestingController.

Não tenho certeza de como projetar o UT. Onde adicionar o tempo limite nesta configuração?

    it('test timeout', () => {

        service.getData('2025-10-12', '2025-10-16').subscribe(
            {
                next: data => {
                    expect(data).not.toBeNull();
                },
                error: error => {
                    expect(error).toBeNull(); // handling all missing keys
                }
            }
        );

        // mocking endpoint - binding
        const response = httpController.expectOne({
            method: 'GET',
            url: RestServerSA.RELEASES_OVERVIEW_RANGE
        });

        // mocking response from endpoint
        response.flush({});
    });

Tenho um valor que foi criptografado usando PHP openssl usando a cifra AES-CBC-256, mas a senha para o valor final também foi criptografada usando o mesmo método.openssl_encrypt($key, $cipher, $passphrase, 0, $iv)

Preciso conseguir descriptografar esses dados usando Python, mas estou tendo problemas com o tamanho do bloco.

Aqui está parte do código que tenho até agora. Testei descriptografá-lo em PHP e funciona corretamente. Meu valor final neste exemplo deve ser "Jimmy".

import base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad

localKey = base64.b64decode('Po0KPxyF')
localIv = base64.b64decode('s8W+/a4jkp9mhO3NkCL7Yg==')

encrypted_value = base64.b64decode('hl5n6Nq5QYtgKIyLEVCupA==')
encrypted_key = base64.b64decode('MGRHRFlaMzhCR0lxb2VHS1JHQXcrWkV2bkJpNWFZb3cybW9iQW5KYTlOU0xKK1FHc2pPUW1MUE9JRU5zTXN1Rg==')
encrypted_iv = base64.b64decode('J31SrExr7KKIOertYIPhpQ==')

# First need to encrypted key that uses the local key as the passphrase
cipher_key = AES.new(pad(localKey,16), AES.MODE_CBC, localIv)
decrypted_key = cipher_key.decrypt(encrypted_key)

# Then decrypted the final value using the newly decrypted key
cipher_key = AES.new(unpad(decrypted_key,16), AES.MODE_CBC, encrypted_iv)
decrypted_value = cipher_key.decrypt(encrypted_value)