lmu | Legendre Memory Units : Continuous-Time Representation | Machine Learning library

Just luck.

One of the main reasons for requiring stack alignment is so that functions can safely use SSE aligned data instructions such as movaps, which fault if used with unaligned data. However, if puts happens to not use any such instructions, or to do anything else which genuinely requires stack alignment, then no fault will occur (though there may still be a performance penalty).

The compiler is entitled to assume that the stack is aligned and that it can use those instructions if it feels like it. So at any time, if your libc is upgraded or recompiled, it may happen that the new version of puts uses such instructions and your code will mysteriously begin failing.

Obviously you don't want that, so align the darn stack like you're supposed to.

There are relatively few situations in C or assembly programming where violating rules like this is guaranteed to segfault or fail in any other predictable way; instead people say things like "the behavior is undefined" meaning that it could fail in any way you can imagine, or then again it might not. So you really can't draw any conclusions from an experiment where illegal code happens to appear to work. Trial and error is not a good way to learn assembly programming.

First thing I would do is clean up the MATLAB API interface stuff. Remember that in Fortran you do not get automatic type promotion in function/subroutine argument lists like you do in C/C++. So it is important to get the signatures exact. You should NEVER be passing literal integers to MATLAB API functions. You should be passing variables that are typed exactly as the API specifies to ensure that there is not a mismatch. E.g., take this code:

In Python,you don't have to declare a varable,so the "string a=..." is wrong, replace it with "a=..."

And,in python 3.x,print is not a keyword,you will have to use "print(xxx)" and not "print xxx".

There is an encoding problem on the web page whose content you copy pasted in your emacs file, which is why it does not typecheck.

For example, the entity → should be displayed → which is why Agda does not accept this specific definition because it thinks it should be some kind of operator defined earlier.

However, since the encoding problem is all over the file, replacing this specific instance of the problem would not solve it for the whole file.

Another example is â„• that should appear as ℕ.

I corrected the file for you:

Here is a gently modified version of your code. I tried to make it work changing as little as possible:

Since you're able to connect to EC2 instance via SSH, your Security Group allows this.
Now you need to allow requests from the client in this Security Group. You will either need to provide a concrete IP, IP range or allow all IPs (not recommended) in the group.
You can find how to do this here.

The index can only be used for acceleration if it uses the same distance function. Some indexes can support multiple (but not arbitrary) distances, for example the R*-tree can support all spatial distance functions (to a varying success though).

Obviously if you build an index to accelerate Cosine distance, but you ask for Euclidean nearest neighbors, the index cannot and will not be used.

You do not need to use an index, but without your runtime will be O(n²); with an index it can be much faster (depending on parameters, dimensionality, etc. - in the worst case, the index is overhead).

I can't find anything that explains the rarity.

An x86 instruction can have at most one ModR/M + SIB + disp0/8/32. So there are zero instructions with two explicit memory operands.

The x86 memory-memory instructions all have at least one implicit memory operand whose location is baked in to the opcode, like push which accesses the stack, or the string instructions movs and cmps.

What are the exceptions?

I'll use [mem] to indicate a ModR/M addressing mode which can be [rdi], [RIP+whatever], [ebx+eax*4+1234], or whatever you like.

• push [mem]: reads [mem], writes implicit [rsp] (after updating rsp).
• pop [mem]
• call [mem]: reads a new RIP from [mem], pushes a return address on the stack.
• movsb/w/d/q: reads DS:(E)SI, writes ES:(E)DI (or in 64-bit mode RSI and RDI). Both are implicit; only the DS segment reg is overridable. Usable with rep.

• cmpsb/w/d/q: reads DS:(E)SI and ES:(E)DI (or in 64-bit mode RSI and RDI). Both are implicit; only the DS segment reg is overridable. Usable with repe / repne.

• MPX bndstx mib, bnd: "Store the bounds in bnd and the pointer value in the index register of mib to a bound table entry (BTE) with address translation using the base of mib." The Operation section shows a load and a store, but I don't know enough about MPX to grok it.

• movdir64b r16/r32/r64, m512. Has its own feature bit, available in upcoming Tremont (successor to Goldmont Plus Atom). Moves 64-bytes as direct-store (WC) with 64-byte write atomicity from source memory address to destination memory address. Destination operand is (aligned atomic) es: /r from ModRM, source is (unaligned non-atomic) the /m from ModRM.

  Uses write-combining for the store, see the description. It's the first time any x86 CPU vendor has guaranteed atomicity wider than 8 bytes outside of lock cmpxchg16b. But unfortunately it's not actually great for multithreading because it forces NT-like cache eviction/bypass behaviour, so other cores will have to read it from DRAM instead of a shared outer cache.

AVX2 gather and AVX512 scatter instructions are debatable. They obviously do multiple loads / stores, but all the pointers come from one SIMD vector (and a scalar base).

I'm not counting instructions like pusha, fldenv, xsaveopt, iret, or enter with nesting level > 1 that do multiple stores or loads to a contiguous block.

I'm also not counting the ins / outs string instructions, because they copy memory to/from I/O space. I/O space isn't memory.

I didn't look at VMX or SGX instructions on http://felixcloutier.com/x86/index.html, just the main list. I don't think I missed any, but I certainly could have.

Let say you already have a data available in the memory. You could use Pure Java API to create Database and use this database as an input for your clustering algorithm. Full Scala code: