LiFT | LinkedIn Fairness Toolkit is a Scala/Spark library | Machine Learning library

To make direct packet accesses in your program, you will need CAP_PERFMON in addition to CAP_BPF. I'm not aware of any way around it.

Why?

Because of Spectre vulnerabilities, someone able to perform arithmetic on unbounded pointers (i.e., all except stack and map value pointers) can read arbitrary memory via speculative out-of-bounds loads.

Such operations thus need to be forbidden for unprivileged users. Allowing CAP_BPF users to perform those operations would essentially give read access to arbitrary memory to CAP_BPF. For those reasons, I doubt this limitation will be lifted in the future.

I found the way to achieve it by

Now you have cmd' of type Console (MaybeT IO a), and want to pass it to a function taking Console (IO a). The first thing you can do is to run the MaybeT monad inside Console and get Console (IO (Maybe a)). You can do this by fmapping runMaybeT.

Once you got Console (IO (Maybe a)), you can pass it to runConsole and get IO (Maybe a). Now, you can lift it to MaybeT IO a using MaybeT.

So it'll be something like this.

Embed the points as (x, y) ↦ (x, y, x² + y²) and test whether there is a separating hyperplane. This works because

• If we have parameters (a, b, c) such that a x + b y + x² + y² < c if (x, y) ∈ A and > c if (x, y) ∈ B, then the comparison is equivalent to (x − (−a/2))² + (y − (−b/2))² ? c + (−a/2)² + (−b/2)², which is equivalent to a separating circle with center (−a/2, −b/2) and radius √(c + (−a/2)² + (−b/2)²);

• Conversely, we can do the algebra to go from a separating circle to a separating hyperplane.

You get the exact same error with the slightly simpler definition of Foo c m given here:

I got a successful solution by decreasing the final time (max=0.04 for successful solution) and rearranging the equations to avoid a possible divide-by-zero:

Use internal __dict__ of Rule instance:

Setup a MRE

Posting an answer so the question can be closed. It took me a while but I think I figured it out.

Thanks to @SethTisue for pointing me to TwoTails. I was able to correctly synthesize a method using the part of the code in that repo. However the bottom line is doing something like this after the typer is not trivially possible. Here is the reason why:

Say you are trying to synthesize and append a method m to a class C after the typer. The problem is if you are synthesizing this method, you will eventually invoke it somewhere new C().m. The membership is resolved during the typer, so the typer will never complete and throw an error method m is not a member of C. So,

1. If you don't require the package information to achieve this, you should do this after the parser

2. If you need the package information, this gets very tricky. You need to add a few new phases after the parser. I will omit the code because it is very lengthy but here is the gist of it.

   1. Phase 1: Accumulate the list of Class Names you will be appending to and their existing method, skip if it's a pre-known class

   2. Phase 2: Go through the code and accumulate a list of all the symbols that correspond to an instance of this class. ValDef and any parameters to the DefDef. If you have implemented Hindley Milner you will immediately identify the problem that will a way to distinguish similarly named symbols in different scopes. There is a lot of existing literature on this that you can read, I am skipping the details.

   3. Phase 3: Go through the code and accumulate a list of method names that are invoked on C but doesn't yet exist. You need to memorize the parameters and their types as well. Whether you need the return type or not really depends on what you are doing and/or if you want extra soundness/verification in a later step. You can skip this phase if the method you are appending is static and you already know what members will be missing in advance.

   4. Phase 4: Go through the code one last time and append a null method into C that with the proper name and types. Retuning null isn't the best thing, not sure if there is a better alternative.

   5. Later in the typer replace the appended method body with the proper one (the one you are copying)

The actual synthesis looks like this but as I mentioned above, if you actually want this to work, you will need to figure out all the stuff above.

As others have stated, Python 3.10 is not currently compatible with Matplotlib. You need to install and use Python 3.9 until it is supported. Until then you have a few options:

You can use the Python Launcher for Windows (py.exe) script to choose which Python version to run like so:

py.exe script help: py -h

List all installed versions py -0

Use a specified version py -3.9

e.g. 1 Create a virtual environment using python 3.9 py -3.9 venv .venv

e.g. 2 install matplotlib with pip using python 3.9 py -3.9 -m pip install matplotlib

On Linux you can run whatever Python version you like like so:

python3.9

You can set up a local (your working directory and all sub-directories) virtual environment that will use your specified version like so:

python3.9 -m venv .venv

Which will set the version of python used to 3.9 while in the local directory, and allow you to type python instead of python3.9 each time you need it.

Another relevant and helpful post by Rotareti here.

Please note that I have not described how to activate and use Python Virtual Environments here in detail, for more information on using them read the python docs.

Reference this answer if you're interested in installing a matplotlib release candidate.