is this notation common?

Yes, cbrt is used by numpy as scipy for the cubic root.

Hmm, wondering now if there's a way to generically support any function if the name is passed in using a lookup of numpy math function names...(the implementation of the functions would also be pitched to numpy, which maybe should be happening anyway instead of lambdas...)

getattr(np, name)

But this does not really work, because it would not give have access to the inverse function, unless, we explicitly include a list of corresponding inverse functions, which will limit in any case the usage to whatever we allow.
Also it would make the parameters option very complex, because in those cases we would not control the exact shape of the string.

I think with polynomials, roots, and offset logs we can probably cover everything that basic users will want to do, for normalizations. The advanced users can always provide the callables.

So even without getattr, I still prefer calling the numpy functions when possible because they're tested and optimized in a way a bunch of lambda functions aren't.

Sure, but this wil only be possible for the simples cases, none of the para-metrical cases would work, without the lambda. On the other hand inside the lambda the operators will be overloaded by numpy when working with arrays, so I do not think the reliability can be that different.

shrugs I think there's potential for error/typos/etc. in writing your own and in theory the numpy functions are more robust. Also now wondering do you cast lists to arrays or are the lambda functions done in a comprehension in FuncNorm?

Yes, everything is cast into a numpy type automatically.

no base2? (Yeah, this all feels weirdly arbitrary)

Yes, I should include log2

not sure why you don't do a generic 'log{p}' then instead of log10 since users will have to type log10 anyway

I did it like this historically (there were no parameters at the beginning) and then keep it to in a similar way that log10, log and log2 exist separately in numpy. But you are right, being strings probably we can just keep 'log' and 'log{p}'. In any case I definitely should include 'log{p}' which is now missing.

both log can be called log(x,2) or log(x,10) so I figure one unified call is cleaner here.

Let's decide about this later

these should probably be properties instead of getters

I am actually considering getting rid of this, and just support get_func, as a property, and then use the FuncInfo object to obtain the required functions.

I think if params should work equally well.

You should raise KeyError if you're explicitly catching the KeyError, otherwise I don't see the point in differentiating the value errors.

Well, actually from the point of view of the dictionary it is a key error, but from the point of view of the user, it may be seen as a value error in one of the input arguments, as he does not need to know that this is stored in a dictionary and access with the string as a key. In any case, I am happy to switch to KeyError.

The reason I have two cases was to differentiate from TypeError, because in this case it may not be as safe to cast the input as a string for printing the error message. The way the code is now there is no chance it will not be a string, so yes, I am happy to just have a single except.

So yeah, then I vote for use one for now and split if a need arises.

what is this block of code doing?

The func.direct(0.5, params) outside the try block is just a debugging residue.
The one inside the block is meant to check that the callable actually works with the number of parameters parsed. Alternatively I could add a number of expected parameters to _FuncInfo, and then do a manual check on the lengths, I did not do it like this to avoid adding more stuff to the initialization of FuncInfo.

Hmm, please remove debugging residue but I also think that's a weird non-obvious test that the callebe works with parameters passed. Like if it fails, I think it should do so naturally further down the stack where it'll yield it's own specific error message.

Sure, I actually though about this more and there is no way I could fail there, because the implementation guarantees that the parameters are floating point numbers. And the fact that there is a mathing string guarantees that the number of parameters is right.

What I am going to include is the possibility of checking if the parameters are in the right range, and also checking wheter the fucntion is bounded as fucntion of the parameters. This way, we can also allow parameters equal to 0.

shrugs I think there's potential for error/typos/etc. in writing your own and in theory the numpy functions are more robust. Also now wondering do you cast lists to arrays or are the lambda functions done in a comprehension in FuncNorm?

both log can be called log(x,2) or log(x,10) so I figure one unified call is cleaner here.

if you insist on writing your own lambdas instead of using numpy, then please test that the lambda functions are correct (no stray typos or the like)

There is a parametric test for each possible case, and it tests both the direct and the inverse, so it should be ok.

np.power, kwargs={x2:2}
maybe something like that?

But I am not sure how would that help, you would still need the lambda function to pass the kwargs, right?

In any case, I do not think it really is that relevant at this point, we are trying to do something relatively simple for a subset of functions (for which it can be tested) aimed to help FuncNorm and children. If we ever decide to make this accessible class directly accesible to end users, or to let users create their own cuestom _FuncInfo objects, then we can worry about these things.

depends on how it'd be called in FuncNorm...(I'd argue FuncNorm should support passing in f=np.power, kwargs={}) too since that's common enough for numpy. Would also give users a way to call np.piecewise directly.

I agree that FuncNorm should support that (even though it is not as useful as it may seem, imagine a case where the variable is the second argument and not the first one). Anyway we can discuss that in the next PR.

IMO doing that here is a mistake, as it goes against what we are trying to achieve, which is to provide the simplest possible way to specify a simple function. For more complex cases, the user will always be able to use FuncNorm with callables directly, or with a new kwargs option based on your suggestion.

I think you can use the builtin callable here: if callable(bounded_0_1):

I think the callable built in function does not exist for python 3.0 or python 3.1, would this be a problem?

We only support 3.4+.

Also callable here.

Add comma after "parameters".

Naming preference: I suggest "function" and "inverse" rather than "direct" and "inverse".

Replace this block with is_str = isinstance(str_func, six.string_types).

We try hard to avoid bare except: constructs; here, use except ValueError.

This is potentially confusing because the error is that params[i] is not a number, not that it is zero. Just say "Parameter %i is %s, which is not a number." % (i, param)

Unnecessary, given checking in the init? If it is needed, it should be there.

Use for i, param in enumerate(params):

Minor tweak: formatting of the string on python 3 will be better if you replace self._funcs.keys() with [k for k in self._funcs.keys()]. This is redundant on python 2, but still works.

Or list(self._funcs) as in the cleanup PRs.

Who is this message for? What is check params and how would the user know if they messed this up?

This message is for whoever makes instances of _FuncInfo, which given the fact that it is underscored, would most likely be a developer. For now this only happens inside _StringFuncParser, which should have everything right, and never trigger the exception, but I wanted to make it robust enough to be used independently.

check_params is a callable that takes a list of the parameters and returns if that list of parameters is allowed for the function. For example:
'log{2}(x+{0.1})' will have its parameters extracted params=[2.,0.1], and will be transformed into 'log{a}(x+{a})'. Then the check_params stored for that parametric string function will be called check_params(params), and will return True.

If on the other hand if 'log{-2}(x+{0.1})', was called, then params=[-2.,0.1], and check_params(params) will return False, as -2 is not a valid value for the base.

I will make the message a bit more clear, as well and the unofficial documentation of the class.

still don't think you need to bother with a log10 since you have the generic case and the user will never know (they have to write log10 anyway)

think it should just be log and log{p} cases

But by far the most common use case is log10; I think that use of any other base for a norm, or for most plotting purposes, will be somewhere between rare and nonexistent. Therefore it makes sense to leave in 'log10'.

I just think that since log10 is implicitly supported by logp, the redundancy isn't worth it unless it has significant time savings. But shrugs defer to you of coursen

"{} must be a string".format(str_func)

I am not sure if it is a good idea to format something that we know is not a string into a string. What about simply " 'str_func' must be a string"?

I though about it again, and realized that actually your way it is better for cases when the error shows up to an user that does not know where the exception is being raised exactly, so, thank you for your suggestion, it now produces a message like that one :).

since the else is so much shorter, what about flipplng:

if not self._params:
  func = _FuncInfo(func.function, func.inverse,
                            func.is_bounded_0_1())
else:
    #longer block of code

you can drop the if params' 'cause when params is none, the loop just won't happen

I agree for the loop but there is also a piece of code after the loop and within the if block 'str_func = re.sub(regex, '{p}', str_func)', however I still think you are right, because if the original call to 'params = re.findall(regex, str_func)' returns no elements, then re.sub used with the same regex should not replace any elements.

"%s is an invalid string.