#lfsrs

[sinningtamer]

⬆️ knight who is so so very pregnant

this art has fic for it!

(don’t reblog to non-kink/fandom blogs)

[machine-saint]

weird tarot story time

so as background: i'm non-spiritual, a believer in philosophical materialism. have been for a decade and a half. but i'm a sucker for the symbology of tarot cards and the art people make for them. so a few years ago i decided to write a little simulator.

now, obviously if you're gonna do tarot you have to shuffle your deck, right? and shuffling a deck in code is easy; take a decent random number generator, use fisher-yates, done. hell, you don't even have to shuffle if you just pick a random card and remove it. but that's not fun. and part of tarot, as i'm told, is your intentions.

so instead what I do is I write an intentionally bad shuffler. you type your query in, and it converts it to a number using a bad hashing algorithm (CRC32) and then converts that into a stream of random numbers using a really bad algorithm (an LFSR), and then implements a shuffler that's intentionally not perfect (some hand-written thing I don't remember). i run it a few times and verify that there aren't any obvious clumps or patterns and go, okay, good enough.

(the other reason is i get to do cool UI design stuff like this)

so I decide to test it. I type in the query "Is this real?" or something like that, let it shuffle (it intentionally takes multiple seconds to shuffle), and draw the top card. and i get this:

X - History, reversed

now, if you're passingly familiar with Tarot, you might not recognize History. if you're more familiar with it, you'd probably go "wait, 10 is Fortune, what the hell". that's because I decided to use the Tarot of the Silicon Dawn by Egypt Urnash, which adds a bunch of fun extras (including some that, in the sadly-out-of-print physical deck, are gloss-on-black. very fun.) the image here is from the high-res images the artist posted on her site; she let me use them with permission, and I wrote the ascii-ifier myself because I figured it fit the aesthetic. i also did the same thing for the Neon Moon deck, which is more conventional in design (aside from renaming the suits) but has a very nice striking cyberpunk-y color scheme.

so anyway. i'm not an expert in interpretation, and Silicon Dawn comes with a booklet that i'd integrated into my program. so i look over at it and see the first paragraph, emphasis mine:

She bends the world around herself, and binds it about her with a story. Or is she the world, bending into itself, and trying to explain itself with narration? Just the whole cosmos finding a way of talking to itself. At the very least this card may be a reminder that the whole deck can just be an elaborate way of talking to yourself – what story do you bring to these cards, what begs itself to be connected in ways you wouldn't let yourself connect normally?

and I think: "well, I asked it if the occult is real, and History upright is 'this can just be an elaborate way of talking to yourself', so if it's reversed..."

and, like, I know this is just a coincidence. i i know that in a 99 card deck, the odds of getting a specific card reversed are about .5%, so it's not impossible. it didn't change my mind about anything. but it's still the only time i've had a, i guess, genuinely low-probability occurrence with occult stuff.

if you want to play around with it, here's the tarot simulator! nothing ever leaves your computer; i can't see your queries or anything like that.

[omiindustriies]

The Cascading Register from omiindustriies is a source of pseudo-random voltages and gates using a shift register-based architecture. It takes inspiration from digital shift registers, runglers, linear feedback shift registers (LFSRs), and analog shift registers. The module features an eight-bit shift register and voltage-controlled clock; broken into four main function blocks: clocking, data, CV, and gates.

[technician-the]

This is the Son of Atari, A variable clocked digital noise generator, based on a discrete LFSR.

It makes Asteroids/Space Invader type sounds

[theohonohan]

Shift register sequences

I looked into shift register sequences a few years ago, as a way to create a random dissolve. This is a fairly well-known trick, sometimes referred to as FizzleFade. An \(n\)-bit maximal Linear Feedback Shift Register is used to cycle through all but one of the possible strings of n bits. In most shift register applications, it’s the output bit that counts. In FizzleFade, the contents of the register are what we care about.

There are two variants of LFSR, the Galois and the Fibonacci. They both use polynomials, “taps” to create feedback in the register, and in both cases they use XOR to calculate addition mod 2 (we are working in GF(2)). At first it might seem that the Galois and Fibonacci LFSRs can’t be equivalent, since the Fibonacci type XORs the tap values together to create an input bit, whereas the Galois type XORs the output bit together with a set of bits withi n the register. These are very different operations.

It turns out, though, that Galois and Fibonacci LFSRs create the same stream of output bits, so they are closely related. I’m tempted to say that they are ‘duals’, which is the go-to term when two mathematical structures are somehow opposite without being exactly complementary.

The mathematical operation on which LFSRs are based is long division of polynomials over GF(2).

As everyone knows, long division produces a pair of values, the quotient and the remainder. The Galois LFSR stores the remainders (both the ‘intermediate’ remainders, and the final remainder) in the register. At each step, it subtracts the divisor from the register using XOR. So the contents of the register change abruptly at each step. The quotient can be recovered by watching the output bits.

Here’s a visualisation of the calculation performed by a 3-bit Galois LFSR, formatted as long division:

The contents of the register at each step are bolded. The first thing to notice is that after seven steps the register returns to its initial state. This property is a result of the choice of divisor. It corresponds to the divisor polynomial being a factor of \(X^n + 1\) for \(n= 2^3 - 1\), and not for any smaller value of n. Any divisor polynomial with this property is called a primitive polynomial.

The upshot of this is that the cycle length of this particular LFSR is \(2^3 - 1\), which is \(7\). Since there are only \(8\) possible values for the contents of the register, and the “all zeros” value is excluded, this is the maximum length of cycle. The successive output bits of the shift register give the quotient of the division operation.

The Fibonacci LFSR is more difficult to understand, but it’s also an implementation of the same long division process. At each step, the bit values at each of the tap locations are gathered and XORed together, which is the same as adding them (or subtracting them), and also equivalent to a parity check. The way to conceptualize this is that a digit at position \(n\) in the divisor only contributes if a) it is a \(1\) and b) a division took place \(n\) steps ago. The resulting bit corresponds to the sum of digits in the current column, and it tells us what the next bit of the quotient is. This bit is shifted into to the input of the register. As a result, the contents of the register in the Fibonacci case are the digits of the quotient.

The duality here, then, is that the Galois LFSR works on rows, and the Fibonacci LFSR works on columns. As in many cases of duality, one form is like an inside-out version of the other, not just an opposite. In this case, the Galois form is a log more natural. Indeed, because the Fibonacci implementation stores (part of) the quotient in the register, there is no place to “input” a dividend polynomial—it is specialised to dividing polynomials of the form \(X^n\), while the Galois LFSR can be readily adapted to do general polynomial long division.

In explaining this, I feel the need for more detailed terminology dealing with the workings of long division. What words are there to describe the condition when a one is entered in the quotient, and a subtraction takes place? I’ve referred to this as “a division” above, but that doesn’t seem quite right. On the other hand, it doesn’t seem likely that using words like subtrahend will improve the description.

[afactaday]

#aFactADay2024

#1100 (wow binary, how apt): the Game Boy has four audio channels, each one capable of playing one sound. a single channel could be controlled by the code to play a single note, which would automatically be generated. the first two channels were square waves: you give the frequency to a timer which cycles at that frequency. square waves have a bit-depth (how high-resolution the waveform is) of 1, so the timer cycles just through a series of bits (1s or 0s) in memory and outputs those. there are four options for a series of bits it cycles through, depending on what duty cycle you want. if you pick 00000001, that's a duty cycle of 12.5% because the waveform is high for 12.5% of the time, whereas 00001111 has a duty cycle of 50%. both of these examples have the same frequency though, so would sound at the same pitch

once the signal goes through the duty cycle unit, it goes to a length counter, which is a little thing that keeps track of how long a channel has been on for and turns it off after a certain while. this means you can tell a channel how long a note is going to be and it'll automatically turn off after the time.

then, the signal goes through a "volume envelope", which controls how the volume changes with time. the envelope has four controls: attack, decay, sustain, release (aka ADSR). the attack is how long it takes the note to reach maximum volume after it initially starts playing; the decay is how long it takes the note to die down after that to a lower level; the sustain is the level (as a fraction of the maximum volume) at which it remains until released; the release is how quickly the note disappears. then the signal goes to the mixer, which combines all four channels and sorts out things like panning (where the left/right speaker is louder than the other to make it seem like the source of the sound is moving) (each channel can be individually panned, as well as a master panning) and master volume. the first channel also has an in-built frequency sweep unit, which allows for easy slides between two notes.

except that's just the first two channels. the third channel is a wavetable, which generates waves from, um, a table... rather than selecting a waveform from a choice of 4 duty cycles, a waveform is loaded into the RAM and it plays that. instead of 1-bit square waves, the third channel of the Game Boy uses 4-bit samples. there are 32 entries in the table, so the table is 16 bytes in RAM, right at the end of the last block. the timer spins through these to form a much higher quality wave that's used to make more interesting timbres than that of a dead oboe. then, the wave goes through a similar series of units as the square waves, except the envelope is replaced with a simple volume control.

the final channel, the noise channel, works similarly to square waves, but instead of the duty cycle unit, a "linear feedback shift register" (LFSR) generates a pseudo-random series of 1s and 0s to form the wave. in combination with the ADSR envelope, it gives that instantly recognisable Game Boy sound effect. the way the LFSR works is interesting: a shift register (a memory unit which shifts all its contents down by 1 bit upon every clock) holds 15 random bits. upon the clock pulse, the data is shifted down by one, so the top bit becomes empty and the bottom bit is lost. the lowest two bits are then XORed, to create a pseudo-random new bit to fill the gap at the top. the waveform is then taken from the bottom bit as the cycle goes round, and is then inverted, before carrying on to the other units (length counter, envelope, mixer).

after the whistle-stop tour of Game Boy music synthesis, here are the most interesting trivia i could find:

even when channels aren't in active use, they're constantly calculating new values, which are then thrown away.

the length counter clocks twice as frequently (ie, higher resolution) as the frequency sweep, which clocks twice as fast as the volume envelope. the volume envelope never clocks at the same time as the counter or the sweep.

a thing called "zombie mode" can be activated to marionette the volume while a channel is playing, bypassing the envelope (i don't quite understand this...)

the length counters on different models of the Game Boy differ: some of them are volatile and always read zero when powered on, whereas others you can write to the length counter while a channel is powered off.

[buntaindreemurr]

i think i figured it out. i'm not upset that ai is being USED in the creative field, because there are and have been endless applications for "ai" as a legitimately creative tool (quantizers, euclidean rhythm generators, the "turing machine" LFSR sequencer, color palette generators, arguably the entire field of 3d modeling and animation).

i'm upset that moneyed artless dipshits are attempting to use it to REPLACE the creative field. i'm increasingly pissed at the restraints bing and others are putting on image generators to prevent them from generating any output that isn't Safe And Marketable. you can't even prompt them with gibberish anymore just to see what comes out when it's entirely unguided. fuck that

[xenahabonal]

Sign extend 16 bit to 32 bit vhdl tutorial pdf

 SIGN EXTEND 16 BIT TO 32 BIT VHDL TUTORIAL PDF >>Download vk.cc/c7jKeU

  SIGN EXTEND 16 BIT TO 32 BIT VHDL TUTORIAL PDF >> Read Online bit.do/fSmfG

        sign extension circuit 32 bit lfsr polynomial 32-bit lfsr c code 16 bit lfsr vhdl resizevhdl sign extend sign extend verilog 16-bit floating point converter

  A 16 bit ofset and immediate operand could be instructions, hardware is simplified and its operating speed extended using by extension register and If you made a 32 bit signed wire that you put brancedloc2 into first In VHDL the sign extension would also need to be explicit which is really the rootSign extension. Consider the 8-bit 2's complement representation of: -5 = ~00000101 + 1. = 11111010 + 1. = 11111011. 42 = 00101010. What is their 16-bit 2's register 2. Instruction. [20–16]. Instruction. [15–0]. Sign extend. Instruction "register_file" is an array of 32-bit logic vectors (e.g., 32-bit words). This VHDL guide is aimed to show you some common constructions in VHDL, integer – an integer, signed 32 bit value. generic(N : integer := 16);. It is a signed value, so it must be sign-extended to 32 bits. Sign extension simply means copying the sign bit into the most significant bits: ImmExt31:12 =

https://www.tumblr.com/xenahabonal/697945763308847104/anti-surge-control-centrifugal-compressor-pdf, https://www.tumblr.com/xenahabonal/697945763308847104/anti-surge-control-centrifugal-compressor-pdf, https://www.tumblr.com/xenahabonal/697946273367638016/morza-szept-pdf-chomikuj-darmowa, https://www.tumblr.com/xenahabonal/697946273367638016/morza-szept-pdf-chomikuj-darmowa, https://www.tumblr.com/xenahabonal/697945763308847104/anti-surge-control-centrifugal-compressor-pdf.

[omegasmileyface]

Finished my research run for LEGO® Friends for the 3DS in 3:00:03. It's officially routed (though certainly not optimal) and ready to be properly run.

[sinningtamer]

"On GOD bro we gonna get Ren a vasectomy." - some random advisor who's on babysitting duty for the 4th time this week.

[superlinyuyangblog-blog]

OverTheWire Krypton

Level0 is just warm up the substitution code, the table is ABCDEFGHIJKLMNOPQRSTUVWXYZ

NOPQRSTUVWXYZABCDEFGHIJKLM

And key is LEVEL TWO PASSWORD ROTTEN.

Level 1 , I went to then directory and saw that there were 2 files, the README file tell me what is the challenge instruction, the password to the next level is encrypted using a ROT13 cipher. I can remember what the rot13 is, so I google it and try to understand what it is. Then I realized how it works so I try solve it manually, the key is caesariseasy. 

Level 2 is harder than previous, but it is also use Caesar Cipher, from the example the Alphabet is shifted once given by a certain number, that means if we know which number does it shift we can decode this code. I use the easiest brute-force one, I write a shell script and test every number to see is the message become a sentence or a word, finally, I found that the shift number is 14.

Level3 I have Statistic the frequency of letters in found 1,2 and 3, that is:

S 155 ---> e

C 107

Q 106 ---> t

J 102 ---->a 

U 100

B 87

G 81

N 74

D 69

Z 57

V 56

W 47

Y 42

T 32

M 29

X 29

L 27

K 25

A 20

E 17

F 11

O 7

H 2

I 2

R 1

fond2：

S 243 ---> e

Q 186 ---> t

J 158 ----> a

N 135

U 130

B 129

D 119

G 111

C 86

W 66

Z 59

V 53

M 45

T 37

E 34

X 33

Y 33

K 30

L 27

A 26

I 14

F 12

O 3

H 2

R 2

P 1

found3：

S 58 ----> e

Q 48 --> t

J 41 --> a

G 35 ---> o

C 34

N 31

B 30

U 27

D 22

V 21

W 16

Z 16

E 13

K 12

M 12

A 9

X 9

Y 9

L 6

T 6

F 5

I 3

O 2

P 1

R 1

Level 4 is Vigenere Cipher，and we also know that the length is 6 from the instruction, I found a good website explain how Vigenere Cipher works: http://smurfoncrack.com/pygenere/pygenere.php. I just copy the message to the website so I get the answer FREKEY.

Level 5 is the same as level 4 the key is KEYLEN

Level6 is LFSR, I google it first, I found that when the char is the same but the the position is different the message is different, but when the char is the same and the the position is also same the message would the same, so that is a char*position table, I google the algorithm that attack the LFSR and change a little bit:

#include <stdio.h>

short reg = 1;

char* a_en = "EICTDGYIYZLUIOTJSGYZ";

char* a_pl = "AAAAAAAAAABBBBBBBBBB";

char* b_en = "FJDUEHZJZAKTHNSIRFXY";

char* krypton7 = "PNUKLYLWRQKGKBE";

main()

{

        short a = 0;

        int b, c;

        int i, j;

        char *key[10];

        short magic[20];

        for(i=0, j=0; i<20; i++, j++)

        {

                b = reg;

                b &= 1;

                c = reg;

                c &= 2;

                c = c >> 1;

                a = b ^ c;

                b = reg;

                b = b >> 1;

                c = a;

                c = c << 3;

                a = b | c;

//             printf("magic: %hx\n", a);

                reg = a;

                magic[i] = a;

                if(j >= 10)

                        j = 0;

                key[j] = a_en[i] - a;

                while(key[j] < 0x41)

                        key[j] += 0x1A;

                key[j] -= a_pl[i];

                printf("magic: %hx\tkey[%d]: %hhx\n", a, j, key[j]);

        }

        for(i=0, j=0; i<20; i++, j++)

        {

                if(j >= 10)

                        j = 0;

                b = b_en[i] - magic[i];

                while(b < 0x41)

                        b += 0x1A;

                b -= (int) key[j];

                while(b < 0x41)

                        b += 0x1A;

                printf("%c", b);

        }

        printf("\n");

        //解密krypton7

        for(i=0, j=0; i<strlen(krypton7); i++, j++)

        {

                if(j >= 10)

                        j = 0;

                b = krypton7[i] - magic[i];

                while(b < 0x41)

                        b += 0x1A;

                b -= (int) key[j];

                while(b < 0x41)

                        b += 0x1A;

                printf("%c", b);jia

        }

        printf("\n");

}

[kremlin]

hello, i would like to ask about Linear Shift Feedback Registers and how you would explain how they work

sure. LFSRs are pretty straightforward. let’s take first break down what a Linear Feedback Shift Register is:

shift register - shift registers are pretty simple. they have (fundamentally) two inputs and one output: data in, clock, and data out respectively. when the clock signal cycles, data is read from data-in and written to data-out. simple

feedback - this means that some form of this component’s output is fed back in as input

linear - don’t, err..don’t worry about this

here is a very basic LFSR:

here the input to the first SR (which outputs through the other two) is given as the XOR of the first output combined with the last output. this has an interesting effect -- so long as the starting state of the input of all the SRs isn’t zero, the output from this LFSR will effectively be pseudorandom. the starting state of the SR inputs is called the ‘seed’ in this case. PRNGs is the most common use case for LFSRs

[goonlinepapers]

Learning Goal: I'm working on a c programming discussion question and need an ex

Learning Goal: I’m working on a c programming discussion question and need an ex

Learning Goal: I’m working on a c programming discussion question and need an explanation and answer to help me learn.Write a program in C and in MIPS assembly language program that generates pseudorandom 32 bit numbers using a linear feedback shift register.See Wikipedia entry on LFSR: https://en.wikipedia.org/wiki/Linear-feedback_shift_register (Links to an external site.) The entry above…

[drowsyfantasy]

Learning Goal: I'm working on a c programming discussion question and need an ex

Learning Goal: I’m working on a c programming discussion question and need an ex

Learning Goal: I’m working on a c programming discussion question and need an explanation and answer to help me learn.Write a program in C and in MIPS assembly language program that generates pseudorandom 32 bit numbers using a linear feedback shift register.See Wikipedia entry on LFSR: https://en.wikipedia.org/wiki/Linear-feedback_shift_register (Links to an external site.) The entry above…

[grobz]

Learning Goal: I'm working on a c programming discussion question and need an ex

Learning Goal: I’m working on a c programming discussion question and need an ex

Learning Goal: I’m working on a c programming discussion question and need an explanation and answer to help me learn.Write a program in C and in MIPS assembly language program that generates pseudorandom 32 bit numbers using a linear feedback shift register.See Wikipedia entry on LFSR: https://en.wikipedia.org/wiki/Linear-feedback_shift_register (Links to an external site.) The entry above…

[rustycode-it]

A brief history of random numbers

From the README of oorandom

The usefulness of random numbers has been known for a long, long time to people who also knew how to use slide rules. If you wanted to do some math without the bother of coming up with all that pesky input data from the real world, you might as well just use any ol' random numbers, as long as there weren't any patterns in them to heck up the patterns you were trying to look at. So in the first half of the 20th century you had little old ladies named Edith spinning roulette wheels or pulling bingo balls out of baskets and writing the results down, which got assembled into giant tomes and published so that engineering schools could buy them and have giant tomes sitting on their shelves. Anyone who wanted some meaningless numbers could pull the tome down, flip it open to a presumably-random page, and there were all the random numbers anyone could want. The problem was solved, and life was good.

In late 1940's computers were invented, but they were far too big and expensive to be put on the task of intentionally generating nonsense, and things carried on as before. If you needed random numbers in a computer program, you just got a pretty young lady named Mary to transcribe part of the book to punch cards for you.

Around the early 1960's computers got fast enough that Edith and Mary couldn't keep up with them, so they got downsized and replaced with more computers. To do this people came up with Linear Congruential Generators (LCG's), which could generate lots of numbers numbers that weren't really random, but sure looked random. LCG's worked well on computers that even a second-rate university could afford, and so the problem was solved, and life was good.

At some unknown point in here, presumably sometime in the 60's or 70's, someone seems to have invented Linear Feedback Shift Registers (LFSR's) as well. These made random-looking numbers and were really easy to implement in hardware compared to the LCG, which needed to do complicated things like multiply numbers. The random-looking numbers made by LFSR's were good enough for hardware people, so they started using LFSR's whenever they needed to and never looked back.

Anyway, by the late 60's people who knew how to use slide rules had realized that using numbers that only looked random could really heck up their math pretty bad, and one of the more common LCG implmentations, RANDU, was actually about as bad as possible. So, just using any old LCG wasn't good enough, you had to use one made by someone with a PhD in mathematics. Donald Knuth shook his fist at the world and shouted "Hah! I told you so!", published a book on how to do it Right that most people didn't read, and then went back into his Fortress of Solitude to write TeX. Because it was created by IBM, RANDU's awfulness is now enshrined forever in history documents like this one, and because the people writing OS's and programming languages at the time weren't actually doing much slide-rule stuff anymore and didn't actually need very good random-looking numbers, everyone went back to using whatever old crap RNG they were using anyway. The problem was solved, or at least not terribly problematic, and life was good.

Also, sometime in the 70's or 80's the arts of cryptography started leaking from classified government works into the real world. People started thinking about how much money they could make from scrambling satellite TV so that plebs with HAM radio licenses couldn't watch it, and these people started giving more money to people who had PhD's in mathematics to figure out how to make this work. It was quickly determined that neither LCG's nor LFSR's made numbers that were random-looking enough to really get in the way of someone who knew how to use a slide rule, and since Edith had long ago retired to a small beach house in New Jersey, they needed to figure out how to get computers to make better random-looking numbers. But making numbers look random enough that someone couldn't undo the process and get free pay-per-view was slow and involved lots of details that nobody else really cared about, so that topic went off on its own adventures and will not be further mentioned.

Things more or less trundled along this way until the late 90's, when suddenly computers were everywhere and there was a new generation of people who had grown up too late to know how to use slide rules, so they did all their math with computers. They were doing a LOT of math by now, and they looked around and realized that their random-looking numbers really weren't very random-looking at all, and this was actually something of a problem by now. So the Mersenne Twister got invented. It was pretty slow and used a lot of memory and made kinda mediocre random numbers, but it was way better than a bad LCG, and most importantly, it had a cool name. Most people didn't want to read Knuth's book and figure out how to make a non-bad LCG, so everyone started using the Mersenne Twister whenever possible. The problem was solved, and life was good.

This is where things stood until the early 2010's, when I finished my MS and started paying attention again. People suddenly realized it was possible to make random-looking numbers better than the Mersenne Twister using an algorithm called xorshift. Xorshift was fast, it made good pretty random-looking numbers, and it didn't need a whole 3 kilobytes of state just sitting around taking up space and causing comment among the neighbors at church. It did sometimes have problems with some of its numbers not looking random enough in a few select circumstances, but people were gun-shy about their randomness by now so a few people with PhD's in mathematics slowly and patiently spent years figuring out ways to work around these problems, leading to a whole confusing family of related things such as xoshiro, xoroshiro, xoroshiro+, xoroshiro*, and so on. Nobody else could really tell the difference between them, but everyone agreed they were better than Mersenne Twister, easier to implement, and the name was nearly as cool. Many papers were published, the problem was solved, and life was good.

However, at about the same time some bright young spark figured out that it actually wasn't too hard, if you read Knuth's book and thought real hard about what you were doing, to take the old LCG and hop it up on cocaine and moon juice. The result got called the Permuted Congruential Generator, or PCG. This quite miffed the people working on xorshift generators by being almost as small and fast, and producing random-looking numbers that satisfied even the people who had learned to use slide rules for fun in this latter age. It also used xor's and bit shifts, and that's xorshift's turf, dammit, it's right in the name! Since nobody had figured out any downsides to PCG's yet, everyone shrugged and said "might as well just go with that then", and that is where, as of 2019, the art currently stands. The problem is solved, and life is good.