(you are just confused because posix compliant shells have corrupted your mind)
> do-action -param "string" $variable (do this first) [type]value
To declare a function:
function do-mythings {
param([int]$argument)
$argument + 5
}
> do-mythings -arg 5
10
That's all you need to get started.
Numbers are just numbers.
Inline math just works. Parentheses for order of operations.
Strings you put in quotes - double quotes allow interpolation, single quotes don't. This is the same as sh.
All variables are prefixed with $s. Even when declaring them. This makes slightly more sense than sh.
A region in {squirrelly braces} gets the [scriptblock] data type. It's like a lambda but comprehensible by mere mortals.
if (test) {success} else {fail} - the test is always executed first because (). Success and fail conditions only depending on the test. They're script blocks. No weird special syntax, if may as well be a user function.
Functions can be named anything, but the convention is Verb-PlaceThing. Not case sensitive.
Named arguments are specified with a single hyphen, like MIT Unix software (xorg for instance). If there is only one parameter the name is optional, etc. Param names can be abbreviated as long as they aren't ambiguous. This is also easy to follow with your own functions, unlike in sh (fricking hate getopt).
Types are inferred dynamically because it's easier to write scripts that way. If you need to force something (variable, expression, whatever) to have a specific type, put it in [brackets] beforehand. The type names are the same as c# and every other post-algol language. For comparison, posix shell only has one type, String.
To make an array, @(item1, item2, etc)
To make a hashtable, @{
key1 = val1
key2 = val2
}
Adding strings concatenates them together. Adding numbers adds their values. If this is not satisfactory, declare their types and it will work.
All expressions are technically objects with properties and methods. $var.property returns the value of that property. $var.invokeMethod() runs the method, which is just a function built into that data type by some poor intern 20 years ago.
Pipes (|) work similarly to sh, but transfer objects. The current object in the pipeline is always the variable $_.
As a bonus, here's a one-liner for opening Internet Explorer on Windows 11 (they lied, it's still there, they will never remove it)
COM is an old windows api. Com Objects are just instances of apps. We open internet explorer as a com object.
The parentheses sets that as an expression, and its return value _is_ the exploder. It has properties like visibility, which is $false by default. This is boring so set it to $true. Now we have a real working instance of an app they've been trying to remove for years, because they can't actually remove it merely hide it away. As long as the windows api can parse HTML, this will still work.
The Epaulette shark is only about 9 million years old as a species, making it the most recent branch in the shark family. And it is slowly but surely evolving into a land animal
Your pupils contract in response to visible light, but not all of the sun’s light is visible. During an eclipse, your pupils widen because it’s dark, but there’s an outer layer around the sun that mostly only puts out light that’s not visible to us, but that can still damage your retinas. Thus, looking at an eclipse makes your pupils open up like it’s dark, which lets more of the invisible damage beams in.
The sun doesn’t get a critical multiplier on its damage when HP is low. Equipping the moon gives the sun a bonus to backstab.
My friend forgot to secure the latch on his magic card briefcase and all his commander decks are now mixed together. Now he’s playing 1200 card pickup and has to reorganize everything.
yesterday my brain suddenly went "hey the cyclic multiplicative group of 𝔽16 has order 15, just like fizzbuzz repeats the words every 15 ste
yesterday my brain suddenly went “hey the cyclic multiplicative group of 𝔽₁₆ has order 15, just like fizzbuzz repeats the words every 15 steps”. the issue with that of course is that one would still need to output the numbers until 100 and the field simply doesn't have enough elements to keep track of that. however, the field 𝔽₂₅₆ has 𝔽₁₆ as a subfield and therefore can also track divisibility by 15 (and 3 and 5). the field also has native support on x86 using avx512 (and i tried hard to shoehorn the GF2P8AFFINEINVQB instruction into the program).
the thing simply goes through consecutive powers of a primitive root of unity (primitive meaning that x^i = 1 only if i is a multiple of 255, the size of the multiplicative group). the divisibility checks for 3 or 5 are then equivalent to checking whether x^i to the powers 85 or 51 is 1, since that means i*85 or i*51 are a multiple of 255. for the non-fizzbuzz numbers one can calculate the discrete logarithm to recover i (mod 255) from x^i.
anyway, here is the unreadable mess....
(8051 enthusiast, 1st May 2023)
the code is a little intimidating but well-commented (and easier to read if you paste it somewhere with C syntax highlighting)
references for the SIMD instructions used:
The instruction multiplies elements in the finite field GF(2^8), operating on a byte (field element) in the first source operand and the corresponding byte in a second source operand. The field GF(2^8) is represented in polynomial representation with the reduction polynomial x^8 + x^4 + x^3 + x + 1.
The AFFINEB instruction computes an affine transformation in the Galois Field 2^8. For this instruction, an affine transformation is defined by A * x + b where “A” is an 8 by 8 bit matrix, and “x” and “b” are 8-bit vectors. One SIMD register (operand 1) holds “x” as either 16, 32 or 64 8-bit vectors. A second SIMD (operand 2) register or memory operand contains 2, 4, or 8 “A” values, which are operated upon by the correspondingly aligned 8 “x” values in the first register. The “b” vector is constant for all calculations and contained in the immediate byte.
The AFFINEINVB instruction computes an affine transformation in the Galois Field 2^8. For this instruction, an affine transformation is defined by A * inv(x) + b where “A” is an 8 by 8 bit matrix, and “x” and “b” are 8-bit vectors. The inverse of the bytes in x is defined with respect to the reduction polynomial x^8 + x^4 + x^3 + x + 1.
One SIMD register (operand 1) holds “x” as either 16, 32 or 64 8-bit vectors. A second SIMD (operand 2) register or memory operand contains 2, 4, or 8 “A” values, which are operated upon by the correspondingly aligned 8 “x” values in the first register. The “b” vector is constant for all calculations and contained in the immediate byte.
germansingergirl
gamechangershow
vaporwave
theartofmadeline
amandla
turnnoffyourmind
