KetaThunberg
Biography
No biography added yet
Stats
KetaThunberg
mattbatwings
20 bit divider (Java & Bedrock)
20 bit sequential divider. Takes in two 20 bit numbers A, B as input and returns A // B (i.e. the integer quotient of A divided by B) and the remainder. Uses restoring division and runs on a clock-speed of 18t per bit (quite slow).Works on Java & Bedrock. Uses Mattbatwings' 5t CCA.
minecraft
redstone
KetaThunberg
mattbatwings
16 bit divider (Java & Bedrock)
16 bit sequential divider. Takes in two 16 bit numbers A,B, and returns the integer quotient as well as the remainder. Runs on a 15t per bit clock.Uses Mattbatwings 5t CCA. Works on Java, to make it work on bedrock you have to replace the green stained glass by upper slabs. I forgot to do it, sry
minecraft
redstone
32 bit square root extractor
32 bit sequential square root extractor. Takes in a 32 bit number input and returns the rounded down square root, as well as the remainder. Uses the algorithm explained in Mattbatwings video:https://youtu.be/bnwsyYpf3GQ?si=gMd06RvJpv5iq0PzIt uses Aminos 3t CCA (extended to 32 bits) and runs on a clock speed of 18t per bit. It need 16 iterations. Faster design would be to use a non-restoring method, but it's gonna be twice as big.Java only.
minecraft
redstone
32 bit cube root extractor
Takes in a 32 bit number A and returns Q = floor(cbroot(A)) as well as the remainder R, i.e. A = Q^3 + R.It runs on a (horrible) clockspeed of 28t per bit, and it needs 11 iterations, i.e. in total it's gonna take over 30 seconds. It uses the restoring shift-and-subtract algorithm. It can be made substantially faster (but also bigger) if we use a non-restoring method. I used Aminos 3t CCA design for all the adders.Java only.
redstone
minecraft
32 bit square root extractor without remainder
This unit takes in a 32 bit number A and computes floor(sqrt(A)), i.e. the square root of A rounded down. It uses the non-restoring shift-and-subtract algorithm, and it computes a bit every 11rt, or 1.1 seconds. In total, it needs a little more than 20 seconds due to additional overhead.In this design the focus was on speed & compactness. My previous square root extractor was 18rt per bit, so this is design is a lot faster, but it has two downsides, namely:No remainder. Since the used algorithm is non-restoring, we sometimes have to do an extra addition to get the correct remainder. This is a little bit tedious to do, also the remainder is hard to access, it is stored on the yellow line in the middle of the build.No Reset button. I didn't find a good way to reset the output, so you can only overwrite the previous output, but not clear the outputI used Aminos 3t CCA design for the adders.Java only.
minecraft
redstone
CORDIC Unit
This is a unit that does the CORDIC algorithm, which is a simple iterative algorithm that only uses additions, subtractions & shifting to compute functions like sine, cosine and much more. The algorithm can be done in 6 different settings, yielding different functions. We choose between 3 Coordinate Systems: Circular, Linear, Hyperbolic 2 Modes: Rotation, Vectoring Each pair of Coordinate System & Mode computes a different function, e.g. Circular Rotation is used for computing sine & cosine. This unit uses binary fixed point numbers in signed Q3.37 format (using twos complement), i.e. we have one sign bit, two integer bits, and 37 fractional bits. It can do 38 iterations at max. The inputs are located a bit awkwardly, we have: x,y inputs at the sidesphi input at the frontCoordinate System & Mode selection at the front at the bottomPanel for selecting total number of iterations, Clock button & Reset button at the right sideOutputs at the backThe functions we can compute areSin, Cos: Circular Rotation. Inputs: phi. Outputs: x≈cos(phi), y≈(phi). Input range: approx. [-1.57, 1.57] Arctan: Circular Vectoring. Inputs: x,y. Outputs: phi≈arctan(y/x). Input range: |y/x| =< 1 is sufficient, but theoretically approx. |y/x| =< 5.758 should work too Sinh, Cosh: Hyperbolic Rotation. Inputs: phi. Outputs: x≈cosh(phi), y≈sinh(phi). Input range: approx. [-1.1181, 1.1181] Atanh: Hyperbolic Vectoring. Inputs: x,y. Outputs: phi≈atanh(y/x). Input range: approx. |y/x| =< 0.8Multiplication: Linear Rotation. Inputs x, phi. Output: y≈x*phi. Input range: phi between -2 and 2, and x*phi must fit in Q3.37Division: Linear Vectoring. Inputs x,y. Output: phi≈y/x. Input range: y/x must be between -2 and 2.Multiplication and Division are just for fun and not really that useful, e.g. you can't compute 2*2 with this. I only inlcuded them because they didn't take up any additional space or slow anything down. Any normal multiplier or divider will be better.Clock Speed:Rotation: 32rt per iterationVectoring: 36rt per iterationJava only.
minecraft
redstone
logic
8 / 16 / 32 bit Radix-4 Booth multipliers (signed & unsigned)
Collection of three sequential multipliers, with 8 / 16 / 32 bit inputs and 16 / 32 / 64 bit output. Since the Radix-4 Booth algorithm can also handle negative numbers, the inputs can be positive or negative.For each input, at the MSB there is a lever that let's you decide if the number should be interpreted as signed or unsigned. In the signed case, the number is seen as being in twos complement, i.e. the MSB decides what sign the number should have. For example, in the 8 bit case, if we plug in 11111111, then in the unsigned case, this number is 255, and in the signed case, this number is -1. If we plug in 01111111, then in both the signed and the unsigned case this number is 127.The algorithm handles two bits in one iteration, so for e.g. 8 bits, we only need 4 iterations. One iteration takes only 3t. As far as I can tell, even the 32 bit multiplier should never take longer than 10 seconds from pressing the "Start" button to showing the result regardless of inputs.I used Aminos CCA design as well as a looping CSA which was shown in Bennyscube video.Java only.
8 / 16 / 32 bit CSA multipliers
Collection of three multipliers, one with 8 bit input and 16 bit output, 16 bit input and 32 bit output, 32 bit input and 64 bit output.It uses looping Carry Save Adders (lime) to quickly add incoming numbers together and store them in the Carry Save format (i.e. as partial sum and carries), and then uses fast CCAs (green) to add partial sums and carries together. They run on a speed of 3t per bit. I got the CSA design from Bennyscube's video on Carry Save Adders, and the CCA design is by Amino.In order to make it work on Bedrock, you only have to replace the green stained glass by upper slabs.
minecraft
redstone
logic
32 / 31 bit divider
Sequential divider, takes inputs A (max. 32 bits) and B (max. 31 bits) and returns A // B, A % B. Uses non-restoring division method, and runs on a clockspeed of 11t per bit. The CCAs that are used are by Amino.Java only.
minecraft
redstone
No Flows Yet
This user hasn't created any visual schematic flows yet.
KetaThunberg's Bookmarks
No bookmark collections found.
