[Python-ideas] Vectorization [was Re: Add list.join() please]

[Adrien Ricocotam]

@D’aprano I think you’re misleading by what I said, sorry for not being
crystal clear.

I just read the link on Julia (which I didn’t do) and I get what you mean
now and it’s not quite different from what I said.

I proposed introducing a new type : « vector »
A few steps have been made in Python for typing and I think the next step
is having typed collections. Keeping with nothing checked is better imo.
So if we take this next step, we’ll get a vector type with *not-guaranteed*
homogeneous data. Whether its type is « object » « int » or anything else
doesn’t matter as long as it’s supposed to be the same.

This doesn’t change anything in term of usage. Of course we should/could
use map and usual operators on collections. What I was then proposing, to
complete what you suggested and because I don’t like the dot notation, is
using the matrix-multiplication the same way it is used in Julia with the
dots.

But I have a question. I never coded anything at C-level nor a compiler, is
this possible for user defined types to make the vectorieation optimized
the same way it’s done with numbers in numpy ?

If yes, I think it would benefit the community. If no, it’s less likely,
though it’s pursuing the steps made with typing

On Sat 2 Feb 2019 at 10:23, Kirill Balunov <kirillbalunov at gmail.com> wrote:

>
>
> сб, 2 февр. 2019 г. в 07:33, Steven D'Aprano <steve at pearwood.info>:
>
>>
>> I didn't say anything about a vector type.
>>
>>
> I agree  you did not say. But since you started a new thread from the one
> where the vector type was a little discussed, it seemed to me  that it is
> appropriate to mention it here. Sorry about that.
>
>
>> > Therefore, it allows you to ensure that the method is present for each
>> > element in the vector. The first given example is what numpy is all
>> about
>> > and without some guarantee that L consists of homogeneous data it hardly
>> > make sense.
>>
>> Of course it makes sense. Even numpy supports inhomogeneous data:
>>
>> py> a = np.array([1, 'spam'])
>> py> a
>> array(['1', 'spam'],
>>       dtype='|S4')
>>
>>
> Yes, numpy, at some degree, supports heterogeneous arrays. But not in the
> way you brought it. Your example just shows homogeneous array of type
> `'|S4'`. In the same way as `np.array([1, 1.234])` will be homogeneous. Of
> course you can say -  np.array([1, 'spam'], dtype='object'), but in this
> case it will also be homogeneous array, but of type `object`.
>
>
>> Inhomogeneous data may rule out some optimizations, but that hardly
>> means that it "doesn't make sense" to use it.
>>
>
> I did not say that it  "doesn't make sense". I only said that you should
> be lucky to call `..method()` on collections of heterogeneous data. And
> therefore, usually this kind of operations imply that you are working with
> a "homogeneous data". Unfortunately, built-in containers cannot provide
> such a guarantee without self-checking. Therefore, in my opinion that at
> the moment such an operator is not needed.
>
> With kind regards,
> -gdg
>
> _______________________________________________
> Python-ideas mailing list
> Python-ideas at python.org
> https://mail.python.org/mailman/listinfo/python-ideas
> Code of Conduct: http://python.org/psf/codeofconduct/
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-ideas/attachments/20190202/3d3343b0/attachment.html>