All perguntas(coding)

Tenho um script bash que pega um arquivo de propriedades simples e substitui os valores em outro arquivo. (O arquivo de propriedades é apenas linhas de propriedades do tipo 'foo=bar')

INPUT=`cat $INPUT_FILE`
while read line; do
   PROP_NAME=`echo $line | cut -f1 -d'='`
   PROP_VALUE=`echo $line | cut -f2- -d'=' | sed 's/\$/\\\$/g`
   time INPUT="$(echo "$INPUT" | sed "s\`${PROP_NAME}\b\`${PROP_VALUE}\`g")"
done <<<$(cat "$PROPERTIES_FILE")
# Do more stuff with INPUT

No entanto, quando minha máquina tem carga alta (mais de quarenta anos), tenho uma grande perda de tempo em meus seds

real  0m0.169s
user  0m0.001s
sys  0m0.006s

Baixa carga:

real  0m0.011s
user  0m0.002s
sys  0m0.004s

Normalmente, perder 0,1 segundo não é um grande problema, mas tanto o arquivo de propriedades quanto os arquivos de entrada têm centenas/milhares de linhas e esses 0,1 segundo somam mais de uma hora de tempo desperdiçado.

O que posso fazer para consertar isso? Preciso apenas de mais CPUs?

Propriedades de exemplo (as linhas começam com um caractere especial para criar uma maneira de indicar que algo na entrada está tentando acessar uma propriedade)

$foo=bar
$hello=world
^hello=goodbye

Entrada de amostra

This is a story about $hello. It starts at a $foo and ends in a park.

Bob said to Sally "^hello, see you soon"

Resultado esperado

This is a story about world. It starts at a bar and ends in a park.

Bob said to Sally "goodbye, see you soon"

Esta é uma pergunta de acompanhamento desta resposta de QA . Eu uso o Racket v8.16.

Para doc1 :compile_time_instantiation.rkt​

(module compile-time-number racket/base
  (require (for-syntax racket/base))
  (begin-for-syntax
    (printf "picked ~a\n" (random)))
  (printf "running\n"))

Então:

$ racket -i -e '(dynamic-require "compile_time_instantiation.rkt" #f)'
Welcome to Racket v8.16 [cs].
picked 0.015421409441077423
running
$ racket -i -e '(require "compile_time_instantiation.rkt")'
Welcome to Racket v8.16 [cs].
picked 0.14007121863188537
running
picked 0.7200261945290138
$ racket -i
Welcome to Racket v8.16 [cs].
> (require "compile_time_instantiation.rkt")
picked 0.7451208846143317
running
$ racket compile_time_instantiation.rkt
picked 0.9883107842338839
running

doc1 diz:

Enquanto isso, dynamic-require apenas instancia um módulo; ele não visita o módulo . Essa simplificação é o motivo pelo qual alguns dos exemplos anteriores usam dynamic-require em vez de require .

Quando um módulo é instanciado, as expressões de tempo de execução em seu corpo são avaliadas .

Então o extra "picked ..." no 2º comando é da visita extra de requirebeyond quando da expansão:

Quando um módulo é visitado, as expressões de tempo de compilação (como a definição de macro) em seu corpo são avaliadas.

À medida que um módulo é expandido , ele é visitado .

As expressões de tempo de compilação de um módulo que são avaliadas pela visita incluem os lados direitos dos formulários define-syntax e o corpo dos formulários begin-for-syntax .

Mas por que o 3º não tem isso?

Estou testando o recurso Vaadin Copilot AI no Windows 11 com o Vaadin Flow e pedindo para ele executar o seguinte comando:

Create an empty LocationView class with one button on the screen named 'Test'.

E em resposta, recebo um erro:

Error parsing JSON: Unable to write file - JSON chunk that failed

Detalhes:

2025-04-02T02:17:19.100+03:00  INFO 32644 --- [ctor-http-nio-7] com.vaadin.copilot.ai.AICommandHandler   : Parsed JSON: StreamResponse[status=VALIDATION, message=Validation finished, exception=, changes={}, code=1]
2025-04-02T02:17:19.757+03:00  INFO 32644 --- [ctor-http-nio-7] com.vaadin.copilot.ai.AICommandHandler   : Parsed JSON: StreamResponse[status=PRE_PROCESS, message=Flow Source modified, exception=, changes={}, code=2]
2025-04-02T02:17:20.478+03:00  INFO 32644 --- [ctor-http-nio-7] com.vaadin.copilot.ai.AICommandHandler   : Parsed JSON: StreamResponse[status=EMBEDDING_CONTEXT, message=Embedding context retrieval finished, exception=, changes={}, code=2]
2025-04-02T02:17:22.617+03:00  INFO 32644 --- [ctor-http-nio-7] com.vaadin.copilot.ai.AICommandHandler   : Parsed JSON: StreamResponse[status=AI_CALL, message=AI call finished, exception=, changes={}, code=2]
2025-04-02T02:17:22.618+03:00  INFO 32644 --- [ctor-http-nio-7] com.vaadin.copilot.ai.AICommandHandler   : Parsed JSON: StreamResponse[status=POST_PROCESS, message=Post-process finished, exception=, changes={src\main\java\ai\example\base\ui\view\LocationView.java=package ai.example.base.ui.view;

import com.vaadin.flow.component.button.Button;
import com.vaadin.flow.component.orderedlayout.VerticalLayout;
import com.vaadin.flow.router.Route;

@Route("location")
public class LocationView extends VerticalLayout {

    public LocationView() {
        Button testButton = new Button("Test");
        add(testButton);
    }
}
}, code=2]
2025-04-02T02:17:22.619+03:00  INFO 32644 --- [ctor-http-nio-7] com.vaadin.copilot.ai.AICommandHandler   : PostProcess finished
2025-04-02T02:17:22.620+03:00 ERROR 32644 --- [ctor-http-nio-7] com.vaadin.copilot.ai.AICommandHandler   : Error parsing JSON: Unable to write file (src\main\java\ai\example\base\ui\view\LocationView.java) with data from copilot server response - JSON chunk that failed: {"status":"POST_PROCESS","message":"Post-process finished","exception":"","changes":{"src\\main\\java\\ai\\example\\base\\ui\\view\\LocationView.java":"package ai.example.base.ui.view;\n\nimport com.vaadin.flow.component.button.Button;\nimport com.vaadin.flow.component.orderedlayout.VerticalLayout;\nimport com.vaadin.flow.router.Route;\n\n@Route(\"location\")\npublic class LocationView extends VerticalLayout {\n\n    public LocationView() {\n        Button testButton = new Button(\"Test\");\n        add(testButton);\n    }\n}\n"},"code":2}

O que estou fazendo errado e qual pode ser o motivo disso?

Uma nova ferramenta de geração de código recebe apenas uma entrada - n, o tamanho de um array de entrada. A ferramenta deve então gerar um programa de árvore de decisão simples que contém 2 tipos de nós:

• nó de decisão com comparação estrita
• nó de saída (folha)

O nó de decisão compara dois elementos de uma matriz de entrada usando 1 de 3 operadores - <, =, >. Combinações desses operadores NÃO são permitidas. Usar operadores booleanos extras como NOT, AND, OR também não é permitido.

Um nó de saída especifica quais elementos retornar do array de entrada. Esses elementos devem ter todos o mesmo valor e esse valor é o mínimo de todo o array de entrada.

Até agora, tentei usar uma abordagem baseada em pilha que gera código correto para array de entrada de comprimento 2, mas falha para cada comprimento maior. A saída se parece com isso:

if input[0] < input[1]:
    return input[0]
else:
    if input[0] == input[1]:
        return input[0, 1]
    else:
        return input[1]

Aqui está meu código:

Node.kt

import ComparisonOperator.*

enum class ComparisonOperator {
    LESS_THAN, EQUALS, GREATER_THAN
}

class Node (
    val trueBranch: Node? = null,
    val falseBranch: Node? = null,
    val operator: ComparisonOperator = LESS_THAN,
    val indices: IntArray = intArrayOf()
)

imprimir.kt

import TaskType.*

enum class TaskType {
    PROCESS_NODE,
    PROCESS_ELSE
}

data class StackEntry(val node: Node, val indent: Int, val taskType: TaskType)

fun generatePythonCode(root: Node): String {
    val builder = StringBuilder()
    val stack = ArrayDeque<StackEntry>()
    stack.addLast(StackEntry(root, 0, PROCESS_NODE))

    while (stack.isNotEmpty()) {
        val entry = stack.removeLast()
        val node = entry.node
        val indent = entry.indent
        val indentStr = "    ".repeat(indent)

        when (entry.taskType) {
            PROCESS_NODE -> {
                if (node.trueBranch == null) {
                    // Leaf node: output the return statement.
                    val indices = node.indices.joinToString(", ")
                    builder.append(indentStr).append("return input[").append(indices).append("]\n")
                } else {
                    // Decision node: output an if statement.
                    val left = "input[${node.indices[0]}]"
                    val right = "input[${node.indices[1]}]"
                    val op = when (node.operator) {
                        ComparisonOperator.LESS_THAN -> "<"
                        ComparisonOperator.EQUALS -> "=="
                        ComparisonOperator.GREATER_THAN -> ">"
                    }
                    builder.append(indentStr).append("if ").append(left).append(" $op ").append(right).append(":\n")
                    // Push the false branch as an else task (it will add the "else:" line).
                    stack.addLast(StackEntry(node.falseBranch!!, indent, PROCESS_ELSE))
                    // Then push the true branch for processing with increased indent.
                    stack.addLast(StackEntry(node.trueBranch, indent + 1, PROCESS_NODE))
                }
            }
            PROCESS_ELSE -> {
                // For an else task, output the "else:" line and then process the node.
                builder.append(indentStr).append("else:\n")
                stack.addLast(StackEntry(node, indent + 1, PROCESS_NODE))
            }
        }
    }
    return builder.toString().trimEnd()
}

codegen.kt

import ComparisonOperator.*

enum class FrameType {
    EQUALITY,
    MERGE
}

// Each frame holds the current candidate groups (each a List<Int>).
// When the number of candidate groups is 1, a leaf (output) node is produced.
// Otherwise, two candidate groups are extracted and processed.
data class Frame(
    val candidates: List<List<Int>>,
    val type: FrameType,
    var step: Int = 0,
    var group1: List<Int>? = null,
    var group2: List<Int>? = null,
    var rest: List<List<Int>> = emptyList(),
    // For a MERGE frame, we need:
    // branchTrue: result for candidate list [group1] + rest.
    // branchEquality (i.e. the nested equality decision) will be built from two subbranches.
    // For an EQUALITY frame, we only need branchTrue and branchFalse.
    var branchTrue: Node? = null,
    var branchFalse: Node? = null,
    // Temporary field to hold a generated child result.
    var tempResult: Node? = null
)

// The function generateMinProgram builds the decision tree (as Node objects) that, when interpreted,
// returns the indices of all occurrences of the minimum element from the input array.
// It uses a brute-force backtracking strategy based on a stack.
fun generateMinProgram(n: Int): Node {
    // Assume n >= 2. Initially, each candidate group is a single index.
    val initialCandidates = (0 until n).map { listOf(it) }
    val stack = ArrayDeque<Frame>()
    // The outermost decision is always a MERGE.
    stack.add(Frame(candidates = initialCandidates, type = FrameType.MERGE))

    // The iterative DFS: process the frames until the root decision is built.
    var result: Node? = null

    while (stack.isNotEmpty()) {
        val current = stack.last()
        // If the candidate list has only one candidate group, create a leaf (output) node.
        if (current.candidates.size == 1) {
            // This candidate group represents the indices that are equal to the minimum.
            result = Node(
                trueBranch = null,
                falseBranch = null,
                // For output nodes the operator value is not used.
                operator = LESS_THAN,
                indices = current.candidates.first().toIntArray()
            )
            stack.removeLast()
            if (stack.isNotEmpty()) {
                // Propagate the result to the parent frame.
                stack.last().tempResult = result
            } else {
                // No parent exists; this would happen if n==1 (but we assume n>=2).
                return result
            }
            continue
        }

        // Otherwise, there is at least a decision to be made.
        when (current.type) {
            FrameType.MERGE -> {
                // MERGE frame has three main phases.
                when (current.step) {
                    0 -> {
                        // Initialize: pick the first two candidate groups.
                        current.group1 = current.candidates[0]
                        current.group2 = current.candidates[1]
                        current.rest = if (current.candidates.size > 2) current.candidates.subList(2, current.candidates.size) else emptyList()
                        // Process the "true" branch for the primary decision:
                        // if input[group1[0]] < input[group2[0]] then the winner is group1.
                        val trueCandidates = listOf(current.group1!!) + current.rest
                        // New frame for processing the "true" branch.
                        stack.add(Frame(candidates = trueCandidates, type = FrameType.MERGE))
                        current.step = 1
                    }
                    1 -> {
                        // Coming back from the "true" branch.
                        current.branchTrue = current.tempResult
                        current.tempResult = null
                        // Next, process the nested equality decision.
                        // Create a new EQUALITY frame.
                        // For equality: if input[group1[0]] == input[group2[0]], then we merge group1 and group2.
                        // The candidate list becomes [group1 U group2] + rest.
                        val merged = current.group1!! + current.group2!!
                        val eqCandidates = listOf(merged) + current.rest
                        stack.add(Frame(candidates = eqCandidates, type = FrameType.EQUALITY))
                        current.step = 2
                    }
                    2 -> {
                        // Returning from the equality branch's "true" part (for the equality decision).
                        // In a MERGE frame, we now go to process the "false" branch of the nested equality:
                        current.branchTrue = current.branchTrue // holds nothing new; we now reuse the equality structure.
                        // For the "false" branch of the equality decision (i.e. when input[group1[0]] is not equal to input[group2[0]])
                        // we take group2 as the winner. Candidate list becomes [group2] + rest.
                        val falseCandidates = listOf(current.group2!!) + current.rest
                        stack.add(Frame(candidates = falseCandidates, type = FrameType.EQUALITY))
                        current.step = 3
                    }
                    3 -> {
                        // Coming back from the equality frame "false" branch.
                        current.branchFalse = current.tempResult
                        current.tempResult = null
                        // Build the nested equality decision node.
                        // This node has operator EQUALS and compares the same indices from group1 and group2.
                        val eqNode = Node(
                            trueBranch = current.tempResult ?: run {
                                // The true branch result is already stored in branch from the equality frame "true",
                                // which was set when processing the equality frame. In this MERGE frame, we expect the equality
                                // decision to have been constructed by processing the two equality branches.
                                // Here we use current.branchTrue that was computed in step 2.
                                current.branchTrue
                            },
                            falseBranch = current.branchFalse,
                            operator = EQUALS,
                            indices = intArrayOf(current.group1!![0], current.group2!![0])
                        )
                        // Build the primary decision node.
                        val mergeNode = Node(
                            trueBranch = current.branchTrue,
                            falseBranch = eqNode,
                            operator = LESS_THAN,
                            indices = intArrayOf(current.group1!![0], current.group2!![0])
                        )
                        stack.removeLast() // Done with current MERGE frame.
                        if (stack.isNotEmpty()) {
                            stack.last().tempResult = mergeNode
                        } else {
                            return mergeNode
                        }
                    }
                }
            }
            FrameType.EQUALITY -> {
                // EQUALITY frame has two phases.
                when (current.step) {
                    0 -> {
                        // In an EQUALITY frame the comparison is always on the two groups that formed the candidate list.
                        // Since we always pass a candidate list with at least one candidate, if there are at least two,
                        // then we perform a decision test.
                        current.group1 = current.candidates[0]
                        current.group2 = current.candidates[0] // In an equality frame candidate list is built from either merged groups or single group2.
                        // For an EQUALITY frame, if there is more than one candidate group then we consider the first two.
                        // However, in our usages we've built the candidate list so that its size should be 1.
                        // To support a generic approach we check:
                        if (current.candidates.size >= 2) {
                            current.group2 = current.candidates[1]
                            current.rest = if (current.candidates.size > 2) current.candidates.subList(2, current.candidates.size) else emptyList()
                        } else {
                            // If candidate list size is 1, then we are at a leaf even in an equality frame.
                            val leaf = Node(
                                trueBranch = null,
                                falseBranch = null,
                                operator = EQUALS,
                                indices = current.candidates.first().toIntArray()
                            )
                            stack.removeLast()
                            if (stack.isNotEmpty()) {
                                stack.last().tempResult = leaf
                            } else {
                                return leaf
                            }
                            continue
                        }
                        // Process the "true" branch of the equality decision:
                        // If input[group1[0]] == input[group2[0]], then the result candidate list remains as-is.
                        // (In our usage, for the equality branch, candidate list is already merged.)
                        val trueCandidates = current.candidates
                        stack.add(Frame(candidates = trueCandidates, type = FrameType.EQUALITY))
                        current.step = 1
                    }
                    1 -> {
                        // Return from the "true" branch.
                        current.branchTrue = current.tempResult
                        current.tempResult = null
                        // Process the "false" branch:
                        // In our usage, the "false" branch for an EQUALITY decision comes from a candidate list built for group2.
                        // We expect that candidate list to have a single candidate group.
                        val falseCandidates = if (current.candidates.size >= 2) {
                            // Use the second candidate alone alongside any remaining candidates.
                            listOf(current.candidates[1]) + current.rest
                        } else {
                            current.candidates
                        }
                        stack.add(Frame(candidates = falseCandidates, type = FrameType.EQUALITY))
                        current.step = 2
                    }
                    2 -> {
                        // Return from the "false" branch.
                        current.branchFalse = current.tempResult
                        current.tempResult = null
                        // Build the equality decision node.
                        val eqNode = Node(
                            trueBranch = current.branchTrue,
                            falseBranch = current.branchFalse,
                            operator = EQUALS,
                            indices = intArrayOf(current.candidates[0][0], if (current.candidates.size >= 2) current.candidates[1][0] else current.candidates[0][0])
                        )
                        stack.removeLast()
                        if (stack.isNotEmpty()) {
                            stack.last().tempResult = eqNode
                        } else {
                            return eqNode
                        }
                    }
                }
            }
        }
    }
    // Should never reach here.
    return result!!
}

principal.kt

fun main() {
    val root = generateMinProgram(2)
    val code = generatePythonCode(root)
    println(code)
}

Não estou pedindo para você consertar meu código. Em vez disso, o que estou procurando é uma descrição de um algoritmo de alto nível e suas estruturas de dados. Talvez uma solução de backtracking seja suficiente?

Também é um problema XY porque o que eu realmente preciso é de uma resposta para a pergunta Como podemos derivar a fórmula para os nós de decisão estrita mínima na matriz Minimum-Finding? que não teve muitas visualizações, então estou tentando descobrir a fórmula forçando brutamente a etapa de geração de código.

Estou usando Hibernate no meu aplicativo Java e simplesmente não consigo me livrar dessa ClassNotFoundException com JAXB. Eu literalmente tentei de tudo, mas não consigo consertar.

Estou usando Java 21.

Aqui está o erro que recebo:

    Caused by: jakarta.xml.bind.JAXBException: Implementation of Jakarta XML Binding-API has not been found on module path or classpath.
    at jakarta.xml.bind.ContextFinder.newInstance(ContextFinder.java:252) ~[?:?]
    at jakarta.xml.bind.ContextFinder.newInstance(ContextFinder.java:240) ~[?:?]
    at jakarta.xml.bind.ContextFinder.find(ContextFinder.java:381) ~[?:?]
    at jakarta.xml.bind.JAXBContext.newInstance(JAXBContext.java:605) ~[?:?]
    at jakarta.xml.bind.JAXBContext.newInstance(JAXBContext.java:546) ~[?:?]
    at org.hibernate.boot.cfgxml.internal.JaxbCfgProcessor.unmarshal(JaxbCfgProcessor.java:121) ~[?:?]
    ... 25 more
Caused by: java.lang.ClassNotFoundException: org.glassfish.jaxb.runtime.v2.ContextFactory
    at java.base/java.net.URLClassLoader.findClass(URLClassLoader.java:445) ~[?:?]
    at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:593) ~[?:?]
    at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:526) ~[?:?]
    at jakarta.xml.bind.ServiceLoaderUtil.nullSafeLoadClass(ServiceLoaderUtil.java:113) ~[?:?]
    at jakarta.xml.bind.ServiceLoaderUtil.safeLoadClass(ServiceLoaderUtil.java:146) ~[?:?]
    at jakarta.xml.bind.ContextFinder.newInstance(ContextFinder.java:250) ~[?:?]
    at jakarta.xml.bind.ContextFinder.newInstance(ContextFinder.java:240) ~[?:?]
    at jakarta.xml.bind.ContextFinder.find(ContextFinder.java:381) ~[?:?]
    at jakarta.xml.bind.JAXBContext.newInstance(JAXBContext.java:605) ~[?:?]
    at jakarta.xml.bind.JAXBContext.newInstance(JAXBContext.java:546) ~[?:?]
    at org.hibernate.boot.cfgxml.internal.JaxbCfgProcessor.unmarshal(JaxbCfgProcessor.java:121) ~[?:?]
    ... 25 more

E aqui está meu arquivo POM completo:

    <groupId>org.test.project</groupId>
    <artifactId>project-core</artifactId>
    <version>1.0-SNAPSHOT</version>

    <name>project-core</name>
    <description>test project</description>

    <repositories>
        <repository>
            <id>spigot-repo</id>
            <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
        </repository>
        <repository>
            <id>minecraft-repo</id>
            <url>https://libraries.minecraft.net/</url>
        </repository>
    </repositories>

    <dependencies>
        <dependency>
            <groupId>org.spigotmc</groupId>
            <artifactId>spigot-api</artifactId>
            <version>1.21.4-R0.1-SNAPSHOT</version>
            <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.hibernate.orm/hibernate-core -->
        <dependency>
            <groupId>org.hibernate.orm</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>6.6.12.Final</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.mysql/mysql-connector-j -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>9.2.0</version>
        </dependency>
    </dependencies>

    <build>
        <defaultGoal>clean install</defaultGoal>
        <resources>
            <resource>
                <directory>${project.basedir}/src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
        <plugins>
            <!-- Maven Compiler Plugin -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>21</source>
                    <target>21</target>
                </configuration>
            </plugin>

            <!-- Maven Shade Plugin -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

Observe que removi as dependências JAXB neste arquivo POM, mas já tentei adicionar a API JAXB e a implementação de tempo de execução e ele continuou me dando esse erro. Como eu disse antes, descompilei meu arquivo JAR e org.glassfish.jaxb.runtime.v2.ContextFactory foi compilado corretamente, pois faz parte da dependência do Hibernate.

Estas são as dependências que tentei adicionar antes:

<dependency>
    <groupId>jakarta.xml.bind</groupId>
    <artifactId>jakarta.xml.bind-api</artifactId>
    <version>4.0.0</version> 
</dependency>
<!-- JAXB Reference Implementation -->
<dependency>
    <groupId>org.glassfish.jaxb</groupId>
    <artifactId>jaxb-runtime</artifactId>
    <version>4.0.0</version> 
    <scope>runtime</scope>
</dependency>

Também tentei várias versões dessas dependências. E tentei as dependências sun que também não funcionaram.

Tentei incluir classpaths no arquivo MANIFEST.mf - isso não resolveu o problema. E tentei usar a dependência Moxy do Eclipse em vez de JAXB (e incluí jaxb.properties), isso também não resolveu o problema.

Além disso, tentei adicionar as dependências do jaxb e excluí-las da dependência do Hibernate para garantir que não fossem conflitantes, mas isso também não resolveu o problema.

Tentei executá-lo em várias versões do Java e, como você pode imaginar, também não obtive sucesso.

Eu tentei todas as coisas possíveis para me livrar do java.lang.ClassNotFoundException: org.glassfish.jaxb.runtime.v2.ContextFactory e fazer o Hibernate funcionar, mas eu simplesmente não consigo consertá-lo. O que mais eu posso tentar? Ajuda é muito apreciada!

Estou tentando construir o GMP no Windows, usando o Cygwin64. Eu executo ./configuresem problemas, mas makeimprime algumas bobagens:

C:/cygwin64/bin/sh.exe ../libtool --mode=compile --tag=CC ../mpn/m4-ccas --m4="m4" gcc -c -DHAVE_CONFIG_H -I. -I..  -D__GMP_WITHIN_GMP -I.. -DOPERATION_`echo invert_limb_table | sed 's/_$//'`   -O2 -pedantic -fomit-frame-pointer -m64 -mtune=k8 -march=k8  `test -f 'invert_limb_table.asm' || echo './'`invert_limb_table.asm
libtool: compile:  ../mpn/m4-ccas "--m4=m4 gcc" -c -DHAVE_CONFIG_H -I. -I.. -D__GMP_WITHIN_GMP -I.. -DOPERATION_invert_limb_table -O2 -pedantic -fomit-frame-pointer -m64 -mtune=k8 -march=k8 invert_limb_table.asm -o invert_limb_table.o
m4 gcc  -DHAVE_CONFIG_H -D__GMP_WITHIN_GMP -DOPERATION_invert_limb_table invert_limb_table.asm >tmp-invert_limb_table.s

antes de imprimir m4: cannot open `gcc': No such file or directorye dar erro. Isso é estranho, pois eu definitivamente tenho o GCC instalado, o que é confirmado por eu conseguir executar gcc. O que está acontecendo aqui e como posso consertar?

Gostaria de importar elementos opcionais da GUI definidos em arquivos .py separados e adicioná-los/remover dinamicamente da GUI principal. Os elementos opcionais são definidos em um arquivo de configuração de texto e, portanto, os nomes dos arquivos não são conhecidos antecipadamente. Minha ideia original era impor um formato comum - a classe principal seria nomeada de forma idêntica em todos os arquivos de módulo. Descobri que a implementação mais simples disso se comporta de forma inesperada. Embora os objetos importados pareçam ter nomes distintos, há, de fato, diafonia. Isso demonstra o problema e uma solução alternativa que encontrei no SE (comentada):

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()

        if "1" in hint:
            self.module = importlib.import_module("Mod1").Module()#PROBLEMATIC
            #module = importlib.import_module("Mod1")
            #class_ = getattr(module, "Module1")
            #self.module = class_()
        if "2" in hint:
            self.module = importlib.import_module("Mod2").Module()#PROBLEMATIC
            #module = importlib.import_module("Mod2")
            #class_ = getattr(module, "Module2")
            #self.module = class_()
            
        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('''
#<Module1>:
<Module>: #PROBLEMATIC  
    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)])
''')

#class Module1(FloatLayout):
class Module(FloatLayout): #PROBLEMATIC

    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('''
#<Module2>:
<Module>: #PROBLEMATIC
    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)])
''')

#class Module2(FloatLayout):
class Module(FloatLayout): #PROBLEMATIC

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

Parece que, embora os módulos tenham nomes distintos Mod1e Mod2, a classe principal ter o mesmo nome é um problema. Uma vez que ambos os módulos foram importados pelo menos uma vez, ambos aparecem na GUI, independentemente de qual deles está realmente ativado.

Embora minha solução alternativa funcione para evitar esse comportamento indesejado, gostaria de saber o que o causa. Isso tem a ver com como a importação funciona no Python em geral ou com um problema específico do Kivy? Existe outra maneira de lidar com isso que permitiria classes com nomes idênticos em módulos distintos?

Tenho tentado produzir um gráfico semelhante a este usando ggplot2:

E este é meu código R:

df <- data.frame(
  tecnica = factor(rep(1:4, each = 4)),  # Repite cada tecnica 4 veces
  bloque = factor(rep(1:4, times = 4)),  # Iitera por cada bloque
  resistencia = c(3129, 3000, 2865, 2890,
                  3200, 3300, 2975, 3150,
                  2800, 2900, 2985, 3050,
                  2600, 2700, 2600, 2765)   # Observaciones en orden fila por fila
)


# Calcular la media y desviación estándar para la muestra.
media_resistencia <- mean(df$resistencia)
sd_resistencia <- sd(df$resistencia)

# Calcular la media por técnica y convertir los resultados en un dataframe
medias_df <- aggregate(resistencia ~ tecnica, data = df, mean)



ticks_values <- unlist(lapply(c(-3,-2,-1,0,1,2,3), function(x) round((x * sd_resistencia)+media_resistencia,2)))
ticks_values[[1]]<-ticks_values[[1]]-10
ticks_values[[length(ticks_values)]]<-ticks_values[[length(ticks_values)]]+10



library(ggplot2)

# Crear un data frame para la función de densidad
x_vals <- seq(min(ticks_values), max(ticks_values), length.out = 100)
density_vals <- data.frame(
  x = x_vals,
  y = dnorm(x_vals, mean = media_resistencia, sd = sd_resistencia)
)

# Crear la gráfica con ggplot2
ggplot(density_vals, aes(x = x, y = y)) +
  geom_line(size = 0.5) +  # Línea de la distribución normal
  geom_point(data = medias_df, aes(x = resistencia, y = 0, color = tecnica), size = 4) +
  geom_vline(xintercept = ticks_values[[4]], colour = "black", linetype=3, size = .5) +
  scale_x_continuous(breaks = ticks_values, labels = ticks_values) +  
  scale_y_continuous(limits = c(0, max(density_vals$y))) +
  theme_minimal() +  
  theme(axis.title.y = element_blank(),   
        axis.text.y = element_blank(),     
        axis.ticks.y = element_blank(),    
        panel.grid.major.y = element_blank(),   
        panel.grid.minor.y = element_blank(),
        axis.ticks.x = element_line(size = 0.7),   
        axis.ticks.length = unit(7, "pt"), 
        axis.line.x = element_line(size = 0.5, linetype=1),
        axis.text.x = element_text(size = 10, angle = 0, hjust = 0.5, vjust = 0.5)) +  # Rotar etiquetas X
  labs(x = "Resistencia", y = NULL)  # Etiqueta del eje X

E este é o meu resultado:

Como posso adicionar os valores do media_dfdata frame ao gráfico como rótulos para os pontos? Como posso ajustar a posição dos pontos no media_dfdata frame para que a linha do eixo x os cruze?

Activator.CreateInstance recebe um CultureInfoargumento. Os documentos dão a seguinte descrição para esse argumento:

Informações específicas de cultura que governam a coerção de argspara os tipos formais declarados para o typeconstrutor. Se culturefor null, o CultureInfo para o thread atual é usado.

O que isso significa? Quais são alguns exemplos de quando alguém culturedaria um resultado diferente de um diferente culture?

Tenho um cliente TLS que usa boost para as operações de conexão e handshake e, se elas falharem, retornarão um boost::system::system_error.

Se possível, gostaria de verificar se o código de erro está relacionado a um dos seguintes casos:

• Incompatibilidade de conjunto de cifras
• Incompatibilidade de versão TLS
• Certificado incorreto
• Certificado expirado

Encontrei os seguintes códigos de erro, mas não consigo encontrar nenhum que seja relevante para o meu caso:

https://www.boost.org/doc/libs/1_87_0/boost/asio/error.hpp https://www.boost.org/doc/libs/master/libs/system/doc/html/system.html#ref_boostsystemerrc_hpp