cld | compact language detection in ruby | Speech library

The BIOS will always start execution at the first byte of the boot sector, and in your case that appears to be the string, so you're executing data. (The fact that you put in a label called main doesn't affect this; nothing looks at it.) It could be that your "Hello world" string just happens to correspond to instructions that don't totally break everything.

Try moving the string to be after all the code, or else insert a jmp main before it.

Also, you have an inconsistency between your ORG directive and your ds segment. Your boot sector gets loaded at linear address 0x7c00. You can think of this in segment:offset form as 0000:7c00 or 07c0:0000 (or other ways in between if you really want). So to access data in the boot sector, you either need to load ds with zero and use [ORG 0x7c00], or else load ds with 0x07c0 and use [ORG 0]. However, your code mixes the two.

Turns out the code wasnt really working in the first place lol. The value of rcx in the loop in str_copy is an address and the values of rdi and rsi are not getting switched so if anything, nothing right is happening in that part of the code. To solve this, I initialized another register with the same value of rcx and another function that swaps the address of rdi and rsi so I can copy the contents of string2 to string1 as shown by the function below

That's because is not supported by Firefox. You might prefer using a solution based on the Drag and drop API

I believe this is what you need? You can pivot all the cols except the ones you can choose to exclude like:

One way could be:

if your specific use case is based on some data.frame or list with the colors mapped to certain values in your plotting data. I would suggest anapproach that I've found useful. I added an additional level/value to variable to the cld data.frame.

[EDIT 2021-03-06: thanks to a series of commits over the past ~day (thanks, Liz!), this slowdown is now largely fixed on HEAD; these performance gains should show up in the next monthly release. I'm leaving the answer below as an example of how to dig into this sort of issue, but the specific problems it diagnosed have largely been resolved.]

Building on @Elizabeth Mattijsen's comment: The slow performance here is mostly due to the Rakudo compiler not properly optimizing the generated code (as of 2021-03-05). As the compiler continues to improve, the (idiomatic) code you wrote above should perform much better.

However, for today we can use a few workarounds to speed up this calculation. While it's still true that Raku's performance won't be particularly competitive with R here, some profiling-driven refactoring can make this code nearly an order of magnitude faster.

Here's how we do it:

First, we start by profiling the code. If you run your script with raku --profile=, then you'll get a profile written to . By default, this will be an HTML file that allows you to view the profile in your browser. My preference, however, is to specify an .sql extension, which generates an SQL profile. I then view this profile with MoarProf, the revised profiler that Timo Paulssen is building.

Looking at this profile shows exactly the issue that Liz mentioned: Calls that should be getting inlined are not. To fix this, let's create our own sorting function, which the JIT compiler will happily optimize:

Since I am not aware of a ready-made way of computing your output in any standard library, I came up with the implementation roll_mean_k_efficient below, which seems to speed up your computations considerably. Note that this implementation makes use of the rollapply and the na.locf methods from the zoo package.

Don't use the .org directive. The configure file sets that address: STARTADDRESS: default = $0801.

Also, that directive tells the assembler to tell the linker, "don't relocate the following code". That prevents the .segment directive from doing what we expect it to do.