Module Vector

 Jan Burse, created Oct 15. 2018 
/**


 * This module provides vectors of element columns. A vector is a


 * compound with varying number of elements which can be constants


 * or symbolic expressions. An element can be accessed by the


 * predicate []/3. The first element has the index one. The arity


 * of the vector can be queried by the predicate len/2. Vectors can


 * be created by the two special forms [_ | _] and {_ | _} introduced


 * in the module element.


 *


 * Examples:


 * ?- X is [A,B,C], Y is len(X).


 * X is [A,B,C],


 * Y = 3


 * ?- X is [A,B,C], Z is X[2].


 * X is [A,B,C],


 * Z is B


 *


 * The predicate sum/2, min/2 and max/2 can be used to compute the sum,


 * minimum or maximum of the elements of a vector. Further aggregate


 * functions are currently not provided. This module further provides


 * some rudimentary arithmetic such as sign change, addition and subtraction.


 * Other operations such as scalar product or transposing are currently


 * not provided. Error handling is rudimentary.


 *


 * The vector based consing returns a matrix. The consing does currently


 * not check that the second argument is a proper list and that all


 * elements of the list are vectors. The intention here is to use the


 * consing to only create homogenous matrixes of vectors. The reader


 * interested in the methods of the matrix should browse into the


 * module matrix.


 *


 * Warranty & Liability


 * To the extent permitted by applicable law and unless explicitly


 * otherwise agreed upon, XLOG Technologies GmbH makes no warranties


 * regarding the provided information. XLOG Technologies GmbH assumes


 * no liability that any problems might be solved with the information


 * provided by XLOG Technologies GmbH.


 *


 * Rights & License


 * All industrial property rights regarding the information - copyright


 * and patent rights in particular - are the sole property of XLOG


 * Technologies GmbH. If the company was not the originator of some


 * excerpts, XLOG Technologies GmbH has at least obtained the right to


 * reproduce, change and translate the information.


 *


 * Reproduction is restricted to the whole unaltered document. Reproduction


 * of the information is only allowed for non-commercial uses. Selling,


 * giving away or letting of the execution of the library is prohibited.


 * The library can be distributed as part of your applications and libraries


 * for execution provided this comment remains unchanged.


 *


 * Restrictions


 * Only to be distributed with programs that add significant and primary


 * functionality to the library. Not to be distributed with additional


 * software intended to replace any components of the library.


 *


 * Trademarks


 * Jekejeke is a registered trademark of XLOG Technologies GmbH.


 */




:- package(library(jekmin/frequent/gauss)).


:- use_package(library(jekmin/frequent/groebner)).


:- use_package(library(jekpro/frequent/misc)).




:- module(vector, []).




:- use_module(../groebner/generic).


:- use_module(library(advanced/arith)).


:- use_module(library(misc/residue)).


:- use_module(library(experiment/attr)).


:- use_module(library(experiment/trail)).




/***********************************************************/


/* Array Builder & Access                                  */


/***********************************************************/




/**


 * .(X, Y, Z):


 * The predicate succeeds in Z with the consing of X and Y.


 */


% .(+Vector, +List, -Matrice)


:- override '.'/3.


:- public '.'/3.


'.'(X, L, Z) :-


   Z =.. [matrice,X|L].




/**


 * X[Y, Z]:


 * The predicate succeeds in Z with the Y-the element


 * of the vector X.


 */


% +Vector [+Integer, -Element]


:- override sys_index/3.


:- public sys_index/3.


X [Y, Z] :-


   integer(Y),


   arg(Y, X, Z).




/**


 * len(X, Y):


 * The predicate succeeds in Y with the number of elements


 * in the vector X.


 */


% len(+Vector, -Integer)


:- public len/2.


len(X, Y) :-


   functor(X, _, Y).




/**


 * sum(X, Y):


 * The predicate succeeds in Y with the sum of elements


 * in the vector X.


 */


% sum(+Vector, -Internal)


:- public sum/2.


sum(X, Y) :-


   X =.. [_|L],


   (  L = [A|B]


   -> sys_sum_vector(B, A, Y)


   ;  Y = 0).




% sys_sum_vector(+List, +Internal, -Internal)


:- private sys_sum_vector/3.


sys_sum_vector([X|L], A, R) :-


   H is A+X,


   sys_sum_vector(L, H, R).


sys_sum_vector([], R, R).




/**


 * min(X, Y):


 * The predicate succeeds in Y with the minimum of the


 * elements in the vector X.


 */


% min(+Vector, -Internal)


:- public min/2.


min(X, Y) :-


   X =.. [_,A|L],


   sys_min_vector(L, A, Y).




% sys_min_vector(+List, +Internal, -Internal)


:- private sys_min_vector/3.


sys_min_vector([X|L], A, R) :-


   H is min(A,X),


   sys_min_vector(L, H, R).


sys_min_vector([], R, R).




/**


 * max(X, Y):


 * The predicate succeeds in Y with the maximum of the


 * elements in the vector X.


 */


% max(+Vector, -Internal)


:- public max/2.


max(X, Y) :-


   X =.. [_,A|L],


   sys_max_vector(L, A, Y).




% sys_max_vector(+List, +Internal, -Internal)


:- private sys_max_vector/3.


sys_max_vector([X|L], A, R) :-


   H is max(A,X),


   sys_max_vector(L, H, R).


sys_max_vector([], R, R).




/***********************************************************/


/* Basic Arithmetic                                        */


/***********************************************************/




/**


 * -(X, Y):


 * The predicate succeeds in Y with the sign changed vector X.


 */


% -(+Vector, -Vector)


:- override (-)/2.


:- public (-)/2.


X - Y :-


   L is len(X),


   Y is {-X[I]|between(1, L, I)}.




/**


 * +(X, Y, Z):


 * The predicate succeeds in Z with the sum of the vector X and


 * the vector Y.


 */


% +(+Vector, +Internal, -Vector)


:- override (+)/3.


:- public (+)/3.


+(X, Y, Z) :-


   functor(Y, vector, _),


   L is len(X),


   L =:= len(Y),


   Z is {X[I]+Y[I]|between(1, L, I)}.




/**


 * -(X, Y, Z):


 * The predicate succeeds in Z with the vector X subtracted


 * by the vector Y.


 */


% -(+Vector, +Internal, -Vector)


:- override (-)/3.


:- public (-)/3.


-(X, Y, Z) :-


   functor(Y, vector, _),


   L is len(X),


   L =:= len(Y),


   Z is {X[I]-Y[I]|between(1, L, I)}.




/***********************************************************/


/* CAS BindCount[] Hook                                        */


/***********************************************************/




/**


 * sys_printable_value(F, G):


 * The predicate succeeds in G with a custom form of F. The


 * predicate should be extended for custom forms.


 */


% sys_printable_value(+Term, -Term)


:- public residue:sys_printable_value/2.


:- multifile residue:sys_printable_value/2.


residue:sys_printable_value(X, _) :-


   var(X), !, fail.


residue:sys_printable_value(F, G) :-


   functor(F, vector, _), !,


   F =.. [_|H],


   sys_portray_vector(H, G).




% sys_portray_vector(+List, -List)


:- private sys_portray_vector/2.


sys_portray_vector([X|L], [Y|R]) :-


   printable(X, Y),


   sys_portray_vector(L, R).


sys_portray_vector([], []).




/*********************************************************************/


/* Generic Hook                                                      */


/*********************************************************************/




/**


 * X is E:


 * The predicate succeeds in evaluating E by using polymorphism.


 */


% is(-Internal, +Expr)


:- override generic:is/2.


:- multifile generic:is/2.


:- public generic:is/2.


:- meta_predicate generic:(?is#(1)).


generic:(X is E) :-


   var(E), !,


   sys_ensure_serno(E),


   sys_freeze_var(E, X).


generic:(X is E) :-


   functor(E, vector, _), !,


   X = E.




:- multifile generic:is_abnormal/1.


:- public generic:is_abnormal/1.


generic:is_abnormal(E) :-


   functor(E, vector, _).

Comments