O
otto
Thu, Oct 6, 2016 1:41 AM
GPL license now with the code.
On Wed, 5 Oct 2016 18:11:39 -0700
otto otto@123phase.com wrote:
I have written a library for my work with and for openscad that does
affine transforms. I use it to generate a module that will rotate
about the line through any two points in space given the two points.
It simplifies a number of operations if you can wrap your brain around
the affine transform.
Code and test examples are at:
https://github.com/ottojas/openscad-affine
I would appreciate any testing comments etc.
I just created the library and realized I havn't (yet) included the
license for you to do whatever you want with it. I will do that now.
Thanks for any help
Otto
OpenSCAD mailing list
Discuss@lists.openscad.org
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
GPL license now with the code.
On Wed, 5 Oct 2016 18:11:39 -0700
otto <otto@123phase.com> wrote:
> I have written a library for my work with and for openscad that does
> affine transforms. I use it to generate a module that will rotate
> about the line through any two points in space given the two points.
> It simplifies a number of operations if you can wrap your brain around
> the affine transform.
>
> Code and test examples are at:
>
> https://github.com/ottojas/openscad-affine
>
> I would appreciate any testing comments etc.
>
> I just created the library and realized I havn't (yet) included the
> license for you to do whatever you want with it. I will do that now.
>
> Thanks for any help
> Otto
>
> _______________________________________________
> OpenSCAD mailing list
> Discuss@lists.openscad.org
> http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
O
otto
Mon, Oct 10, 2016 8:53 AM
I have hacked the openscad source code to support function indirection.
Here is a sample of how it works. Function is decorated with the "@"
character when it is created and when it is used, but not when it is
passed to another function.
//Preferred usage//
function @xsq(x) = x*x;
function @recip(x)=1/x;
vec1=[1,2,3];
vec2=[.1,.7];
function map(func,vec) = [for (i=vec) @func(i)];
echo(map(xsq,vec1));
echo(map(xsq,vec2));
echo(map(recip,vec1));
echo(map(recip,vec2));
//Other crazy usage//
function div3(x)=x/3;
indirect = "div3";
echo(map(indirect,vec2));
Output is:
ECHO: [1, 4, 9]
ECHO: [0.01, 0.49]
ECHO: [1, 0.5, 0.333333]
ECHO: [10, 1.42857]
ECHO: [0.0333333, 0.233333]
Everything is contained in the github repositor:
https://github.com/ottojas/openscad-affine
There is a pdf file there with some sample 3D and 2D output. In order
to get this capability you need to add about 30 lines of code in
changes to five files in the source directory. These are relatively
stable files and you may get away with simply copying them from the
ojasSources directory.
This is very much a work in progress. Comments, questions, flames,
laughter, mockery etc. all welcome. If anyone tests this please let me
know what your experience is. Everything is gnu public license as is
the source code for openscad.
Regards
Otto
I have hacked the openscad source code to support function indirection.
Here is a sample of how it works. Function is decorated with the "@"
character when it is created and when it is used, but not when it is
passed to another function.
//Preferred usage//
function @xsq(x) = x*x;
function @recip(x)=1/x;
vec1=[1,2,3];
vec2=[.1,.7];
function map(func,vec) = [for (i=vec) @func(i)];
echo(map(xsq,vec1));
echo(map(xsq,vec2));
echo(map(recip,vec1));
echo(map(recip,vec2));
//Other crazy usage//
function div3(x)=x/3;
indirect = "div3";
echo(map(indirect,vec2));
Output is:
ECHO: [1, 4, 9]
ECHO: [0.01, 0.49]
ECHO: [1, 0.5, 0.333333]
ECHO: [10, 1.42857]
ECHO: [0.0333333, 0.233333]
Everything is contained in the github repositor:
https://github.com/ottojas/openscad-affine
There is a pdf file there with some sample 3D and 2D output. In order
to get this capability you need to add about 30 lines of code in
changes to five files in the source directory. These are relatively
stable files and you may get away with simply copying them from the
ojasSources directory.
This is very much a work in progress. Comments, questions, flames,
laughter, mockery etc. all welcome. If anyone tests this please let me
know what your experience is. Everything is gnu public license as is
the source code for openscad.
Regards
Otto
NH
nop head
Mon, Oct 10, 2016 9:06 AM
You don't seem to use the @ sign in the places I would expect. I don't see
a need for them in the function definition as any function should be
passable as an argument. I would expect them to be needed where a function
is called from a string, so:
function xsq(x) = x*x;
function recip(x)=1/x;
vec1=[1,2,3];
vec2=[.1,.7];
function map(func,vec) = [for (i=vec) @func(i)];
echo(map("xsq",vec1));
echo(map"("xsq",vec2));
echo(map("recip",vec1));
echo(map("recip",vec2));
The @ sign could also be used to make a function literal instead of passing
string but that is a bigger change to the language. Simply adding @ to take
a string and look up function seems like a simple mod. Creating a new
variable type that is a function would have much bigger implications
because it could be used in any expression. Keeping the name as a string
allows all sorts of tricks by concatenating suffixes, etc.
On 10 October 2016 at 09:53, otto otto@123phase.com wrote:
I have hacked the openscad source code to support function indirection.
Here is a sample of how it works. Function is decorated with the "@"
character when it is created and when it is used, but not when it is
passed to another function.
//Preferred usage//
function @xsq(x) = x*x;
function @recip(x)=1/x;
vec1=[1,2,3];
vec2=[.1,.7];
function map(func,vec) = [for (i=vec) @func(i)];
echo(map(xsq,vec1));
echo(map(xsq,vec2));
echo(map(recip,vec1));
echo(map(recip,vec2));
//Other crazy usage//
function div3(x)=x/3;
indirect = "div3";
echo(map(indirect,vec2));
Output is:
ECHO: [1, 4, 9]
ECHO: [0.01, 0.49]
ECHO: [1, 0.5, 0.333333]
ECHO: [10, 1.42857]
ECHO: [0.0333333, 0.233333]
Everything is contained in the github repositor:
https://github.com/ottojas/openscad-affine
There is a pdf file there with some sample 3D and 2D output. In order
to get this capability you need to add about 30 lines of code in
changes to five files in the source directory. These are relatively
stable files and you may get away with simply copying them from the
ojasSources directory.
This is very much a work in progress. Comments, questions, flames,
laughter, mockery etc. all welcome. If anyone tests this please let me
know what your experience is. Everything is gnu public license as is
the source code for openscad.
Regards
Otto
OpenSCAD mailing list
Discuss@lists.openscad.org
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
You don't seem to use the @ sign in the places I would expect. I don't see
a need for them in the function definition as any function should be
passable as an argument. I would expect them to be needed where a function
is called from a string, so:
function xsq(x) = x*x;
function recip(x)=1/x;
vec1=[1,2,3];
vec2=[.1,.7];
function map(func,vec) = [for (i=vec) @func(i)];
echo(map("xsq",vec1));
echo(map"("xsq",vec2));
echo(map("recip",vec1));
echo(map("recip",vec2));
The @ sign could also be used to make a function literal instead of passing
string but that is a bigger change to the language. Simply adding @ to take
a string and look up function seems like a simple mod. Creating a new
variable type that is a function would have much bigger implications
because it could be used in any expression. Keeping the name as a string
allows all sorts of tricks by concatenating suffixes, etc.
On 10 October 2016 at 09:53, otto <otto@123phase.com> wrote:
> I have hacked the openscad source code to support function indirection.
>
> Here is a sample of how it works. Function is decorated with the "@"
> character when it is created and when it is used, but not when it is
> passed to another function.
>
> //Preferred usage//
> function @xsq(x) = x*x;
> function @recip(x)=1/x;
> vec1=[1,2,3];
> vec2=[.1,.7];
>
> function map(func,vec) = [for (i=vec) @func(i)];
> echo(map(xsq,vec1));
> echo(map(xsq,vec2));
> echo(map(recip,vec1));
> echo(map(recip,vec2));
>
> //Other crazy usage//
> function div3(x)=x/3;
> indirect = "div3";
> echo(map(indirect,vec2));
>
> Output is:
>
> ECHO: [1, 4, 9]
> ECHO: [0.01, 0.49]
> ECHO: [1, 0.5, 0.333333]
> ECHO: [10, 1.42857]
> ECHO: [0.0333333, 0.233333]
>
>
> Everything is contained in the github repositor:
> https://github.com/ottojas/openscad-affine
>
> There is a pdf file there with some sample 3D and 2D output. In order
> to get this capability you need to add about 30 lines of code in
> changes to five files in the source directory. These are relatively
> stable files and you may get away with simply copying them from the
> ojasSources directory.
>
> This is very much a work in progress. Comments, questions, flames,
> laughter, mockery etc. all welcome. If anyone tests this please let me
> know what your experience is. Everything is gnu public license as is
> the source code for openscad.
>
> Regards
> Otto
>
>
>
>
>
> _______________________________________________
> OpenSCAD mailing list
> Discuss@lists.openscad.org
> http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
>
O
otto
Mon, Oct 10, 2016 9:19 AM
On Mon, 10 Oct 2016 10:06:50 +0100
nop head nop.head@gmail.com wrote:
The goal was to get what I wanted easily. The changes are small and
the code seems quite stable.
In declaring a function with the @ decoration.
As in function @xsq(x) = x*x
xsq is an ID token and the variable xsq is given a unique function name
as its contents. The name is a digit followed by a period. You can
see it by echoing xsq.
You can then pass xsq around and then dereference it with @. Because we
use openscads well designed and consistent parsing/compiling environment
to do all the work, this is fast. As designed I hadn't really
anticipated the side effect that any function can be passed as its token
name, and dereferenced later. The great thing about this is that the
compiler resolves functions by there string name and all I needed to do
was detect the decorator in the parser and then do one level of
indirection. The nice thing is it is safe, it doesn't break other code
and it requires only small changes to the source code and it works
now. Please test the code in the repository if you are inclined or
have the time.
Regards
Otto
You don't seem to use the @ sign in the places I would expect. I
don't see a need for them in the function definition as any function
should be passable as an argument. I would expect them to be needed
where a function is called from a string, so:
function xsq(x) = x*x;
function recip(x)=1/x;
vec1=[1,2,3];
vec2=[.1,.7];
function map(func,vec) = [for (i=vec) @func(i)];
echo(map("xsq",vec1));
echo(map"("xsq",vec2));
echo(map("recip",vec1));
echo(map("recip",vec2));
The @ sign could also be used to make a function literal instead of
passing string but that is a bigger change to the language. Simply
adding @ to take a string and look up function seems like a simple
mod. Creating a new variable type that is a function would have much
bigger implications because it could be used in any expression.
Keeping the name as a string allows all sorts of tricks by
concatenating suffixes, etc.
On 10 October 2016 at 09:53, otto otto@123phase.com wrote:
I have hacked the openscad source code to support function
indirection.
Here is a sample of how it works. Function is decorated with the
"@" character when it is created and when it is used, but not when
it is passed to another function.
//Preferred usage//
function @xsq(x) = x*x;
function @recip(x)=1/x;
vec1=[1,2,3];
vec2=[.1,.7];
function map(func,vec) = [for (i=vec) @func(i)];
echo(map(xsq,vec1));
echo(map(xsq,vec2));
echo(map(recip,vec1));
echo(map(recip,vec2));
//Other crazy usage//
function div3(x)=x/3;
indirect = "div3";
echo(map(indirect,vec2));
Output is:
ECHO: [1, 4, 9]
ECHO: [0.01, 0.49]
ECHO: [1, 0.5, 0.333333]
ECHO: [10, 1.42857]
ECHO: [0.0333333, 0.233333]
Everything is contained in the github repositor:
https://github.com/ottojas/openscad-affine
There is a pdf file there with some sample 3D and 2D output. In
order to get this capability you need to add about 30 lines of code
in changes to five files in the source directory. These are
relatively stable files and you may get away with simply copying
them from the ojasSources directory.
This is very much a work in progress. Comments, questions, flames,
laughter, mockery etc. all welcome. If anyone tests this please
let me know what your experience is. Everything is gnu public
license as is the source code for openscad.
Regards
Otto
OpenSCAD mailing list
Discuss@lists.openscad.org
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
On Mon, 10 Oct 2016 10:06:50 +0100
nop head <nop.head@gmail.com> wrote:
The goal was to get what I wanted easily. The changes are small and
the code seems quite stable.
In declaring a function with the @ decoration.
As in function @xsq(x) = x*x
xsq is an ID token and the variable xsq is given a unique function name
as its contents. The name is a digit followed by a period. You can
see it by echoing xsq.
You can then pass xsq around and then dereference it with @. Because we
use openscads well designed and consistent parsing/compiling environment
to do all the work, this is fast. As designed I hadn't really
anticipated the side effect that any function can be passed as its token
name, and dereferenced later. The great thing about this is that the
compiler resolves functions by there string name and all I needed to do
was detect the decorator in the parser and then do one level of
indirection. The nice thing is it is safe, it doesn't break other code
and it requires only small changes to the source code and it works
now. Please test the code in the repository if you are inclined or
have the time.
Regards
Otto
> You don't seem to use the @ sign in the places I would expect. I
> don't see a need for them in the function definition as any function
> should be passable as an argument. I would expect them to be needed
> where a function is called from a string, so:
>
> function xsq(x) = x*x;
> function recip(x)=1/x;
> vec1=[1,2,3];
> vec2=[.1,.7];
>
> function map(func,vec) = [for (i=vec) @func(i)];
> echo(map("xsq",vec1));
> echo(map"("xsq",vec2));
> echo(map("recip",vec1));
> echo(map("recip",vec2));
>
> The @ sign could also be used to make a function literal instead of
> passing string but that is a bigger change to the language. Simply
> adding @ to take a string and look up function seems like a simple
> mod. Creating a new variable type that is a function would have much
> bigger implications because it could be used in any expression.
> Keeping the name as a string allows all sorts of tricks by
> concatenating suffixes, etc.
>
>
>
> On 10 October 2016 at 09:53, otto <otto@123phase.com> wrote:
>
> > I have hacked the openscad source code to support function
> > indirection.
> >
> > Here is a sample of how it works. Function is decorated with the
> > "@" character when it is created and when it is used, but not when
> > it is passed to another function.
> >
> > //Preferred usage//
> > function @xsq(x) = x*x;
> > function @recip(x)=1/x;
> > vec1=[1,2,3];
> > vec2=[.1,.7];
> >
> > function map(func,vec) = [for (i=vec) @func(i)];
> > echo(map(xsq,vec1));
> > echo(map(xsq,vec2));
> > echo(map(recip,vec1));
> > echo(map(recip,vec2));
> >
> > //Other crazy usage//
> > function div3(x)=x/3;
> > indirect = "div3";
> > echo(map(indirect,vec2));
> >
> > Output is:
> >
> > ECHO: [1, 4, 9]
> > ECHO: [0.01, 0.49]
> > ECHO: [1, 0.5, 0.333333]
> > ECHO: [10, 1.42857]
> > ECHO: [0.0333333, 0.233333]
> >
> >
> > Everything is contained in the github repositor:
> > https://github.com/ottojas/openscad-affine
> >
> > There is a pdf file there with some sample 3D and 2D output. In
> > order to get this capability you need to add about 30 lines of code
> > in changes to five files in the source directory. These are
> > relatively stable files and you may get away with simply copying
> > them from the ojasSources directory.
> >
> > This is very much a work in progress. Comments, questions, flames,
> > laughter, mockery etc. all welcome. If anyone tests this please
> > let me know what your experience is. Everything is gnu public
> > license as is the source code for openscad.
> >
> > Regards
> > Otto
> >
> >
> >
> >
> >
> > _______________________________________________
> > OpenSCAD mailing list
> > Discuss@lists.openscad.org
> > http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
> >
NH
nop head
Mon, Oct 10, 2016 9:44 AM
So @xsq becomes both a name mangled function and a variable holding its
name? That seems like a bit of a kludge to me.
Defining functions normally and passing them with @name would allow the
compiler to check it was a valid function name without having to have
specially decorated functions. They could be passed as string equal to
their name and then calling @func() could work with any string that equals
a function name. Seems less kludgey to me. You only have one type of
function rather than ones that have to be called normally and ones that
need to be called with @.
On 10 October 2016 at 10:19, otto otto@123phase.com wrote:
On Mon, 10 Oct 2016 10:06:50 +0100
nop head nop.head@gmail.com wrote:
The goal was to get what I wanted easily. The changes are small and
the code seems quite stable.
In declaring a function with the @ decoration.
As in function @xsq(x) = x*x
xsq is an ID token and the variable xsq is given a unique function name
as its contents. The name is a digit followed by a period. You can
see it by echoing xsq.
You can then pass xsq around and then dereference it with @. Because we
use openscads well designed and consistent parsing/compiling environment
to do all the work, this is fast. As designed I hadn't really
anticipated the side effect that any function can be passed as its token
name, and dereferenced later. The great thing about this is that the
compiler resolves functions by there string name and all I needed to do
was detect the decorator in the parser and then do one level of
indirection. The nice thing is it is safe, it doesn't break other code
and it requires only small changes to the source code and it works
now. Please test the code in the repository if you are inclined or
have the time.
Regards
Otto
You don't seem to use the @ sign in the places I would expect. I
don't see a need for them in the function definition as any function
should be passable as an argument. I would expect them to be needed
where a function is called from a string, so:
function xsq(x) = x*x;
function recip(x)=1/x;
vec1=[1,2,3];
vec2=[.1,.7];
function map(func,vec) = [for (i=vec) @func(i)];
echo(map("xsq",vec1));
echo(map"("xsq",vec2));
echo(map("recip",vec1));
echo(map("recip",vec2));
The @ sign could also be used to make a function literal instead of
passing string but that is a bigger change to the language. Simply
adding @ to take a string and look up function seems like a simple
mod. Creating a new variable type that is a function would have much
bigger implications because it could be used in any expression.
Keeping the name as a string allows all sorts of tricks by
concatenating suffixes, etc.
On 10 October 2016 at 09:53, otto otto@123phase.com wrote:
I have hacked the openscad source code to support function
indirection.
Here is a sample of how it works. Function is decorated with the
"@" character when it is created and when it is used, but not when
it is passed to another function.
//Preferred usage//
function @xsq(x) = x*x;
function @recip(x)=1/x;
vec1=[1,2,3];
vec2=[.1,.7];
function map(func,vec) = [for (i=vec) @func(i)];
echo(map(xsq,vec1));
echo(map(xsq,vec2));
echo(map(recip,vec1));
echo(map(recip,vec2));
//Other crazy usage//
function div3(x)=x/3;
indirect = "div3";
echo(map(indirect,vec2));
Output is:
ECHO: [1, 4, 9]
ECHO: [0.01, 0.49]
ECHO: [1, 0.5, 0.333333]
ECHO: [10, 1.42857]
ECHO: [0.0333333, 0.233333]
Everything is contained in the github repositor:
https://github.com/ottojas/openscad-affine
There is a pdf file there with some sample 3D and 2D output. In
order to get this capability you need to add about 30 lines of code
in changes to five files in the source directory. These are
relatively stable files and you may get away with simply copying
them from the ojasSources directory.
This is very much a work in progress. Comments, questions, flames,
laughter, mockery etc. all welcome. If anyone tests this please
let me know what your experience is. Everything is gnu public
license as is the source code for openscad.
Regards
Otto
OpenSCAD mailing list
Discuss@lists.openscad.org
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
So @xsq becomes both a name mangled function and a variable holding its
name? That seems like a bit of a kludge to me.
Defining functions normally and passing them with @name would allow the
compiler to check it was a valid function name without having to have
specially decorated functions. They could be passed as string equal to
their name and then calling @func() could work with any string that equals
a function name. Seems less kludgey to me. You only have one type of
function rather than ones that have to be called normally and ones that
need to be called with @.
On 10 October 2016 at 10:19, otto <otto@123phase.com> wrote:
> On Mon, 10 Oct 2016 10:06:50 +0100
> nop head <nop.head@gmail.com> wrote:
>
> The goal was to get what I wanted easily. The changes are small and
> the code seems quite stable.
>
> In declaring a function with the @ decoration.
>
> As in function @xsq(x) = x*x
> xsq is an ID token and the variable xsq is given a unique function name
> as its contents. The name is a digit followed by a period. You can
> see it by echoing xsq.
>
> You can then pass xsq around and then dereference it with @. Because we
> use openscads well designed and consistent parsing/compiling environment
> to do all the work, this is fast. As designed I hadn't really
> anticipated the side effect that any function can be passed as its token
> name, and dereferenced later. The great thing about this is that the
> compiler resolves functions by there string name and all I needed to do
> was detect the decorator in the parser and then do one level of
> indirection. The nice thing is it is safe, it doesn't break other code
> and it requires only small changes to the source code and it works
> now. Please test the code in the repository if you are inclined or
> have the time.
>
>
> Regards
> Otto
>
>
> > You don't seem to use the @ sign in the places I would expect. I
> > don't see a need for them in the function definition as any function
> > should be passable as an argument. I would expect them to be needed
> > where a function is called from a string, so:
> >
> > function xsq(x) = x*x;
> > function recip(x)=1/x;
> > vec1=[1,2,3];
> > vec2=[.1,.7];
> >
> > function map(func,vec) = [for (i=vec) @func(i)];
> > echo(map("xsq",vec1));
> > echo(map"("xsq",vec2));
> > echo(map("recip",vec1));
> > echo(map("recip",vec2));
> >
> > The @ sign could also be used to make a function literal instead of
> > passing string but that is a bigger change to the language. Simply
> > adding @ to take a string and look up function seems like a simple
> > mod. Creating a new variable type that is a function would have much
> > bigger implications because it could be used in any expression.
> > Keeping the name as a string allows all sorts of tricks by
> > concatenating suffixes, etc.
> >
> >
> >
> > On 10 October 2016 at 09:53, otto <otto@123phase.com> wrote:
> >
> > > I have hacked the openscad source code to support function
> > > indirection.
> > >
> > > Here is a sample of how it works. Function is decorated with the
> > > "@" character when it is created and when it is used, but not when
> > > it is passed to another function.
> > >
> > > //Preferred usage//
> > > function @xsq(x) = x*x;
> > > function @recip(x)=1/x;
> > > vec1=[1,2,3];
> > > vec2=[.1,.7];
> > >
> > > function map(func,vec) = [for (i=vec) @func(i)];
> > > echo(map(xsq,vec1));
> > > echo(map(xsq,vec2));
> > > echo(map(recip,vec1));
> > > echo(map(recip,vec2));
> > >
> > > //Other crazy usage//
> > > function div3(x)=x/3;
> > > indirect = "div3";
> > > echo(map(indirect,vec2));
> > >
> > > Output is:
> > >
> > > ECHO: [1, 4, 9]
> > > ECHO: [0.01, 0.49]
> > > ECHO: [1, 0.5, 0.333333]
> > > ECHO: [10, 1.42857]
> > > ECHO: [0.0333333, 0.233333]
> > >
> > >
> > > Everything is contained in the github repositor:
> > > https://github.com/ottojas/openscad-affine
> > >
> > > There is a pdf file there with some sample 3D and 2D output. In
> > > order to get this capability you need to add about 30 lines of code
> > > in changes to five files in the source directory. These are
> > > relatively stable files and you may get away with simply copying
> > > them from the ojasSources directory.
> > >
> > > This is very much a work in progress. Comments, questions, flames,
> > > laughter, mockery etc. all welcome. If anyone tests this please
> > > let me know what your experience is. Everything is gnu public
> > > license as is the source code for openscad.
> > >
> > > Regards
> > > Otto
> > >
> > >
> > >
> > >
> > >
> > > _______________________________________________
> > > OpenSCAD mailing list
> > > Discuss@lists.openscad.org
> > > http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
> > >
>
>
> _______________________________________________
> OpenSCAD mailing list
> Discuss@lists.openscad.org
> http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
>
O
otto
Mon, Oct 10, 2016 5:13 PM
So @xsq becomes both a name mangled function and a variable holding
its name? That seems like a bit of a kludge to me.
Well its like this, you can pass a function with the name of the
function in quotes.
function div3(x)=x/3;
vec = [1,2,3];
function map(func,vec) = [for (i=vec) @func(i)];
echo(map("div3",vec));
And it works:
Compiling design (CSG Tree generation)...
ECHO: [0.333333, 0.666667, 1]
Using the construct funcion @xyz .., gives you a way to create a
function and have the compiler generate a name for the function and put
it in a variable for you. "@" used in other contexts is simply a
dereferencing operator. It does require that the name following the
"@" is a variable name known by the compiler and not an expression
returning a string. "@concat("d","iv3")" will not work.
A syntax that would work nicely (but requires more hacking on my part)
would be to create true anonymous functions with syntax such as follows.
Abandon the "function @...",
shorten it to "@(<argument list>,<function,def>)"
Which returns the created name of the function. This would allow for
a more anonymous lambda like usage.
Map could then be invoked, map(@(x,x/3),[1,2,3]), which is more compact
and would get the right behavior.
Thanks for the questions and idea. You are helping me think it
through. Please try current code. I think I will try to program
this capability next week. I am going on a trip this week.
BTW what is best way to pass on this code in github.
Regards
Otto
Defining functions normally and passing them with @name would allow
the compiler to check it was a valid function name without having to
have specially decorated functions. They could be passed as string
equal to their name and then calling @func() could work with any
string that equals a function name. Seems less kludgey to me. You
only have one type of function rather than ones that have to be
called normally and ones that need to be called with @.
On 10 October 2016 at 10:19, otto otto@123phase.com wrote:
On Mon, 10 Oct 2016 10:06:50 +0100
nop head nop.head@gmail.com wrote:
The goal was to get what I wanted easily. The changes are small and
the code seems quite stable.
In declaring a function with the @ decoration.
As in function @xsq(x) = x*x
xsq is an ID token and the variable xsq is given a unique function
name as its contents. The name is a digit followed by a period.
You can see it by echoing xsq.
You can then pass xsq around and then dereference it with @.
Because we use openscads well designed and consistent
parsing/compiling environment to do all the work, this is fast. As
designed I hadn't really anticipated the side effect that any
function can be passed as its token name, and dereferenced later.
The great thing about this is that the compiler resolves functions
by there string name and all I needed to do was detect the
decorator in the parser and then do one level of indirection. The
nice thing is it is safe, it doesn't break other code and it
requires only small changes to the source code and it works now.
Please test the code in the repository if you are inclined or have
the time.
Regards
Otto
You don't seem to use the @ sign in the places I would expect. I
don't see a need for them in the function definition as any
function should be passable as an argument. I would expect them
to be needed where a function is called from a string, so:
function xsq(x) = x*x;
function recip(x)=1/x;
vec1=[1,2,3];
vec2=[.1,.7];
function map(func,vec) = [for (i=vec) @func(i)];
echo(map("xsq",vec1));
echo(map"("xsq",vec2));
echo(map("recip",vec1));
echo(map("recip",vec2));
The @ sign could also be used to make a function literal instead
of passing string but that is a bigger change to the language.
Simply adding @ to take a string and look up function seems like
a simple mod. Creating a new variable type that is a function
would have much bigger implications because it could be used in
any expression. Keeping the name as a string allows all sorts of
tricks by concatenating suffixes, etc.
On 10 October 2016 at 09:53, otto otto@123phase.com wrote:
I have hacked the openscad source code to support function
indirection.
Here is a sample of how it works. Function is decorated with
the "@" character when it is created and when it is used, but
not when it is passed to another function.
//Preferred usage//
function @xsq(x) = x*x;
function @recip(x)=1/x;
vec1=[1,2,3];
vec2=[.1,.7];
function map(func,vec) = [for (i=vec) @func(i)];
echo(map(xsq,vec1));
echo(map(xsq,vec2));
echo(map(recip,vec1));
echo(map(recip,vec2));
//Other crazy usage//
function div3(x)=x/3;
indirect = "div3";
echo(map(indirect,vec2));
Output is:
ECHO: [1, 4, 9]
ECHO: [0.01, 0.49]
ECHO: [1, 0.5, 0.333333]
ECHO: [10, 1.42857]
ECHO: [0.0333333, 0.233333]
Everything is contained in the github repositor:
https://github.com/ottojas/openscad-affine
There is a pdf file there with some sample 3D and 2D output. In
order to get this capability you need to add about 30 lines of
code in changes to five files in the source directory. These
are relatively stable files and you may get away with simply
copying them from the ojasSources directory.
This is very much a work in progress. Comments, questions,
flames, laughter, mockery etc. all welcome. If anyone tests
this please let me know what your experience is. Everything is
gnu public license as is the source code for openscad.
Regards
Otto
OpenSCAD mailing list
Discuss@lists.openscad.org
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
On Mon, 10 Oct 2016 10:44:13 +0100
nop head <nop.head@gmail.com> wrote:
> So @xsq becomes both a name mangled function and a variable holding
> its name? That seems like a bit of a kludge to me.
Well its like this, you can pass a function with the name of the
function in quotes.
function div3(x)=x/3;
vec = [1,2,3];
function map(func,vec) = [for (i=vec) @func(i)];
echo(map("div3",vec));
And it works:
Compiling design (CSG Tree generation)...
ECHO: [0.333333, 0.666667, 1]
Using the construct funcion @xyz .., gives you a way to create a
function and have the compiler generate a name for the function and put
it in a variable for you. "@" used in other contexts is simply a
dereferencing operator. It does require that the name following the
"@" is a variable name known by the compiler and not an expression
returning a string. "@concat("d","iv3")" will not work.
A syntax that would work nicely (but requires more hacking on my part)
would be to create true anonymous functions with syntax such as follows.
Abandon the "function @...",
shorten it to "@(<argument list>,<function,def>)"
Which returns the created name of the function. This would allow for
a more anonymous lambda like usage.
Map could then be invoked, map(@(x,x/3),[1,2,3]), which is more compact
and would get the right behavior.
Thanks for the questions and idea. You are helping me think it
through. Please try current code. I think I will try to program
this capability next week. I am going on a trip this week.
BTW what is best way to pass on this code in github.
Regards
Otto
>
> Defining functions normally and passing them with @name would allow
> the compiler to check it was a valid function name without having to
> have specially decorated functions. They could be passed as string
> equal to their name and then calling @func() could work with any
> string that equals a function name. Seems less kludgey to me. You
> only have one type of function rather than ones that have to be
> called normally and ones that need to be called with @.
>
> On 10 October 2016 at 10:19, otto <otto@123phase.com> wrote:
>
> > On Mon, 10 Oct 2016 10:06:50 +0100
> > nop head <nop.head@gmail.com> wrote:
> >
> > The goal was to get what I wanted easily. The changes are small and
> > the code seems quite stable.
> >
> > In declaring a function with the @ decoration.
> >
> > As in function @xsq(x) = x*x
> > xsq is an ID token and the variable xsq is given a unique function
> > name as its contents. The name is a digit followed by a period.
> > You can see it by echoing xsq.
> >
> > You can then pass xsq around and then dereference it with @.
> > Because we use openscads well designed and consistent
> > parsing/compiling environment to do all the work, this is fast. As
> > designed I hadn't really anticipated the side effect that any
> > function can be passed as its token name, and dereferenced later.
> > The great thing about this is that the compiler resolves functions
> > by there string name and all I needed to do was detect the
> > decorator in the parser and then do one level of indirection. The
> > nice thing is it is safe, it doesn't break other code and it
> > requires only small changes to the source code and it works now.
> > Please test the code in the repository if you are inclined or have
> > the time.
> >
> >
> > Regards
> > Otto
> >
> >
> > > You don't seem to use the @ sign in the places I would expect. I
> > > don't see a need for them in the function definition as any
> > > function should be passable as an argument. I would expect them
> > > to be needed where a function is called from a string, so:
> > >
> > > function xsq(x) = x*x;
> > > function recip(x)=1/x;
> > > vec1=[1,2,3];
> > > vec2=[.1,.7];
> > >
> > > function map(func,vec) = [for (i=vec) @func(i)];
> > > echo(map("xsq",vec1));
> > > echo(map"("xsq",vec2));
> > > echo(map("recip",vec1));
> > > echo(map("recip",vec2));
> > >
> > > The @ sign could also be used to make a function literal instead
> > > of passing string but that is a bigger change to the language.
> > > Simply adding @ to take a string and look up function seems like
> > > a simple mod. Creating a new variable type that is a function
> > > would have much bigger implications because it could be used in
> > > any expression. Keeping the name as a string allows all sorts of
> > > tricks by concatenating suffixes, etc.
> > >
> > >
> > >
> > > On 10 October 2016 at 09:53, otto <otto@123phase.com> wrote:
> > >
> > > > I have hacked the openscad source code to support function
> > > > indirection.
> > > >
> > > > Here is a sample of how it works. Function is decorated with
> > > > the "@" character when it is created and when it is used, but
> > > > not when it is passed to another function.
> > > >
> > > > //Preferred usage//
> > > > function @xsq(x) = x*x;
> > > > function @recip(x)=1/x;
> > > > vec1=[1,2,3];
> > > > vec2=[.1,.7];
> > > >
> > > > function map(func,vec) = [for (i=vec) @func(i)];
> > > > echo(map(xsq,vec1));
> > > > echo(map(xsq,vec2));
> > > > echo(map(recip,vec1));
> > > > echo(map(recip,vec2));
> > > >
> > > > //Other crazy usage//
> > > > function div3(x)=x/3;
> > > > indirect = "div3";
> > > > echo(map(indirect,vec2));
> > > >
> > > > Output is:
> > > >
> > > > ECHO: [1, 4, 9]
> > > > ECHO: [0.01, 0.49]
> > > > ECHO: [1, 0.5, 0.333333]
> > > > ECHO: [10, 1.42857]
> > > > ECHO: [0.0333333, 0.233333]
> > > >
> > > >
> > > > Everything is contained in the github repositor:
> > > > https://github.com/ottojas/openscad-affine
> > > >
> > > > There is a pdf file there with some sample 3D and 2D output. In
> > > > order to get this capability you need to add about 30 lines of
> > > > code in changes to five files in the source directory. These
> > > > are relatively stable files and you may get away with simply
> > > > copying them from the ojasSources directory.
> > > >
> > > > This is very much a work in progress. Comments, questions,
> > > > flames, laughter, mockery etc. all welcome. If anyone tests
> > > > this please let me know what your experience is. Everything is
> > > > gnu public license as is the source code for openscad.
> > > >
> > > > Regards
> > > > Otto
> > > >
> > > >
> > > >
> > > >
> > > >
> > > > _______________________________________________
> > > > OpenSCAD mailing list
> > > > Discuss@lists.openscad.org
> > > > http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
> > > >
> >
> >
> > _______________________________________________
> > OpenSCAD mailing list
> > Discuss@lists.openscad.org
> > http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
> >
B
Bananapeel
Mon, Oct 10, 2016 7:15 PM
I don't know why this thread is inside the thread "Convert from object to
polygon/polyhedron." Anyways, regarding passing functions as arguments:
IMO, there's just one "proper" syntax for this. And that is, that the name
without () acts as a variable, and () means call. And function becomes just
another type, like string and int. This means functions and variables must
occupy the same namespace. This syntax can also work for modules, however,
this means variables, functions and modules all share the same namespace,
which currently isn't the case.
Using () on a variable that isn't of type function or module would give a
runtime error.
Example:
//Preferred usage//
function xsq(x) = x*x;
function recip(x)=1/x;
vec1=[1, 2, 3];
vec2=[0.1, 0.7];
function map(func,vec) = [for (i=vec) func(i)];
echo(map(xsq,vec1));
echo(map(xsq,vec2));
echo(map(recip,vec1));
echo(map(recip,vec2));
//Other crazy usage//
function div3(x)=x/3;
indirect = div3;
echo(map(indirect,vec2));
--
View this message in context: http://forum.openscad.org/Convert-from-object-to-polygon-polyhedron-tp18522p18659.html
Sent from the OpenSCAD mailing list archive at Nabble.com.
I don't know why this thread is inside the thread "Convert from object to
polygon/polyhedron." Anyways, regarding passing functions as arguments:
IMO, there's just one "proper" syntax for this. And that is, that the name
without () acts as a variable, and () means call. And function becomes just
another type, like string and int. This means functions and variables must
occupy the same namespace. This syntax can also work for modules, however,
this means variables, functions and modules all share the same namespace,
which currently isn't the case.
Using () on a variable that isn't of type function or module would give a
runtime error.
Example:
//Preferred usage//
function xsq(x) = x*x;
function recip(x)=1/x;
vec1=[1, 2, 3];
vec2=[0.1, 0.7];
function map(func,vec) = [for (i=vec) func(i)];
echo(map(xsq,vec1));
echo(map(xsq,vec2));
echo(map(recip,vec1));
echo(map(recip,vec2));
//Other crazy usage//
function div3(x)=x/3;
indirect = div3;
echo(map(indirect,vec2));
--
View this message in context: http://forum.openscad.org/Convert-from-object-to-polygon-polyhedron-tp18522p18659.html
Sent from the OpenSCAD mailing list archive at Nabble.com.
A
adrian
Mon, Oct 10, 2016 8:50 PM
I don't know why this thread is inside the thread "Convert from object to
polygon/polyhedron."
Yes, I feel that my thread got hijacked somehow.
Bananapeel wrote
IMO, there's just one "proper" syntax for this. And that is, that the name
without () acts as a variable, and () means call. And function becomes
just another type, like string and int. This means functions and variables
must occupy the same namespace. This syntax can also work for modules,
however, this means variables, functions and modules all share the same
namespace, which currently isn't the case.
Using () on a variable that isn't of type function or module would give a
runtime error.
Yes, this sounds somewhat reasonable, but these namespaces don't have to
collide. They can still be (and really should remain) separate, as changing
this could break a lot of scripts. One can gain access to the function
namespace using that @ sign (or some other sign. I assume that & wasn't
used for simplicity):
It would also be nice to have proper lambdas:
This syntax would introduce being able to create true lambdas on the fly,
instead of always having to name them and access the function namespace.
--
View this message in context: http://forum.openscad.org/Convert-from-object-to-polygon-polyhedron-tp18522p18662.html
Sent from the OpenSCAD mailing list archive at Nabble.com.
Bananapeel wrote
> I don't know why this thread is inside the thread "Convert from object to
> polygon/polyhedron."
Yes, I feel that my thread got hijacked somehow.
Bananapeel wrote
> IMO, there's just one "proper" syntax for this. And that is, that the name
> without () acts as a variable, and () means call. And function becomes
> just another type, like string and int. This means functions and variables
> must occupy the same namespace. This syntax can also work for modules,
> however, this means variables, functions and modules all share the same
> namespace, which currently isn't the case.
>
> Using () on a variable that isn't of type function or module would give a
> runtime error.
Yes, this sounds somewhat reasonable, but these namespaces don't have to
collide. They can still be (and really should remain) separate, as changing
this could break a lot of scripts. One can gain access to the function
namespace using that @ sign (or some other sign. I assume that & wasn't
used for simplicity):
It would also be nice to have proper lambdas:
This syntax would introduce being able to create true lambdas on the fly,
instead of always having to name them and access the function namespace.
--
View this message in context: http://forum.openscad.org/Convert-from-object-to-polygon-polyhedron-tp18522p18662.html
Sent from the OpenSCAD mailing list archive at Nabble.com.
O
otto
Mon, Oct 10, 2016 9:15 PM
Let me summarize current situation:
The following work in my current code:
function map(func,vec) = [for (i=vec) @func(i)];
function @xsq(x) = x*x;
function recip(x)=1/x;
box = "recip";
vec1=[1, 2, 3];
map(box,vec);
map(xsq,vec);
Objections have been:
- First version using "function @xsq(x)" seems kludgy.
- One suggestion was the following syntax:
function recip(x)=1/x;
vec1=[1, 2, 3];
function map(func,vec) = [for (i=vec) func(i)];
which seems intuitive.
3. (my own objections) None of these allow for lambda like syntax.
I have a particular problem with my own current code and all
suggestions. They fail to implement lambda. Suggestion 2 is
essentially the same way that python deals with indirection, Python
provides two methods of creating a function. One method uses a def
statement and the other uses the Lambda construct. They are equivalent
and dereferencing is automatic.
I believe I can get the lambda behavior relatively easily in the current
system. To add lambda syntax I will implement it as:
@(<argumentlist>:<functionDefintion>)
which I think is easier to read than (from python):
lambda <argumentlist>:<functionDefintion>
Either implementation is possible and if enough people request one over
the other, I am willing to implement either. The first is much simpler
to add for me with my current shallow knowledge of how the code works
and really requires very small changes.
The following would then work:
vec1=[1, 2, 3];
function map(func,vec) = [for (i=vec) @func(i)];
recip = @(x:1/x);
map(recip,vec); //this would work as before
map(@(x,x*x),vec); //this would be using @ as lambda.
I actually believe that the dereferencing of a variable name using "@"
makes the code clearer and easier to maintain and we lose nothing in
terms of capabilities.
If anyone wants to hack the code themselves to obtain any behavior, I
am happy to help point out where in the code changes can be made.
Currently there are only about 30 lines of code that have been added. In
addition, there are some problems currently in my code that could use
some work. I will post these in openscad-affine when I have time.
Collaboration on this is desirable. Incidentally I need these changes
for my work. The modules in paraSolids are essential for me and need
the function indirection capabilities to work.
For examples of pretty picture please see: ParaSolidExamples.pdf
which is among the files at https://github.com/ottojas/openscad-affine
The repo needs some re-arrangement but I think everything is there..
Thoughts?
I would really like it if someone would test the code I have written.
I am almost exclusively on debian based linux systems. Debian, Ubuntu
and mint. I would be happy to build a binary for one of these if that
is what someone willing to test would like. I am definitely going to
implement the second syntax when i have time (next week at earliest),
that is the "@(<argument list>:<function definition>)" syntax for an
anonymous function.
If requested, I will fork the complete source code setup so you can
compile on any system. Is that a good idea??
Regards
Otto
On Mon, 10 Oct 2016 12:15:31 -0700 (MST)
Bananapeel lunatica.xiaoyu@gmail.com wrote:
I don't know why this thread is inside the thread "Convert from
object to polygon/polyhedron." Anyways, regarding passing functions
as arguments:
IMO, there's just one "proper" syntax for this. And that is, that the
name without () acts as a variable, and () means call. And function
becomes just another type, like string and int. This means functions
and variables must occupy the same namespace. This syntax can also
work for modules, however, this means variables, functions and
modules all share the same namespace, which currently isn't the case.
Using () on a variable that isn't of type function or module would
give a runtime error.
Example:
//Preferred usage//
function xsq(x) = x*x;
function recip(x)=1/x;
vec1=[1, 2, 3];
vec2=[0.1, 0.7];
function map(func,vec) = [for (i=vec) func(i)];
echo(map(xsq,vec1));
echo(map(xsq,vec2));
echo(map(recip,vec1));
echo(map(recip,vec2));
//Other crazy usage//
function div3(x)=x/3;
indirect = div3;
echo(map(indirect,vec2));
--
View this message in context:
http://forum.openscad.org/Convert-from-object-to-polygon-polyhedron-tp18522p18659.html
Sent from the OpenSCAD mailing list archive at Nabble.com.
OpenSCAD mailing list
Discuss@lists.openscad.org
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
Let me summarize current situation:
The following work in my current code:
function map(func,vec) = [for (i=vec) @func(i)];
function @xsq(x) = x*x;
function recip(x)=1/x;
box = "recip";
vec1=[1, 2, 3];
map(box,vec);
map(xsq,vec);
Objections have been:
1. First version using "function @xsq(x)" seems kludgy.
2. One suggestion was the following syntax:
> function recip(x)=1/x;
> vec1=[1, 2, 3];
> function map(func,vec) = [for (i=vec) func(i)];
which seems intuitive.
3. (my own objections) None of these allow for lambda like syntax.
I have a particular problem with my own current code and all
suggestions. They fail to implement lambda. Suggestion 2 is
essentially the same way that python deals with indirection, Python
provides two methods of creating a function. One method uses a def
statement and the other uses the Lambda construct. They are equivalent
and dereferencing is automatic.
I believe I can get the lambda behavior relatively easily in the current
system. To add lambda syntax I will implement it as:
@(<argumentlist>:<functionDefintion>)
which I think is easier to read than (from python):
lambda <argumentlist>:<functionDefintion>
Either implementation is possible and if enough people request one over
the other, I am willing to implement either. The first is much simpler
to add for me with my current shallow knowledge of how the code works
and really requires very small changes.
The following would then work:
vec1=[1, 2, 3];
function map(func,vec) = [for (i=vec) @func(i)];
recip = @(x:1/x);
map(recip,vec); //this would work as before
map(@(x,x*x),vec); //this would be using @ as lambda.
I actually believe that the dereferencing of a variable name using "@"
makes the code clearer and easier to maintain and we lose nothing in
terms of capabilities.
If anyone wants to hack the code themselves to obtain any behavior, I
am happy to help point out where in the code changes can be made.
Currently there are only about 30 lines of code that have been added. In
addition, there are some problems currently in my code that could use
some work. I will post these in openscad-affine when I have time.
Collaboration on this is desirable. Incidentally I need these changes
for my work. The modules in paraSolids are essential for me and need
the function indirection capabilities to work.
For examples of pretty picture please see: ParaSolidExamples.pdf
which is among the files at https://github.com/ottojas/openscad-affine
The repo needs some re-arrangement but I think everything is there..
Thoughts?
I would really like it if someone would test the code I have written.
I am almost exclusively on debian based linux systems. Debian, Ubuntu
and mint. I would be happy to build a binary for one of these if that
is what someone willing to test would like. I am definitely going to
implement the second syntax when i have time (next week at earliest),
that is the "@(<argument list>:<function definition>)" syntax for an
anonymous function.
If requested, I will fork the complete source code setup so you can
compile on any system. Is that a good idea??
Regards
Otto
On Mon, 10 Oct 2016 12:15:31 -0700 (MST)
Bananapeel <lunatica.xiaoyu@gmail.com> wrote:
> I don't know why this thread is inside the thread "Convert from
> object to polygon/polyhedron." Anyways, regarding passing functions
> as arguments:
>
> IMO, there's just one "proper" syntax for this. And that is, that the
> name without () acts as a variable, and () means call. And function
> becomes just another type, like string and int. This means functions
> and variables must occupy the same namespace. This syntax can also
> work for modules, however, this means variables, functions and
> modules all share the same namespace, which currently isn't the case.
>
> Using () on a variable that isn't of type function or module would
> give a runtime error.
>
> Example:
>
> //Preferred usage//
> function xsq(x) = x*x;
> function recip(x)=1/x;
> vec1=[1, 2, 3];
> vec2=[0.1, 0.7];
>
> function map(func,vec) = [for (i=vec) func(i)];
> echo(map(xsq,vec1));
> echo(map(xsq,vec2));
> echo(map(recip,vec1));
> echo(map(recip,vec2));
>
> //Other crazy usage//
> function div3(x)=x/3;
> indirect = div3;
> echo(map(indirect,vec2));
>
>
>
>
> --
> View this message in context:
> http://forum.openscad.org/Convert-from-object-to-polygon-polyhedron-tp18522p18659.html
> Sent from the OpenSCAD mailing list archive at Nabble.com.
>
> _______________________________________________
> OpenSCAD mailing list
> Discuss@lists.openscad.org
> http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
TP
Torsten Paul
Mon, Oct 10, 2016 9:23 PM
On 10/10/2016 11:15 PM, otto wrote:
Either implementation is possible and if enough people
request one over the other, I am willing to implement
either. The first is much simpler to add for me with
my current shallow knowledge of how the code works and
really requires very small changes.
Did you see the work Doug did?
https://github.com/doug-moen/openscad2
It's proposing a way to a more powerful language while still
trying to be as compatible as possible.
It would be ideal if we could get the feature aligned with
those efforts. I think it would be a nice thing to get for
current OpenSCAD already.
ciao,
Torsten.
On 10/10/2016 11:15 PM, otto wrote:
> Either implementation is possible and if enough people
> request one over the other, I am willing to implement
> either. The first is much simpler to add for me with
> my current shallow knowledge of how the code works and
> really requires very small changes.
>
Did you see the work Doug did?
https://github.com/doug-moen/openscad2
It's proposing a way to a more powerful language while still
trying to be as compatible as possible.
It would be ideal if we could get the feature aligned with
those efforts. I think it would be a nice thing to get for
current OpenSCAD already.
ciao,
Torsten.
