Cardinal | Virtual modular synthesizer plugin | Plugin library

In relation to your question,

In the context of UML that is the official definition that you cited.

With your statement. Your statement 4 is correct but as mentioned by Jim the cardinality shouldn't be restricted.

You can have 1 or more leaders of a club along with 1 or more leaders for an individual club.

In addition, subsets help define inheritance. For example, in your diagram if Person is a subset of Club, and they are a leader of the club then automatically they are a member.

It can get a bit nit-picky with logic as in the diagram, the subset does not only inherit from the parent class (Club) but also has its own properties (Person) and at the same time points back to the parent.

Hopefully the links below, outline what I am trying to say.

Some useful links for context:

• What subset constraint means in the UML class diagram

• https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.138.5537&rep=rep1&type=pdf

• https://newbedev.com/how-to-use-subsetted-property-in-uml

You can use

The reason for this is that the contains function doesn't accept a nodeset as input - it only accepts a string. (Well, it may be engine dependent, because it works for Python's lxml module. According to the specification, it should convert the value of the first node in the set to a string and act on that. See also XPath contains(text(),'some string') doesn't work when used with node with more than one Text subnode)

//a[text() = 'Ask Question'] is matching any a elements which contain a text node which equals Ask Question.

//a[text() = 'more text'] is matching any a elements which contain a text node which equals more text.

So both of these expressions match the same a element.

You can re-work your query to //a[text()[contains(., 'Ask Question')]] so that the contains method will only act on a single text node at a time.

In principle, that kind of approach does work: if you have a function f from a set A to a set B and an inverse function to it, you can prove bij_betw f A B (read: f is a bijection from A to B), and that then implies card A = card B.

However, there are a few comments that I have:

1. You should use bool lists instead of nat lists if you can only have 0 or 1 in them anyway.

2. It is usually better to use existing library functions than to define new ones yourself. Your two functions could be defined using library functions like this:

The answer is exactly what I knew it would be.

• i started with headers translated by Franck Soranio
• where some definitions were packed records
• when that didn't work, I tried adding $ALIGN 8 - the ABI required by Windows
• when that didn't work, I tried adding packed to all records

When that didn't work, i asked Stackoverflow.

In the meantime, i spun up Visual Studio C++, and compared the sizeof of the original structures, and the Delphi translations.

They didn't match.

The problem was the packed records.

• sizeof(EVENT_TRACE_LOGFILEW): 416 bytes (was 404)
  • sizeof(EVENT_TRACE): 88 bytes (was 80)
    • sizeof(EVENT_TRACE_HEADER): 44 bytes (was 40)
  • sizeof(TRACE_LOGFILE_HEADER): 272 bytes

Removing the record packing fixed it.

I did get it to work using this:

The issue exists because the inline assembly assumes the first argument as well as the return value to be using register eax, which is true for Delphi in 32-bit mode as per Delphi's calling convention (and although the inline assembly documentation states that there shouldn't be made any assumptions about registers other than ebp and esp, this always held true even inside of inline assembly statements when they were placed at the top of a function).

However, 64-bit mode uses a different calling convention in which the first argument is in rcx and the return value is using rax. So here you are getting random uninitialized garbage as return value that happened to be in that register (with its bytes swapped) because it's never explicitly set.

The best, portable solution would be to implement the byte swap in pure Pascal without inline assembly:

Let B be any type (Bool, in your case), and assume an isomorphism, with its inverse

If I understand correctly, the elements of Lam -> Lam would not be all set-theoretic functions (which are bigger than Lam by Cantor's theorem), but only continuous functions.

Yes, that's a common answer to the apparent paradox.

More in general, types are types, with their logical theory (type theory), while sets are sets (working as in set theory).

One is tempted to interpret types as sets, i.e. to constructs models of the lambda calculus within sets.

I suggest you read the milestone paper "Polymorphism is not set theoretic" by Reynolds. This shows that is you have "forall" types as in System F, and you interpret functions as sets in the "obvious" way, you get a contradiction, by a similar argument you made (Cantor's, roughly). Indeed, Reynolds constructs T ~= (T -> Bool) -> Bool.

Reynolds suggests indeed, one of the option is to interpret function types as a "subset" of functions on sets, e.g. continuous functions as you mentioned.

If so, what is the topology that defines this continuity

Scott topology.

and why are Haskell terms of type Lam -> Lam continuous for it ?

Roughly, because all the basic operations (lambda abstractions, applications, ...) are continuous, so you get a composition of continuous operators which has to be continuous.

Note that defining a proper formal semantics of Haskell is a daunting task. Even focusing on System F only, which is much simpler in comparison, models are already rather complex.

You could start from the simply-typed lambda calculus and learn about their categorical models: Cartesian closed categories (CCCs). Working in, say, the category of Scott-continuous functions is a special case of CCC. The CCC general structure makes you understand that, after you have a basic structure (essentially Currying and little else) you can use that to create a full-model, interpreting any (typed) lambda term.