Return to Question

In some case the Compile's syntax is quite straightforward. Es. for rank 1 e rank 2 tensors:

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 1}}
   , Total[x]
   ];

and

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 2}}
   , Inverse[x] (*Inverse isn't compileable: here is used merely as signpost*)

   ];

Or, even,

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 2}, {y, _Real, 2}}
   , Det[x] + Det[y] (*Det isn't compileable: here is used merely as signpost*)
   ];
cf[matrixA, matrixB]

But what if the arguments are intricated ? What is the syntax needed ?

A workaround to circumvent this question was proposed here : Not the most elegant but could you flatten and join and then "unflatten" and separate afterwards ?

Please, can you give examples for a function having as argument (all atomic expression are understood Real):

• a matrix of lists
• a matrix of matrices
• a matrix whose element are {x_Real , a matrix }
• a matrix whose element are {x_List , a matrix }
• etc.

Addendum

This question has been put on hold, but in IMHO the answer given below (see Jokeur), clarifying what is possible and what is not, fully dissolves the doubt.

In some case the Compile's syntax is quite straightforward. Es. for rank 1 e rank 2 tensors:

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 1}}
   , Total[x]
   ];

and

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 2}}
   , Inverse[x] (*Inverse isn't compileable: here is used merely as signpost*)

   ];

Or, even,

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 2}, {y, _Real, 2}}
   , Det[x] + Det[y] (*Det isn't compileable: here is used merely as signpost*)
   ];
cf[matrixA, matrixB]

But what if the arguments are intricated ? What is the syntax needed ?

A workaround to circumvent this question was proposed here : Not the most elegant but could you flatten and join and then "unflatten" and separate afterwards ?

Please, can you give examples for a function having as argument (all atomic expression are understood Real):

• a matrix of lists
• a matrix of matrices
• a matrix whose element are {x_Real , a matrix }
• a matrix whose element are {x_List , a matrix }
• etc.

Addendum

This question has been put on hold, but in IMHO the answer given below (see Jokeur), clarifying what is possible and what is not, fully dissolves the doubt.

In some case the Compile's syntax is quite straightforward. Es. for rank 1 e rank 2 tensors:

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 1}}
   , Total[x]
   ];

and

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 2}}
   , Inverse[x] (*Inverse isn't compileable: here is used merely as signpost*)

   ];

Or, even,

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 2}, {y, _Real, 2}}
   , Det[x] + Det[y] (*Det isn't compileable: here is used merely as signpost*)
   ];
cf[matrixA, matrixB]

But what if the arguments are intricated ? What is the syntax needed ?

A workaround to circumvent this question was proposed here : Not the most elegant but could you flatten and join and then "unflatten" and separate afterwards ?

Please, can you give examples for a function having as argument (all atomic expression are understood Real):

• a matrix of lists
• a matrix of matrices
• a matrix whose element are {x_Real , a matrix }
• a matrix whose element are {x_List , a matrix }
• etc.

Addendum

This question has been put on hold, but in IMHO the answer given below (see Jokeur), clarifying what is possible and what is not, essentially dissolves the doubt.

In some case the Compile's syntax is quite straightforward. Es. for rank 1 e rank 2 tensors:

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 1}}
   , Total[x]
   ];

and

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 2}}
   , Inverse[x] (*Inverse isn't compileable: here is used merely as signpost*)

   ];

Or, even,

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 2}, {y, _Real, 2}}
   , Det[x] + Det[y] (*Det isn't compileable: here is used merely as signpost*)
   ];
cf[matrixA, matrixB]

But what if the arguments are intricated ? What is the syntax needed ?

A workaround to circumvent this question was proposed here : Not the most elegant but could you flatten and join and then "unflatten" and separate afterwards ?

Please, can you give examples for a function having as argument (all atomic expression are understood Real):

• a matrix of lists
• a matrix of matrices
• a matrix whose element are {x_Real , a matrix }
• a matrix whose element are {x_List , a matrix }
• etc.

Addendum

This question has been put on hold, but in IMHO the answer given below (see Jokeur), clarifying what is possible and what is not, fully dissolves the doubt.

In some case the Compile's syntax is quite straightforward. Es. for rank 1 e rank 2 tensors:

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 1}}
   , Total[x]
   ];

and

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 2}}
   , Inverse[x] (*Inverse isn't compileable: here is used merely as signpost*)

   ];

Or, even,

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 2}, {y, _Real, 2}}
   , Det[x] + Det[y] (*Det isn't compileable: here is used merely as signpost*)
   ];
cf[matrixA, matrixB]

But what if the arguments are intricated ? What is the syntax needed ?

A workaround to circumvent this question was proposed here : Not the most elegant but could you flatten and join and then "unflatten" and separate afterwards ?

Please, can you give examples for a function having as argument (all atomic expression are understood Real):

• a matrix of lists
• a matrix of matrices
• a matrix whose element are {x_Real , a matrix }
• a matrix whose element are {x_List , a matrix }
• etc.

Addendum

In some case the Compile's syntax is quite straightforward. Es. for rank 1 e rank 2 tensors:

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 1}}
   , Total[x]
   ];

and

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 2}}
   , Inverse[x] (*Inverse isn't compileable: here is used merely as signpost*)

   ];

Or, even,

Quiet[Remove[cf]];
cf = Compile[
   {{x, _Real, 2}, {y, _Real, 2}}
   , Det[x] + Det[y] (*Det isn't compileable: here is used merely as signpost*)
   ];
cf[matrixA, matrixB]

But what if the arguments are intricated ? What is the syntax needed ?

A workaround to circumvent this question was proposed here : Not the most elegant but could you flatten and join and then "unflatten" and separate afterwards ?

Please, can you give examples for a function having as argument (all atomic expression are understood Real):

• a matrix of lists
• a matrix of matrices
• a matrix whose element are {x_Real , a matrix }
• a matrix whose element are {x_List , a matrix }
• etc.

Addendum

This question has been put on hold, but in IMHO the answer given below (see Jokeur), clarifying what is possible and what is not, essentially dissolves the doubt.