Dotter

I'm trying to check if a parameter before use it in a function with racket. This parameter must be a list of lists.

I have tried:

I've been trying to add a function to my code which allows the user to search for certain keywords within a list of lists. It only works when the input is identical to the element but I want every element that contains the input to show.

I've encountered strange behavior when using AS3's TouchEvents to handle multi-touch. The touch lags considerably in certain situations, but Flash's frame rate isn't affected. It's as though the touches are getting buffered and the events just aren't dispatched until several seconds after the touch.

I've uploaded a demonstration here: https://youtu.be/omkCDqljfio

I've only managed to reproduce this touch lag in the ActiveX version of Flash Player, but I've reproduced it in both Windows 10 and Windows 7. So what I have here is a C# application that's hosting my AS3 test suite, but it can also be observed if the swf is viewed in Internet Explorer.

Since my application already involves hosting the SWF in a WPF window, I've been attempting to create a solution where touch is received in C# and then communicated to the AS3. It would work perfectly but it seems my WPF window isn't receiving touch frames when the touch is on a WindowsFormsHost. So there's another problem that I have to solve.

FlashDevelop project: https://drive.google.com/file/d/0BxC2eCzurT9rd0gzSGc4TUdQLTQ/view Visual Studio solution: https://drive.google.com/file/d/0BxC2eCzurT9rUThmRHBKWHZmbzA/view

AS3 touch events:

Questions:

1) How is it that numpy.dot() is slower than * in the example code below when BLAS is being used?

2) Is there a way that numpy.dot() can be implemented instead of * in this case for faster array multiplication? I think that I am missing a piece of crucial information which would answer question 1 and mean that numpy.dot() is at least as fast as *, if not faster.

Details included below. Thanks in advance for answers and help.

Details:

I am writing a program which solves coupled PDEs using python 2.7 (64-bit), numpy 1.11.2, Anaconda2 on Windows 7. To improve the accuracy of the program output I need to use large arrays (shape (2, 2^14) and larger) and small integration steps, resulting in a gigantic number of array multiplication operations per simulation which I need to optimize for speed.

Having looked around, it seems as though numpy.dot() should be used for faster array multiplication with respect to * as long as BLAS is installed and working with numpy. This is frequently recommended. However, when I use the timer script below, * is faster than numpy.dot() by at least a factor of 7. In some cases this increases to factors >1000: