This repository has been archived on 2023-08-20. You can view files and clone it, but cannot push or open issues or pull requests.
yap-6.3/library/matrix/matrix.c
Vítor Santos de Costa b3cb7b1071 add log/2 and exp/2
2008-10-22 00:40:15 +01:00

2922 lines
66 KiB
C

/*************************************************************************
* *
* YAP Prolog *
* *
* Yap Prolog was developed at NCCUP - Universidade do Porto *
* *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
* *
**************************************************************************
* *
* File: matrix.c *
* Last rev: *
* mods: *
* comments: numerical arrays *
* *
*************************************************************************/
#include "config.h"
#include "YapInterface.h"
#include <math.h>
#if defined(__MINGW32__) || _MSC_VER
#include <windows.h>
#endif
#if HAVE_STRING_H
#include <string.h>
#endif
/*
A matrix is something of the form
TYPE = {int,double}
#DIMS = an int
DIM1
...
DIMn
DATA in C format.
floating point matrixes may need to be aligned, so we always have an
extra element at the end.
*/
/* maximal number of dimensions, 1024 should be enough */
#define MAX_DIMS 1024
typedef enum {
INT_MATRIX,
FLOAT_MATRIX
} mat_data_type;
typedef enum {
MAT_TYPE=0,
MAT_NDIMS=1,
MAT_SIZE=2,
MAT_ALIGN=3,
MAT_DIMS=4,
} mat_type;
typedef enum {
MAT_PLUS=0,
MAT_SUB=1,
MAT_TIMES=2,
MAT_DIV=3,
MAT_IDIV=4,
MAT_ZDIV=5,
MAT_LOG=6,
MAT_EXP=7
} op_type;
static long int *
matrix_long_data(int *mat, int ndims)
{
return (long int *)(mat+(MAT_DIMS+ndims));
}
static double *
matrix_double_data(int *mat, int ndims)
{
return (double *)(mat+(MAT_DIMS+ndims));
}
static unsigned int
matrix_get_offset(int *mat, int* indx)
{
unsigned int i, pos = mat[MAT_SIZE], off = 0;
/* find where we are */
for (i = 0; i < mat[MAT_NDIMS]; i++) {
pos /= mat[MAT_DIMS+i];
if (indx[i] >= mat[MAT_DIMS+i]) {
return off;
}
off += pos*indx[i];
}
return off;
}
static void
matrix_get_index(int *mat, unsigned int offset, int* indx)
{
unsigned int i, pos = mat[MAT_SIZE];
/* find where we are */
for (i = 0; i < mat[MAT_NDIMS]; i++) {
pos /= mat[MAT_DIMS+i];
indx[i] = offset / pos;
offset = offset % pos;
}
}
static void
matrix_next_index(int *dims, int ndims, int* indx)
{
unsigned int i;
/* find where we are */
for (i = ndims; i >0; ) {
i--;
indx[i]++;
if (indx[i]!=dims[i]) return;
indx[i] = 0;
}
}
static YAP_Term
new_int_matrix(int ndims, int dims[], long int data[])
{
unsigned int sz;
unsigned int i, nelems=1;
YAP_Term blob;
int *mat;
long int *bdata;
int idims[MAX_DIMS];
/* in case we don't have enough room and need to shift the stack, we can't
really afford to keep a pointer to the global */
for (i=0;i< ndims;i++) {
idims[i] = dims[i];
nelems *= dims[i];
}
sz = ((MAT_DIMS+1)*sizeof(int)+ndims*sizeof(int)+nelems*sizeof(long int))/sizeof(YAP_CELL);
blob = YAP_MkBlobTerm(sz);
if (blob == YAP_TermNil())
return FALSE;
mat = (int *)YAP_BlobOfTerm(blob);
mat[MAT_TYPE] = INT_MATRIX;
mat[MAT_NDIMS] = ndims;
mat[MAT_SIZE] = nelems;
for (i=0;i< ndims;i++) {
mat[MAT_DIMS+i] = idims[i];
}
bdata = matrix_long_data(mat,ndims);
if (data)
memcpy((void *)bdata,(void *)data,sizeof(double)*nelems);
return blob;
}
static YAP_Term
new_float_matrix(int ndims, int dims[], double data[])
{
unsigned int sz;
unsigned int i, nelems=1;
YAP_Term blob;
int *mat;
double *bdata;
int idims[MAX_DIMS];
/* in case we don't have enough room and need to shift the stack, we can't
really afford to keep a pointer to the global */
for (i=0;i< ndims;i++) {
idims[i] = dims[i];
nelems *= dims[i];
}
sz = ((MAT_DIMS+1)*sizeof(int)+ndims*sizeof(int)+(nelems+1)*sizeof(double)+(sizeof(YAP_CELL)-1))/sizeof(YAP_CELL);
blob = YAP_MkBlobTerm(sz);
if (blob == YAP_TermNil())
return FALSE;
mat = YAP_BlobOfTerm(blob);
mat[MAT_TYPE] = FLOAT_MATRIX;
mat[MAT_NDIMS] = ndims;
mat[MAT_SIZE] = nelems;
for (i=0;i< ndims;i++) {
mat[MAT_DIMS+i] = idims[i];
}
bdata = matrix_double_data(mat,ndims);
if (data)
memcpy((void *)bdata,(void *)data,sizeof(double)*nelems);
return blob;
}
static int
scan_dims(int ndims, YAP_Term tl, int dims[MAX_DIMS])
{
int i;
for (i = 0; i < ndims; i++) {
YAP_Term th;
int d;
if (!YAP_IsPairTerm(tl)) {
return FALSE;
}
th = YAP_HeadOfTerm(tl);
if (!YAP_IsIntTerm(th)) {
/* ERROR */
return FALSE;
}
d = YAP_IntOfTerm(th);
if (d < 0) {
/* ERROR */
return FALSE;
}
dims[i] = d;
tl = YAP_TailOfTerm(tl);
}
if (tl != YAP_TermNil()) {
/* ERROR */
return FALSE;
}
return TRUE;
}
static int
cp_int_matrix(YAP_Term tl,YAP_Term matrix)
{
int *mat = (int *)YAP_BlobOfTerm(matrix);
int i, nelems = mat[MAT_SIZE];
long int *j = matrix_long_data(mat, mat[MAT_NDIMS]);
for (i = 0; i < nelems; i++) {
YAP_Term th;
int d;
if (!YAP_IsPairTerm(tl)) {
return FALSE;
}
th = YAP_HeadOfTerm(tl);
if (!YAP_IsIntTerm(th)) {
/* ERROR */
return FALSE;
}
d = YAP_IntOfTerm(th);
j[i] = d;
tl = YAP_TailOfTerm(tl);
}
if (tl != YAP_TermNil()) {
/* ERROR */
return FALSE;
}
return TRUE;
}
static int
cp_float_matrix(YAP_Term tl,YAP_Term matrix)
{
int *mat = (int *)YAP_BlobOfTerm(matrix);
int i, nelems = mat[MAT_SIZE];
double *j = matrix_double_data(mat, mat[MAT_NDIMS]);
for (i = 0; i < nelems; i++) {
YAP_Term th;
double d;
if (!YAP_IsPairTerm(tl)) {
return FALSE;
}
th = YAP_HeadOfTerm(tl);
if (YAP_IsIntTerm(th)) {
d = YAP_IntOfTerm(th);
} else if (!YAP_IsFloatTerm(th)) {
/* ERROR */
return FALSE;
} else {
d = YAP_FloatOfTerm(th);
}
j[i] = d;
tl = YAP_TailOfTerm(tl);
}
if (tl != YAP_TermNil()) {
/* ERROR */
return FALSE;
}
return TRUE;
}
static int
set_int_matrix(YAP_Term matrix,long int set)
{
int *mat = (int *)YAP_BlobOfTerm(matrix);
int i, nelems = mat[MAT_SIZE];
long int *j = matrix_long_data(mat, mat[MAT_NDIMS]);
for (i = 0; i < nelems; i++) {
j[i] = set;
}
return TRUE;
}
static int
set_float_matrix(YAP_Term matrix,double set)
{
int *mat = (int *)YAP_BlobOfTerm(matrix);
int i, nelems = mat[MAT_SIZE];
double *j = matrix_double_data(mat, mat[MAT_NDIMS]);
for (i = 0; i < nelems; i++) {
j[i] = set;
}
return TRUE;
}
static int
new_ints_matrix(void)
{
int ndims = YAP_IntOfTerm(YAP_ARG1);
YAP_Term tl = YAP_ARG2, out;
int dims[MAX_DIMS];
if (!scan_dims(ndims, tl, dims))
return FALSE;
out = new_int_matrix(ndims, dims, NULL);
if (!cp_int_matrix(YAP_ARG3,out))
return FALSE;
return YAP_Unify(YAP_ARG4, out);
}
static int
new_ints_matrix_set(void)
{
int ndims = YAP_IntOfTerm(YAP_ARG1);
YAP_Term tl = YAP_ARG2, out, tset = YAP_ARG3;
int dims[MAX_DIMS];
long int set;
if (!YAP_IsIntTerm(tset)) {
return FALSE;
}
set = YAP_IntOfTerm(tset);
if (!scan_dims(ndims, tl, dims))
return FALSE;
out = new_int_matrix(ndims, dims, NULL);
if (!set_int_matrix(out,set))
return FALSE;
return YAP_Unify(YAP_ARG4, out);
}
static int
new_floats_matrix(void)
{
int ndims = YAP_IntOfTerm(YAP_ARG1);
YAP_Term tl = YAP_ARG2, out;
int dims[MAX_DIMS];
if (!scan_dims(ndims, tl, dims))
return FALSE;
out = new_float_matrix(ndims, dims, NULL);
if (!cp_float_matrix(YAP_ARG3,out))
return FALSE;
return YAP_Unify(YAP_ARG4, out);
}
static int
new_floats_matrix_set(void)
{
int ndims = YAP_IntOfTerm(YAP_ARG1);
YAP_Term tl = YAP_ARG2, out, tset = YAP_ARG3;
int dims[MAX_DIMS];
double set;
if (!YAP_IsFloatTerm(tset)) {
return FALSE;
}
set = YAP_FloatOfTerm(tset);
if (!scan_dims(ndims, tl, dims))
return FALSE;
out = new_float_matrix(ndims, dims, NULL);
if (!set_float_matrix(out,set))
return FALSE;
return YAP_Unify(YAP_ARG4, out);
}
static YAP_Term
float_matrix_to_list(int *mat) {
double *data = matrix_double_data(mat, mat[MAT_NDIMS]);
int i = 0;
YAP_Term tf = YAP_TermNil();
for (i = mat[MAT_SIZE]-1; i>= 0; i--) {
tf = YAP_MkPairTerm(YAP_MkFloatTerm(data[i]),tf);
if (tf == YAP_TermNil()) {
/* error */
return YAP_TermNil();
}
}
return tf;
}
static YAP_Term
mk_int_list(int nelems, int *data)
{
YAP_Term tn = YAP_TermNil();
YAP_Term tf = tn;
int i = 0;
for (i = nelems-1; i>= 0; i--) {
tf = YAP_MkPairTerm(YAP_MkIntTerm(data[i]),tf);
if (tf == tn) {
/* error */
return tn;
}
}
return tf;
}
static YAP_Term
mk_long_list(int nelems, long int *data)
{
YAP_Term tn = YAP_TermNil();
YAP_Term tf = tn;
int i = 0;
for (i = nelems-1; i>= 0; i--) {
tf = YAP_MkPairTerm(YAP_MkIntTerm(data[i]),tf);
if (tf == tn) {
/* error */
return tn;
}
}
return tf;
}
static YAP_Term
long_matrix_to_list(int *mat) {
long int *data = matrix_long_data(mat, mat[MAT_NDIMS]);
return mk_long_list(mat[MAT_SIZE], data);
}
static YAP_Term
matrix_access(int *mat, int *indx)
{
unsigned int off = matrix_get_offset(mat, indx);
if (mat[MAT_TYPE]==FLOAT_MATRIX)
return YAP_MkFloatTerm((matrix_double_data(mat,mat[MAT_NDIMS]))[off]);
else
return YAP_MkIntTerm((matrix_long_data(mat,mat[MAT_NDIMS]))[off]);
}
static void
matrix_float_set(int *mat, int *indx, double nval)
{
unsigned int off = 0;
off = matrix_get_offset(mat, indx);
(matrix_double_data(mat,mat[MAT_NDIMS]))[off] = nval;
}
static void
matrix_long_set(int *mat, int *indx, long int nval)
{
unsigned int off = matrix_get_offset(mat, indx);
(matrix_long_data(mat,mat[MAT_NDIMS]))[off] = nval;
}
static void
matrix_float_set_all(int *mat, double nval)
{
int i;
double *data = matrix_double_data(mat,mat[MAT_NDIMS]);
for (i = 0; i< mat[MAT_SIZE]; i++)
data[i] = nval;
}
static void
matrix_long_set_all(int *mat, long int nval)
{
int i;
long int *data = matrix_long_data(mat,mat[MAT_NDIMS]);
if (nval == 0) {
memset((void *)data,0,sizeof(long int)*mat[MAT_SIZE]);
} else {
for (i = 0; i< mat[MAT_SIZE]; i++)
data[i] = nval;
}
}
static void
matrix_float_add(int *mat, int *indx, double nval)
{
unsigned int off;
double *dat = matrix_double_data(mat,mat[MAT_NDIMS]);
off = matrix_get_offset(mat, indx);
dat[off] += nval;
}
static void
matrix_long_add(int *mat, int *indx, long int nval)
{
long int *dat = matrix_long_data(mat,mat[MAT_NDIMS]);
unsigned int off = matrix_get_offset(mat, indx);
dat[off] += nval;
}
static void
matrix_inc(int *mat, int *indx)
{
unsigned int off = matrix_get_offset(mat, indx);
if (mat[MAT_TYPE]==FLOAT_MATRIX)
(matrix_double_data(mat,mat[MAT_NDIMS])[off])++;
else
((matrix_long_data(mat,mat[MAT_NDIMS]))[off])++;
}
static void
matrix_dec(int *mat, int *indx)
{
unsigned int off = matrix_get_offset(mat, indx);
if (mat[MAT_TYPE]==FLOAT_MATRIX)
(matrix_double_data(mat,mat[MAT_NDIMS])[off])--;
else
((matrix_long_data(mat,mat[MAT_NDIMS]))[off])--;
}
static YAP_Term
matrix_inc2(int *mat, int *indx)
{
unsigned int off = matrix_get_offset(mat, indx);
if (mat[MAT_TYPE]==FLOAT_MATRIX) {
double *data = matrix_double_data(mat,mat[MAT_NDIMS]);
double d = data[off];
d++;
data[off] = d;
return YAP_MkFloatTerm(d);
} else {
long int *data = matrix_long_data(mat,mat[MAT_NDIMS]);
long int d = data[off];
d++;
data[off] = d;
return YAP_MkIntTerm(d);
}
}
static YAP_Term
matrix_dec2(int *mat, int *indx)
{
unsigned int off = matrix_get_offset(mat, indx);
if (mat[MAT_TYPE]==FLOAT_MATRIX) {
double *data = matrix_double_data(mat,mat[MAT_NDIMS]);
double d = data[off];
d--;
data[off] = d;
return YAP_MkFloatTerm(d);
} else {
long int *data = matrix_long_data(mat,mat[MAT_NDIMS]);
long int d = data[off];
d--;
data[off] = d;
return YAP_MkIntTerm(d);
}
}
static int
matrix_set(void)
{
int dims[MAX_DIMS], *mat;
YAP_Term tf;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (!scan_dims(mat[MAT_NDIMS], YAP_ARG2, dims)) {
/* Error */
return FALSE;
}
tf = YAP_ARG3;
if (mat[MAT_TYPE] == INT_MATRIX) {
if (YAP_IsIntTerm(tf)) {
matrix_long_set(mat, dims, YAP_IntOfTerm(tf));
} else if (YAP_IsFloatTerm(tf)) {
matrix_long_set(mat, dims, YAP_FloatOfTerm(tf));
} else {
/* Error */
return FALSE;
}
} else {
if (YAP_IsIntTerm(tf)) {
matrix_float_set(mat, dims, YAP_IntOfTerm(tf));
} else if (YAP_IsFloatTerm(tf)) {
matrix_float_set(mat, dims, YAP_FloatOfTerm(tf));
} else {
/* Error */
return FALSE;
}
}
return TRUE;
}
static int
matrix_set_all(void)
{
int *mat;
YAP_Term tf;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
tf = YAP_ARG2;
if (mat[MAT_TYPE] == INT_MATRIX) {
if (YAP_IsIntTerm(tf)) {
matrix_long_set_all(mat, YAP_IntOfTerm(tf));
} else if (YAP_IsFloatTerm(tf)) {
matrix_long_set_all(mat, YAP_FloatOfTerm(tf));
} else {
/* Error */
return FALSE;
}
} else {
if (YAP_IsIntTerm(tf)) {
matrix_float_set_all(mat, YAP_IntOfTerm(tf));
} else if (YAP_IsFloatTerm(tf)) {
matrix_float_set_all(mat, YAP_FloatOfTerm(tf));
} else {
/* Error */
return FALSE;
}
}
return TRUE;
}
static int
matrix_add(void)
{
int dims[MAX_DIMS], *mat;
YAP_Term tf;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (!scan_dims(mat[MAT_NDIMS], YAP_ARG2, dims)) {
/* Error */
return FALSE;
}
tf = YAP_ARG3;
if (mat[MAT_TYPE] == INT_MATRIX) {
if (YAP_IsIntTerm(tf)) {
matrix_long_add(mat, dims, YAP_IntOfTerm(tf));
} else if (YAP_IsFloatTerm(tf)) {
matrix_long_add(mat, dims, YAP_FloatOfTerm(tf));
} else {
/* Error */
return FALSE;
}
} else {
if (YAP_IsIntTerm(tf)) {
matrix_float_add(mat, dims, YAP_IntOfTerm(tf));
} else if (YAP_IsFloatTerm(tf)) {
matrix_float_add(mat, dims, YAP_FloatOfTerm(tf));
} else {
/* Error */
return FALSE;
}
}
return TRUE;
}
static int
do_matrix_access(void)
{
int dims[MAX_DIMS], *mat;
YAP_Term tf;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (!scan_dims(mat[MAT_NDIMS], YAP_ARG2, dims)) {
/* Error */
return FALSE;
}
tf = matrix_access(mat, dims);
return YAP_Unify(tf, YAP_ARG3);
}
static int
do_matrix_inc(void)
{
int dims[MAX_DIMS], *mat;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (!scan_dims(mat[MAT_NDIMS], YAP_ARG2, dims)) {
/* Error */
return FALSE;
}
matrix_inc(mat, dims);
return TRUE;
}
static int
do_matrix_dec(void)
{
int dims[MAX_DIMS], *mat;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (!scan_dims(mat[MAT_NDIMS], YAP_ARG2, dims)) {
/* Error */
return FALSE;
}
matrix_dec(mat, dims);
return TRUE;
}
static int
do_matrix_inc2(void)
{
int dims[MAX_DIMS], *mat;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (!scan_dims(mat[MAT_NDIMS], YAP_ARG2, dims)) {
/* Error */
return FALSE;
}
return
YAP_Unify(matrix_inc2(mat, dims), YAP_ARG3);
}
static int
do_matrix_dec2(void)
{
int dims[MAX_DIMS], *mat;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (!scan_dims(mat[MAT_NDIMS], YAP_ARG2, dims)) {
/* Error */
return FALSE;
}
return
YAP_Unify(matrix_dec2(mat, dims), YAP_ARG3);
}
static int
matrix_to_list(void)
{
int *mat;
YAP_Term tf;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (mat[MAT_TYPE] == INT_MATRIX)
tf = long_matrix_to_list(mat);
else
tf = float_matrix_to_list(mat);
return YAP_Unify(YAP_ARG2, tf);
}
static int
matrix_dims(void)
{
int *mat;
YAP_Term tf;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
tf = mk_int_list(mat[MAT_NDIMS],mat+MAT_DIMS);
return YAP_Unify(YAP_ARG2, tf);
}
static int
matrix_size(void)
{
int *mat;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(mat[MAT_SIZE]));
}
static int
matrix_ndims(void)
{
int *mat;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(mat[MAT_NDIMS]));
}
static int
matrix_type(void)
{
int *mat;
YAP_Term tf;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (mat[MAT_TYPE] == INT_MATRIX) {
tf = YAP_MkIntTerm(0);
} else {
tf = YAP_MkIntTerm(1);
}
return YAP_Unify(YAP_ARG2, tf);
}
static int
matrix_arg_to_offset(void)
{
int indx[MAX_DIMS], *mat;
unsigned int off;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (!scan_dims(mat[MAT_NDIMS], YAP_ARG2, indx)) {
/* Error */
return FALSE;
}
off = matrix_get_offset(mat, indx);
return YAP_Unify(YAP_ARG3, YAP_MkIntTerm(off));
}
static int
matrix_offset_to_arg(void)
{
int indx[MAX_DIMS], *mat;
unsigned int off;
YAP_Term ti, tf;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (!YAP_IsIntTerm(ti = YAP_ARG2)) {
/* Error */
return FALSE;
}
off = YAP_IntOfTerm(ti);
matrix_get_index(mat, off, indx);
tf = mk_int_list(mat[MAT_NDIMS], indx);
return YAP_Unify(YAP_ARG3, tf);
}
static unsigned int
scan_max_long(int sz, long int *data)
{
int i, off=0;
long int max= data[0];
for (i=1; i<sz; i++) {
if (data[i]>max) {
off=i;
max = data[i];
}
}
return off;
}
static unsigned int
scan_max_float(int sz, double *data)
{
int i, off=0;
double max= data[0];
for (i=1; i<sz; i++) {
if (data[i]>max) {
max = data[i];
off=i;
}
}
return off;
}
static unsigned int
scan_min_long(int sz, long int *data)
{
int i, off=0;
long int max= data[0];
for (i=1; i<sz; i++) {
if (data[i]<max) {
max = data[i];
off=i;
}
}
return off;
}
static unsigned int
scan_min_float(int sz, double *data)
{
int i, off=0;
double max= data[0];
for (i=1; i<sz; i++) {
if (data[i]<max) {
max = data[i];
off=i;
}
}
return off;
}
static int
matrix_max(void)
{
int *mat;
unsigned int off;
YAP_Term tf;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data = matrix_long_data(mat, mat[MAT_NDIMS]);
off = scan_max_long(mat[MAT_SIZE], data);
tf = YAP_MkIntTerm(data[off]);
} else {
double *data = matrix_double_data(mat, mat[MAT_NDIMS]);
off = scan_max_float(mat[MAT_SIZE], data);
tf = YAP_MkFloatTerm(data[off]);
}
return YAP_Unify(YAP_ARG2, tf);
}
static int
matrix_maxarg(void)
{
int indx[MAX_DIMS], *mat;
unsigned int off;
YAP_Term tf;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data = matrix_long_data(mat, mat[MAT_NDIMS]);
off = scan_max_long(mat[MAT_SIZE], data);
} else {
double *data = matrix_double_data(mat, mat[MAT_NDIMS]);
off = scan_max_float(mat[MAT_SIZE], data);
}
matrix_get_index(mat, off, indx);
tf = mk_int_list(mat[MAT_NDIMS], indx);
return YAP_Unify(YAP_ARG2, tf);
}
static int
matrix_min(void)
{
int *mat;
unsigned int off;
YAP_Term tf;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data = matrix_long_data(mat, mat[MAT_NDIMS]);
off = scan_min_long(mat[MAT_SIZE], data);
tf = YAP_MkIntTerm(data[off]);
} else {
double *data = matrix_double_data(mat, mat[MAT_NDIMS]);
off = scan_min_float(mat[MAT_SIZE], data);
tf = YAP_MkFloatTerm(data[off]);
}
return YAP_Unify(YAP_ARG2, tf);
}
static int
matrix_log_all(void)
{
int *mat;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (mat[MAT_TYPE] == INT_MATRIX) {
return FALSE;
} else {
double *data = matrix_double_data(mat, mat[MAT_NDIMS]);
int i;
for (i=0; i< mat[MAT_SIZE]; i++) {
data[i] = log(data[i]);
}
}
return TRUE;
}
static int
matrix_log_all2(void)
{
int *mat;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (mat[MAT_TYPE] == INT_MATRIX) {
return FALSE;
} else {
YAP_Term out;
double *data = matrix_double_data(mat, mat[MAT_NDIMS]), *ndata;
int i;
int *nmat;
if (!YAP_IsVarTerm(YAP_ARG2)) {
out = YAP_ARG2;
} else {
out = new_float_matrix(mat[MAT_NDIMS], mat+MAT_DIMS, NULL);
if (out == YAP_TermNil())
return FALSE;
}
nmat = (int *)YAP_BlobOfTerm(out);
ndata = matrix_double_data(nmat, mat[MAT_NDIMS]);
for (i=0; i< mat[MAT_SIZE]; i++) {
ndata[i] = log(data[i]);
}
if (YAP_IsVarTerm(YAP_ARG2)) {
return YAP_Unify(YAP_ARG2, out);
}
}
return TRUE;
}
static int
matrix_exp_all(void)
{
int *mat;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (mat[MAT_TYPE] == INT_MATRIX) {
return FALSE;
} else {
double *data = matrix_double_data(mat, mat[MAT_NDIMS]);
int i;
for (i=0; i< mat[MAT_SIZE]; i++) {
data[i] = exp(data[i]);
}
}
return TRUE;
}
static int
matrix_exp_all2(void)
{
int *mat;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (mat[MAT_TYPE] == INT_MATRIX) {
return FALSE;
} else {
YAP_Term out;
double *data = matrix_double_data(mat, mat[MAT_NDIMS]), *ndata;
int i;
int *nmat;
if (!YAP_IsVarTerm(YAP_ARG2)) {
out = YAP_ARG2;
} else {
out = new_float_matrix(mat[MAT_NDIMS], mat+MAT_DIMS, NULL);
if (out == YAP_TermNil())
return FALSE;
}
nmat = (int *)YAP_BlobOfTerm(out);
ndata = matrix_double_data(nmat, mat[MAT_NDIMS]);
for (i=0; i< mat[MAT_SIZE]; i++) {
ndata[i] = exp(data[i]);
}
if (YAP_IsVarTerm(YAP_ARG2)) {
return YAP_Unify(YAP_ARG2, out);
}
}
return TRUE;
}
static int
matrix_minarg(void)
{
int indx[MAX_DIMS], *mat;
unsigned int off;
YAP_Term tf;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data = matrix_long_data(mat, mat[MAT_NDIMS]);
off = scan_min_long(mat[MAT_SIZE], data);
} else {
double *data = matrix_double_data(mat, mat[MAT_NDIMS]);
off = scan_min_float(mat[MAT_SIZE], data);
}
matrix_get_index(mat, off, indx);
tf = mk_int_list(mat[MAT_NDIMS], indx);
return YAP_Unify(YAP_ARG2, tf);
}
static int
matrix_sum(void)
{
int *mat;
YAP_Term tf;
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data = matrix_long_data(mat, mat[MAT_NDIMS]);
int i;
long int sum = 0;
for (i = 0; i < mat[MAT_SIZE]; i++) {
sum += data[i];
}
tf = YAP_MkIntTerm(sum);
} else {
double *data = matrix_double_data(mat, mat[MAT_NDIMS]);
int i;
double sum = 0.0;
for (i = 0; i < mat[MAT_SIZE]; i++) {
sum += data[i];
}
tf = YAP_MkFloatTerm(sum);
}
return YAP_Unify(YAP_ARG2, tf);
}
static void
add_int_lines(int total,int nlines,long int *mat0,long int *matf)
{
int ncols = total/nlines, i;
for (i=0;i<ncols;i++) {
long int sum = 0;
int j;
for (j=i;j<total;j+=ncols) {
sum += mat0[j];
}
matf[i] = sum;
}
}
static void
add_double_lines(int total,int nlines,double *mat0,double *matf)
{
int ncols = total/nlines, i;
for (i=0;i<ncols;i++) {
double sum = 0;
int j;
for (j=i;j<total;j+=ncols) {
sum += mat0[j];
}
matf[i] = sum;
}
}
static int
matrix_agg_lines(void)
{
int *mat;
YAP_Term tf;
YAP_Term top = YAP_ARG2;
op_type op;
if (!YAP_IsIntTerm(top)) {
return FALSE;
}
op = YAP_IntOfTerm(top);
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
/* create a new array without first dimension */
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data, *ndata;
int dims = mat[MAT_NDIMS];
int *nmat;
tf = new_int_matrix(dims-1,mat+(MAT_DIMS+1),NULL);
if (tf == YAP_TermNil())
return FALSE;
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_long_data(mat, dims);
ndata = matrix_long_data(nmat, dims-1);
if (op == MAT_PLUS) {
add_int_lines(mat[MAT_SIZE],mat[MAT_DIMS],data,ndata);
} else
return FALSE;
} else {
double *data, *ndata;
int dims = mat[MAT_NDIMS];
int *nmat;
tf = new_float_matrix(dims-1,mat+(MAT_DIMS+1),NULL);
nmat = (int *)YAP_BlobOfTerm(tf);
if (tf == YAP_TermNil())
return FALSE;
data = matrix_double_data(mat, dims);
ndata = matrix_double_data(nmat, dims-1);
if (op == MAT_PLUS) {
add_double_lines(mat[MAT_SIZE],mat[MAT_DIMS],data,ndata);
} else
return FALSE;
}
return YAP_Unify(YAP_ARG3,tf);
}
static void
add_int_cols(int total,int nlines,long int *mat0,long int *matf)
{
int ncols = total/nlines, i, j = 0;
for (i=0;i<nlines;i++) {
long int sum = 0;
int max = (i+1)*ncols;
for (;j<max;j++) {
sum += mat0[j];
}
matf[i] = sum;
}
}
static void
add_double_cols(int total,int nlines,double *mat0,double *matf)
{
int ncols = total/nlines, i, j = 0;
for (i=0;i<nlines;i++) {
double sum = 0;
int max = (i+1)*ncols;
for (;j<max;j++) {
sum += mat0[j];
}
matf[i] = sum;
}
}
static int
matrix_agg_cols(void)
{
int *mat;
YAP_Term tf;
YAP_Term top = YAP_ARG2;
op_type op;
if (!YAP_IsIntTerm(top)) {
return FALSE;
}
op = YAP_IntOfTerm(top);
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
/* create a new array without first dimension */
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data, *ndata;
int dims = mat[MAT_NDIMS];
int *nmat;
tf = new_int_matrix(1,mat+MAT_DIMS,NULL);
if (tf == YAP_TermNil())
return FALSE;
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_long_data(mat, dims);
ndata = matrix_long_data(nmat, 1);
if (op == MAT_PLUS) {
add_int_cols(mat[MAT_SIZE],mat[MAT_DIMS],data,ndata);
} else
return FALSE;
} else {
double *data, *ndata;
int dims = mat[MAT_NDIMS];
int *nmat;
tf = new_float_matrix(1,mat+MAT_DIMS,NULL);
if (tf == YAP_TermNil())
return FALSE;
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_double_data(mat, dims);
ndata = matrix_double_data(nmat, 1);
if (op == MAT_PLUS) {
add_double_cols(mat[MAT_SIZE],mat[MAT_DIMS],data,ndata);
} else
return FALSE;
}
return YAP_Unify(YAP_ARG3,tf);
}
static void
div_int_by_lines(int total,int nlines,long int *mat1,long int *mat2,double *ndata)
{
int ncols = total/nlines, i;
for (i=0;i<total;i++) {
ndata[i] = ((double)mat1[i])/mat2[i%ncols];
}
}
static void
div_int_by_dlines(int total,int nlines,long int *mat1,double *mat2,double *ndata)
{
int ncols = total/nlines, i;
for (i=0;i<total;i++) {
ndata[i] = mat1[i]/mat2[i%ncols];
}
}
static void
div_float_long_by_lines(int total,int nlines,double *mat1,long int *mat2,double *ndata)
{
int ncols = total/nlines, i;
for (i=0;i<total;i++) {
ndata[i] = mat1[i]/mat2[i%ncols];
}
}
static void
div_float_by_lines(int total,int nlines,double *mat1,double *mat2,double *ndata)
{
int ncols = total/nlines, i;
for (i=0;i<total;i++) {
ndata[i] = mat1[i]/mat2[i%ncols];
}
}
static int
matrix_op_to_lines(void)
{
int *mat1, *mat2;
YAP_Term top = YAP_ARG3;
op_type op;
YAP_Term tf;
if (!YAP_IsIntTerm(top)) {
return FALSE;
}
op = YAP_IntOfTerm(top);
mat1 = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat1) {
/* Error */
return FALSE;
}
mat2 = (int *)YAP_BlobOfTerm(YAP_ARG2);
if (!mat2) {
/* Error */
return FALSE;
}
/* create a new array without first dimension */
if (mat1[MAT_TYPE] == INT_MATRIX) {
long int *data1;
int dims = mat1[MAT_NDIMS];
int *nmat;
data1 = matrix_long_data(mat1, dims);
if (mat2[MAT_TYPE] == INT_MATRIX) {
long int *data2 = matrix_long_data(mat2, dims-1);
if (op == MAT_DIV) {
double *ndata;
tf = new_float_matrix(dims,mat1+MAT_DIMS,NULL);
if (tf == YAP_TermNil())
return FALSE;
nmat = YAP_BlobOfTerm(tf);
ndata = matrix_double_data(nmat, dims);
div_int_by_lines(mat1[MAT_SIZE],mat1[MAT_DIMS],data1,data2,ndata);
} else {
return FALSE;
}
} else if (mat2[MAT_TYPE] == FLOAT_MATRIX) {
double *data2 = matrix_double_data(mat2, dims-1);
if (op == MAT_DIV) {
double *ndata;
tf = new_float_matrix(dims,mat1+MAT_DIMS,NULL);
if (tf == YAP_TermNil())
return FALSE;
nmat = YAP_BlobOfTerm(tf);
ndata = matrix_double_data(nmat, dims);
div_int_by_dlines(mat1[MAT_SIZE],mat1[MAT_DIMS],data1,data2,ndata);
} else {
return FALSE;
}
} else {
return FALSE;
}
} else {
double *data1, *ndata;
int dims = mat1[MAT_NDIMS];
int *nmat;
data1 = matrix_double_data(mat1, dims);
tf = new_float_matrix(dims,mat1+MAT_DIMS,NULL);
nmat = YAP_BlobOfTerm(tf);
if (tf == YAP_TermNil())
return FALSE;
ndata = matrix_double_data(nmat, dims);
if (mat2[MAT_TYPE] == INT_MATRIX) {
long int *data2 = matrix_long_data(mat2, dims-1);
if (op == MAT_DIV) {
div_float_long_by_lines(mat1[MAT_SIZE],mat1[MAT_DIMS],data1,data2,ndata);
} else {
return FALSE;
}
} else if (mat2[MAT_TYPE] == FLOAT_MATRIX) {
double *data2 = matrix_double_data(mat2, dims-1);
if (op == MAT_DIV) {
div_float_by_lines(mat1[MAT_SIZE],mat1[MAT_DIMS],data1,data2,ndata);
} else {
return FALSE;
}
} else {
return FALSE;
}
}
return YAP_Unify(YAP_ARG4,tf);
}
static void
matrix_long_add_data(long int *nmat, int siz, long int mat1[], long int mat2[])
{
int i;
for (i=0; i< siz; i++) {
nmat[i] = mat1[i]+mat2[i];
}
}
static void
matrix_long_double_add_data(double *nmat, int siz, long int mat1[], double mat2[])
{
int i;
for (i=0; i< siz; i++) {
nmat[i] = mat1[i]+mat2[i];
}
}
static void
matrix_double_add_data(double *nmat, int siz, double mat1[], double mat2[])
{
int i;
for (i=0; i< siz; i++) {
nmat[i] = mat1[i]+mat2[i];
}
}
static void
matrix_long_sub_data(long int *nmat, int siz, long int mat1[], long int mat2[])
{
int i;
for (i=0; i< siz; i++) {
nmat[i] = mat1[i]-mat2[i];
}
}
static void
matrix_long_double_sub_data(double *nmat, int siz, long int mat1[], double mat2[])
{
int i;
for (i=0; i< siz; i++) {
nmat[i] = mat1[i]-mat2[i];
}
}
static void
matrix_long_double_rsub_data(double *nmat, int siz, double mat1[], long int mat2[])
{
int i;
for (i=0; i< siz; i++) {
nmat[i] = mat2[i]-mat1[i];
}
}
static void
matrix_double_sub_data(double *nmat, int siz, double mat1[], double mat2[])
{
int i;
for (i=0; i< siz; i++) {
nmat[i] = mat1[i]-mat2[i];
}
}
static void
matrix_long_mult_data(long int *nmat, int siz, long int mat1[], long int mat2[])
{
int i;
for (i=0; i< siz; i++) {
nmat[i] = mat1[i]*mat2[i];
}
}
static void
matrix_long_double_mult_data(double *nmat, int siz, long int mat1[], double mat2[])
{
int i;
for (i=0; i< siz; i++) {
nmat[i] = mat1[i]*mat2[i];
}
}
static void
matrix_double_mult_data(double *nmat, int siz, double mat1[], double mat2[])
{
int i;
for (i=0; i< siz; i++) {
nmat[i] = mat1[i]*mat2[i];
}
}
static void
matrix_long_div_data(long int *nmat, int siz, long int mat1[], long int mat2[])
{
int i;
for (i=0; i< siz; i++) {
nmat[i] = mat1[i]/mat2[i];
}
}
static void
matrix_long_double_div_data(double *nmat, int siz, long int mat1[], double mat2[])
{
int i;
for (i=0; i< siz; i++) {
nmat[i] = mat1[i]/mat2[i];
}
}
static void
matrix_long_double_div2_data(double *nmat, int siz, double mat1[], long int mat2[])
{
int i;
for (i=0; i< siz; i++) {
nmat[i] = mat1[i]/mat2[i];
}
}
static void
matrix_double_div_data(double *nmat, int siz, double mat1[], double mat2[])
{
int i;
for (i=0; i< siz; i++) {
nmat[i] = mat1[i]/mat2[i];
}
}
static void
matrix_long_zdiv_data(long int *nmat, int siz, long int mat1[], long int mat2[])
{
int i;
for (i=0; i< siz; i++) {
if (mat1[i] == 0)
nmat[i] = 0;
else
nmat[i] = mat1[i]/mat2[i];
}
}
static void
matrix_long_double_zdiv_data(double *nmat, int siz, long int mat1[], double mat2[])
{
int i;
for (i=0; i< siz; i++) {
if (mat1[i] == 0)
nmat[i] = 0;
else
nmat[i] = mat1[i]/mat2[i];
}
}
static void
matrix_long_double_zdiv2_data(double *nmat, int siz, double mat1[], long int mat2[])
{
int i;
for (i=0; i< siz; i++) {
if (mat1[i] == 0.0)
nmat[i] = 0;
else
nmat[i] = mat1[i]/mat2[i];
}
}
static void
matrix_double_zdiv_data(double *nmat, int siz, double mat1[], double mat2[])
{
int i;
for (i=0; i< siz; i++) {
if (mat1[i] == 0.0) {
nmat[i] = 0.0;
} else {
nmat[i] = mat1[i]/mat2[i];
}
}
}
static int
matrix_op(void)
{
int *mat1, *mat2;
YAP_Term top = YAP_ARG3;
op_type op;
YAP_Term tf;
if (!YAP_IsIntTerm(top)) {
return FALSE;
}
op = YAP_IntOfTerm(top);
mat1 = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat1) {
/* Error */
return FALSE;
}
mat2 = (int *)YAP_BlobOfTerm(YAP_ARG2);
if (!mat2) {
/* Error */
return FALSE;
}
if (mat1[MAT_TYPE] == INT_MATRIX) {
long int *data1;
int dims = mat1[MAT_NDIMS];
int *nmat;
data1 = matrix_long_data(mat1, dims);
if (mat2[MAT_TYPE] == INT_MATRIX) {
long int *data2;
long int *ndata;
tf = new_int_matrix(dims,mat1+MAT_DIMS,NULL);
if (tf == YAP_TermNil()) {
return FALSE;
} else {
/* there may have been an overflow */
mat1 = (int *)YAP_BlobOfTerm(YAP_ARG1);
data1 = matrix_long_data(mat1, dims);
mat2 = (int *)YAP_BlobOfTerm(YAP_ARG2);
data2 = matrix_long_data(mat2, dims);
}
nmat = YAP_BlobOfTerm(tf);
ndata = matrix_long_data(nmat, dims);
switch (op) {
case MAT_PLUS:
matrix_long_add_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
case MAT_SUB:
matrix_long_sub_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
case MAT_TIMES:
matrix_long_mult_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
case MAT_DIV:
matrix_long_div_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
case MAT_ZDIV:
matrix_long_zdiv_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
default:
return FALSE;
}
} else if (mat2[MAT_TYPE] == FLOAT_MATRIX) {
double *data2;
double *ndata;
tf = new_float_matrix(dims,mat1+MAT_DIMS,NULL);
if (tf == YAP_TermNil()) {
return FALSE;
} else {
/* there may have been an overflow */
mat1 = (int *)YAP_BlobOfTerm(YAP_ARG1);
data1 = matrix_long_data(mat1, dims);
mat2 = (int *)YAP_BlobOfTerm(YAP_ARG2);
data2 = matrix_double_data(mat2, dims);
}
nmat = YAP_BlobOfTerm(tf);
ndata = matrix_double_data(nmat, dims);
switch (op) {
case MAT_PLUS:
matrix_long_double_add_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
case MAT_SUB:
matrix_long_double_sub_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
case MAT_TIMES:
matrix_long_double_mult_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
case MAT_DIV:
matrix_long_double_div_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
case MAT_ZDIV:
matrix_long_double_zdiv_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
default:
return FALSE;
}
} else {
return FALSE;
}
} else {
double *data1;
int dims = mat1[MAT_NDIMS];
int *nmat;
data1 = matrix_double_data(mat1, dims);
if (mat2[MAT_TYPE] == INT_MATRIX) {
long int *data2;
double *ndata;
tf = new_float_matrix(dims,mat1+MAT_DIMS,NULL);
if (tf == YAP_TermNil()) {
return FALSE;
} else {
/* there may have been an overflow */
mat1 = (int *)YAP_BlobOfTerm(YAP_ARG1);
data1 = matrix_double_data(mat1, dims);
mat2 = (int *)YAP_BlobOfTerm(YAP_ARG2);
data2 = matrix_long_data(mat2, dims);
}
nmat = YAP_BlobOfTerm(tf);
ndata = matrix_double_data(nmat, dims);
switch (op) {
case MAT_PLUS:
matrix_long_double_add_data(ndata, mat1[MAT_SIZE], data2, data1);
break;
case MAT_SUB:
matrix_long_double_rsub_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
case MAT_TIMES:
matrix_long_double_mult_data(ndata, mat1[MAT_SIZE], data2, data1);
break;
case MAT_DIV:
matrix_long_double_div2_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
case MAT_ZDIV:
matrix_long_double_zdiv2_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
default:
return FALSE;
}
} else if (mat2[MAT_TYPE] == FLOAT_MATRIX) {
double *data2;
double *ndata;
tf = new_float_matrix(dims,mat1+MAT_DIMS,NULL);
if (tf == YAP_TermNil()) {
return FALSE;
} else {
/* there may have been an overflow */
mat1 = (int *)YAP_BlobOfTerm(YAP_ARG1);
data1 = matrix_double_data(mat1, dims);
mat2 = (int *)YAP_BlobOfTerm(YAP_ARG2);
data2 = matrix_double_data(mat2, dims);
}
nmat = YAP_BlobOfTerm(tf);
ndata = matrix_double_data(nmat, dims);
switch (op) {
case MAT_PLUS:
matrix_double_add_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
case MAT_SUB:
matrix_double_sub_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
case MAT_TIMES:
matrix_double_mult_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
case MAT_DIV:
matrix_double_div_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
case MAT_ZDIV:
matrix_double_zdiv_data(ndata, mat1[MAT_SIZE], data1, data2);
break;
default:
return FALSE;
}
} else {
return FALSE;
}
}
return YAP_Unify(YAP_ARG4,tf);
}
static void
add_int_by_cols(int total,int nlines,long int *mat1,long int *mat2,long int *ndata)
{
int i, ncols = total/nlines;
for (i=0;i<total;i++) {
ndata[i] = mat1[i] + mat2[i/ncols];
}
}
static void
add_int_by_dcols(int total,int nlines,long int *mat1,double *mat2,double *ndata)
{
int i, ncols = total/nlines;
for (i=0;i<total;i++) {
ndata[i] = mat1[i] + mat2[i/ncols];
}
}
static void
add_double_by_cols(int total,int nlines,double *mat1,double *mat2,double *ndata)
{
int i;
int ncols = total/nlines;
for (i=0;i<total;i++) {
ndata[i] = mat1[i] + mat2[i/ncols];
}
}
static int
matrix_op_to_cols(void)
{
int *mat1, *mat2;
YAP_Term top = YAP_ARG3;
op_type op;
YAP_Term tf;
if (!YAP_IsIntTerm(top)) {
return FALSE;
}
op = YAP_IntOfTerm(top);
mat1 = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat1) {
/* Error */
return FALSE;
}
mat2 = (int *)YAP_BlobOfTerm(YAP_ARG2);
if (!mat2) {
/* Error */
return FALSE;
}
if (mat1[MAT_TYPE] == INT_MATRIX) {
long int *data1;
int dims = mat1[MAT_NDIMS];
int *nmat;
data1 = matrix_long_data(mat1, dims);
if (mat2[MAT_TYPE] == INT_MATRIX) {
long int *data2 = matrix_long_data(mat2, 1);
if (op == MAT_PLUS) {
long int *ndata;
tf = new_int_matrix(dims,mat1+MAT_DIMS,NULL);
if (tf == YAP_TermNil())
return FALSE;
nmat = YAP_BlobOfTerm(tf);
ndata = matrix_long_data(nmat, dims);
add_int_by_cols(mat1[MAT_SIZE],mat1[MAT_DIMS],data1,data2,ndata);
} else {
return FALSE;
}
} else if (mat2[MAT_TYPE] == FLOAT_MATRIX) {
double *data2 = matrix_double_data(mat2, 1);
if (op == MAT_PLUS) {
double *ndata;
tf = new_float_matrix(dims,mat1+MAT_DIMS,NULL);
if (tf == YAP_TermNil())
return FALSE;
nmat = YAP_BlobOfTerm(tf);
ndata = matrix_double_data(nmat, dims);
add_int_by_dcols(mat1[MAT_SIZE],mat1[MAT_DIMS],data1,data2,ndata);
} else {
return FALSE;
}
} else {
return FALSE;
}
} else {
double *data1, *data2, *ndata;
int dims = mat1[MAT_NDIMS];
int *nmat;
if (mat2[MAT_TYPE] != FLOAT_MATRIX)
return FALSE;
tf = new_float_matrix(dims,mat1+MAT_DIMS,NULL);
if (tf == YAP_TermNil())
return FALSE;
nmat = YAP_BlobOfTerm(tf);
data1 = matrix_double_data(mat1, dims);
data2 = matrix_double_data(mat2, 1);
ndata = matrix_double_data(nmat, dims);
if (op == MAT_PLUS) {
add_double_by_cols(mat1[MAT_SIZE],mat1[MAT_DIMS],data1,data2,ndata);
} else
return FALSE;
}
return YAP_Unify(YAP_ARG4,tf);
}
static int
matrix_op_to_all(void)
{
int *mat;
YAP_Term tf;
YAP_Term top = YAP_ARG2;
op_type op;
if (!YAP_IsIntTerm(top)) {
return FALSE;
}
op = YAP_IntOfTerm(top);
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
if (!mat) {
/* Error */
return FALSE;
}
/* create a new array with same dimensions */
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data;
int dims = mat[MAT_NDIMS];
int *nmat;
YAP_Term tnum = YAP_ARG3;
if (YAP_IsIntTerm(tnum)) {
long int num;
long int *ndata;
num = YAP_IntOfTerm(tnum);
tf = new_int_matrix(dims,mat+(MAT_DIMS),NULL);
if (tf == YAP_TermNil())
return FALSE;
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_long_data(mat, dims);
ndata = matrix_long_data(nmat, dims);
if (op == MAT_PLUS) {
int i;
for (i = 0; i < mat[MAT_SIZE]; i++) {
ndata[i] = data[i] + num;
}
} else if (op == MAT_TIMES) {
int i;
for (i = 0; i < mat[MAT_SIZE]; i++) {
ndata[i] = data[i] * num;
}
} else {
return FALSE;
}
} else if (YAP_IsFloatTerm(tnum)) {
double num;
double *ndata;
num = YAP_FloatOfTerm(tnum);
tf = new_float_matrix(dims,mat+(MAT_DIMS),NULL);
if (tf == YAP_TermNil())
return FALSE;
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_long_data(mat, dims);
ndata = matrix_double_data(nmat, dims);
if (op == MAT_PLUS) {
int i;
for (i = 0; i < mat[MAT_SIZE]; i++) {
ndata[i] = data[i] + num;
}
} else if (op == MAT_TIMES) {
int i;
for (i = 0; i < mat[MAT_SIZE]; i++) {
ndata[i] = data[i] * num;
}
} else if (op == MAT_DIV) {
int i;
for (i = 0; i < mat[MAT_SIZE]; i++) {
ndata[i] = data[i] / num;
}
}
} else {
return FALSE;
}
} else {
double *data, *ndata;
int dims = mat[MAT_NDIMS];
int *nmat;
YAP_Term tnum = YAP_ARG3;
double num;
if (YAP_IsFloatTerm(tnum)) {
num = YAP_FloatOfTerm(tnum);
} else if (!YAP_IntOfTerm(tnum)) {
return FALSE;
} else {
num = (double)YAP_IntOfTerm(tnum);
}
tf = new_float_matrix(dims,mat+(MAT_DIMS),NULL);
if (tf == YAP_TermNil())
return FALSE;
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_double_data(mat, dims);
ndata = matrix_double_data(nmat, dims);
switch(op) {
case MAT_PLUS:
{
int i;
for (i = 0; i < mat[MAT_SIZE]; i++) {
ndata[i] = data[i] + num;
}
}
break;
case MAT_TIMES:
{
int i;
for (i = 0; i < mat[MAT_SIZE]; i++) {
ndata[i] = data[i] * num;
}
}
break;
case MAT_DIV:
{
int i;
for (i = 0; i < mat[MAT_SIZE]; i++) {
ndata[i] = data[i] / num;
}
}
break;
default:
return FALSE;
}
}
return YAP_Unify(YAP_ARG4,tf);
}
/* given a matrix M and a set of dims, build a new reordered matrix to follow
the new order
*/
static int
matrix_transpose(void)
{
int ndims, i, *dims, *dimsn;
int conv[MAX_DIMS], indx[MAX_DIMS], nindx[MAX_DIMS];
YAP_Term tconv, tf;
int *mat = (int *)YAP_BlobOfTerm(YAP_ARG1), *nmat;
if (!mat) {
/* Error */
return FALSE;
}
ndims = mat[MAT_NDIMS];
if (mat[MAT_TYPE] == INT_MATRIX) {
/* create a new matrix with the same size */
tf = new_int_matrix(ndims,mat+MAT_DIMS,NULL);
if (tf == YAP_TermNil())
return FALSE;
} else {
/* create a new matrix with the same size */
tf = new_float_matrix(ndims,mat+MAT_DIMS,NULL);
if (tf == YAP_TermNil())
return FALSE;
}
/* just in case there was an overflow */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
dims = mat+MAT_DIMS;
dimsn = nmat+MAT_DIMS;
/* we now have our target matrix, let us grab our conversion matrix */
tconv = YAP_ARG2;
for (i=0; i < ndims; i++) {
YAP_Term th;
long int j;
if (!YAP_IsPairTerm(tconv))
return FALSE;
th = YAP_HeadOfTerm(tconv);
if (!YAP_IsIntTerm(th))
return FALSE;
conv[i] = j = YAP_IntOfTerm(th);
dimsn[i] = dims[j];
tconv = YAP_TailOfTerm(tconv);
}
/*
we now got all the dimensions set up, so what we need to do
next is to copy the elements to the new matrix.
*/
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data = matrix_long_data(mat,ndims);
/* create a new matrix with the same size */
for (i=0; i< mat[MAT_SIZE]; i++) {
long int x = data[i];
int j;
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
matrix_get_index(mat, i, indx);
for (j = 0; j < ndims; j++) {
nindx[j] = indx[conv[j]];
}
matrix_long_set(nmat, nindx, x);
}
} else {
double *data = matrix_double_data(mat,ndims);
/* create a new matrix with the same size */
for (i=0; i< mat[MAT_SIZE]; i++) {
double x = data[i];
long j;
matrix_get_index(mat, i, indx);
for (j = 0; j < ndims; j++)
nindx[j] = indx[conv[j]];
matrix_float_set(nmat, nindx, x);
}
}
return YAP_Unify(YAP_ARG3, tf);
}
/* given a matrix M and a set of dims, fold one of the dimensions of the
matrix on one of the elements
*/
static int
matrix_select(void)
{
int ndims, i, j, *dims, newdims, prdim, leftarg;
int indx[MAX_DIMS], nindx[MAX_DIMS];
YAP_Term tpdim, tdimarg, tf;
int *mat = (int *)YAP_BlobOfTerm(YAP_ARG1), *nmat;
if (!mat) {
/* Error */
return FALSE;
}
/* we now have our target matrix, let us grab our conversion arguments */
tpdim = YAP_ARG2;
ndims = mat[MAT_NDIMS];
dims = mat+MAT_DIMS;
if (!YAP_IsIntTerm(tpdim)) {
return FALSE;
}
prdim = YAP_IntOfTerm(tpdim);
tdimarg = YAP_ARG3;
if (!YAP_IsIntTerm(tdimarg)) {
return FALSE;
}
leftarg = YAP_IntOfTerm(tdimarg);
for (i=0, j=0; i< ndims; i++) {
if (i != prdim) {
nindx[j]= (mat+MAT_DIMS)[i];
j++;
}
}
newdims = ndims-1;
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data, *ndata;
/* create a new matrix with the same size */
tf = new_int_matrix(newdims,nindx,NULL);
if (tf == YAP_TermNil())
return FALSE;
/* in case the matrix moved */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_long_data(mat,ndims);
ndata = matrix_long_data(nmat,newdims);
/* create a new matrix with smaller size */
for (i=0; i< nmat[MAT_SIZE]; i++) {
int j,k;
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
matrix_get_index(nmat, i, indx);
for (j = 0, k=0; j < newdims; j++,k++) {
if (j == prdim) {
nindx[k] = leftarg;
k++;
}
nindx[k]= indx[j];
}
if (k == prdim) {
nindx[k] = leftarg;
}
ndata[i] = data[matrix_get_offset(mat, nindx)];
}
} else {
double *data, *ndata;
/* create a new matrix with the same size */
tf = new_float_matrix(newdims,nindx,NULL);
if (tf == YAP_TermNil())
return FALSE;
/* in case the matrix moved */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_double_data(mat,ndims);
ndata = matrix_double_data(nmat,newdims);
/* create a new matrix with the same size */
for (i=0; i< nmat[MAT_SIZE]; i++) {
int j,k;
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
matrix_get_index(nmat, i, indx);
for (j = 0, k=0; j < newdims; j++,k++) {
if (j == prdim) {
nindx[k] = leftarg;
k++;
}
nindx[k]= indx[j];
}
if (k == prdim) {
nindx[k] = leftarg;
}
ndata[i] = data[matrix_get_offset(mat, nindx)];
}
}
return YAP_Unify(YAP_ARG4, tf);
}
/* given a matrix M and a set of dims, sum out one of the dimensions
*/
static int
matrix_sum_out(void)
{
int ndims, i, j, *dims, newdims, prdim;
int indx[MAX_DIMS], nindx[MAX_DIMS];
YAP_Term tpdim, tf;
int *mat = (int *)YAP_BlobOfTerm(YAP_ARG1), *nmat;
if (!mat) {
/* Error */
return FALSE;
}
/* we now have our target matrix, let us grab our conversion arguments */
tpdim = YAP_ARG2;
ndims = mat[MAT_NDIMS];
dims = mat+MAT_DIMS;
if (!YAP_IsIntTerm(tpdim)) {
return FALSE;
}
prdim = YAP_IntOfTerm(tpdim);
newdims = ndims-1;
for (i=0, j=0; i< ndims; i++) {
if (i != prdim) {
nindx[j]= (mat+MAT_DIMS)[i];
j++;
}
}
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data, *ndata;
/* create a new matrix with the same size */
tf = new_int_matrix(newdims,nindx,NULL);
if (tf == YAP_TermNil())
return FALSE;
/* in case the matrix moved */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_long_data(mat,ndims);
ndata = matrix_long_data(nmat,newdims);
/* create a new matrix with smaller size */
for (i=0;i<nmat[MAT_SIZE];i++)
ndata[i] = 0;
for (i=0; i< mat[MAT_SIZE]; i++) {
int j, k;
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
matrix_get_index(mat, i, indx);
for (j = 0, k=0; j < ndims; j++) {
if (j != prdim) {
nindx[k++]= indx[j];
}
}
ndata[matrix_get_offset(nmat, nindx)] += data[i];
}
} else {
double *data, *ndata;
/* create a new matrix with the same size */
tf = new_float_matrix(newdims,nindx,NULL);
if (tf == YAP_TermNil())
return FALSE;
/* in case the matrix moved */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_double_data(mat,ndims);
ndata = matrix_double_data(nmat,newdims);
/* create a new matrix with smaller size */
for (i=0;i<nmat[MAT_SIZE];i++)
ndata[i] = 0.0;
for (i=0; i< mat[MAT_SIZE]; i++) {
int j, k;
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
matrix_get_index(mat, i, indx);
for (j = 0, k=0; j < ndims; j++) {
if (j != prdim) {
nindx[k++]= indx[j];
}
}
ndata[matrix_get_offset(nmat, nindx)] += data[i];
}
}
return YAP_Unify(YAP_ARG3, tf);
}
/* given a matrix M and a set of dims, sum out one of the dimensions
*/
static int
matrix_sum_out_several(void)
{
int ndims, i, *dims, newdims;
int indx[MAX_DIMS], nindx[MAX_DIMS], conv[MAX_DIMS];
YAP_Term tf, tconv;
int *mat = (int *)YAP_BlobOfTerm(YAP_ARG1), *nmat;
if (!mat) {
/* Error */
return FALSE;
}
ndims = mat[MAT_NDIMS];
dims = mat+MAT_DIMS;
/* we now have our target matrix, let us grab our conversion arguments */
tconv = YAP_ARG2;
for (i=0, newdims=0; i < ndims; i++) {
YAP_Term th;
if (!YAP_IsPairTerm(tconv))
return FALSE;
th = YAP_HeadOfTerm(tconv);
if (!YAP_IsIntTerm(th))
return FALSE;
conv[i] = YAP_IntOfTerm(th);
if (!conv[i]) {
nindx[newdims++] = dims[i];
}
tconv = YAP_TailOfTerm(tconv);
}
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data, *ndata;
/* create a new matrix with the same size */
tf = new_int_matrix(newdims,nindx,NULL);
if (tf == YAP_TermNil())
return FALSE;
/* in case the matrix moved */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_long_data(mat,ndims);
ndata = matrix_long_data(nmat,newdims);
/* create a new matrix with smaller size */
for (i=0;i<nmat[MAT_SIZE];i++)
ndata[i] = 0;
for (i=0; i< mat[MAT_SIZE]; i++) {
int j, k;
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
matrix_get_index(mat, i, indx);
for (j = 0, k=0; j < ndims; j++) {
if (!conv[j]) {
nindx[k++]= indx[j];
}
}
ndata[matrix_get_offset(nmat, nindx)] = log(exp(ndata[matrix_get_offset(nmat, nindx)]) + exp(data[i]));
}
} else {
double *data, *ndata;
/* create a new matrix with the same size */
tf = new_float_matrix(newdims,nindx,NULL);
if (tf == YAP_TermNil())
return FALSE;
/* in case the matrix moved */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_double_data(mat,ndims);
ndata = matrix_double_data(nmat,newdims);
/* create a new matrix with smaller size */
for (i=0;i<nmat[MAT_SIZE];i++)
ndata[i] = 0.0;
for (i=0; i< mat[MAT_SIZE]; i++) {
int j, k;
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
matrix_get_index(mat, i, indx);
for (j = 0, k=0; j < ndims; j++) {
if (!conv[j]) {
nindx[k++]= indx[j];
}
}
ndata[matrix_get_offset(nmat, nindx)] = log(exp(ndata[matrix_get_offset(nmat, nindx)]) + exp(data[i]));
}
}
return YAP_Unify(YAP_ARG3, tf);
}
/* given a matrix M and a set of dims, sum out one of the dimensions
*/
static int
matrix_sum_out_logs(void)
{
int ndims, i, j, *dims, newdims, prdim;
int indx[MAX_DIMS], nindx[MAX_DIMS];
YAP_Term tpdim, tf;
int *mat = (int *)YAP_BlobOfTerm(YAP_ARG1), *nmat;
if (!mat) {
/* Error */
return FALSE;
}
/* we now have our target matrix, let us grab our conversion arguments */
tpdim = YAP_ARG2;
ndims = mat[MAT_NDIMS];
dims = mat+MAT_DIMS;
if (!YAP_IsIntTerm(tpdim)) {
return FALSE;
}
prdim = YAP_IntOfTerm(tpdim);
newdims = ndims-1;
for (i=0, j=0; i< ndims; i++) {
if (i != prdim) {
nindx[j]= (mat+MAT_DIMS)[i];
j++;
}
}
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data, *ndata;
/* create a new matrix with the same size */
tf = new_int_matrix(newdims,nindx,NULL);
if (tf == YAP_TermNil())
return FALSE;
/* in case the matrix moved */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_long_data(mat,ndims);
ndata = matrix_long_data(nmat,newdims);
/* create a new matrix with smaller size */
for (i=0;i<nmat[MAT_SIZE];i++)
ndata[i] = 0;
for (i=0; i< mat[MAT_SIZE]; i++) {
int j, k;
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
matrix_get_index(mat, i, indx);
for (j = 0, k=0; j < ndims; j++) {
if (j != prdim) {
nindx[k++]= indx[j];
}
}
ndata[matrix_get_offset(nmat, nindx)] += exp(data[i]);
}
for (i=0; i< nmat[MAT_SIZE]; i++) {
ndata[i] = log(ndata[i]);
}
} else {
double *data, *ndata;
/* create a new matrix with the same size */
tf = new_float_matrix(newdims,nindx,NULL);
if (tf == YAP_TermNil())
return FALSE;
/* in case the matrix moved */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_double_data(mat,ndims);
ndata = matrix_double_data(nmat,newdims);
/* create a new matrix with smaller size */
for (i=0;i<nmat[MAT_SIZE];i++)
ndata[i] = 0.0;
for (i=0; i< mat[MAT_SIZE]; i++) {
int j, k;
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
matrix_get_index(mat, i, indx);
for (j = 0, k=0; j < ndims; j++) {
if (j != prdim) {
nindx[k++]= indx[j];
}
}
ndata[matrix_get_offset(nmat, nindx)] += exp(data[i]);
}
for (i=0; i< nmat[MAT_SIZE]; i++) {
ndata[i] = log(ndata[i]);
}
}
return YAP_Unify(YAP_ARG3, tf);
}
/* given a matrix M and a set of dims, sum out one of the dimensions
*/
static int
matrix_sum_out_logs_several(void)
{
int ndims, i, *dims, newdims;
int indx[MAX_DIMS], nindx[MAX_DIMS], conv[MAX_DIMS];
YAP_Term tf, tconv;
int *mat = (int *)YAP_BlobOfTerm(YAP_ARG1), *nmat;
if (!mat) {
/* Error */
return FALSE;
}
ndims = mat[MAT_NDIMS];
dims = mat+MAT_DIMS;
/* we now have our target matrix, let us grab our conversion arguments */
tconv = YAP_ARG2;
for (i=0, newdims=0; i < ndims; i++) {
YAP_Term th;
if (!YAP_IsPairTerm(tconv))
return FALSE;
th = YAP_HeadOfTerm(tconv);
if (!YAP_IsIntTerm(th))
return FALSE;
conv[i] = YAP_IntOfTerm(th);
if (!conv[i]) {
nindx[newdims++] = dims[i];
}
tconv = YAP_TailOfTerm(tconv);
}
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data, *ndata;
/* create a new matrix with the same size */
tf = new_int_matrix(newdims,nindx,NULL);
if (tf == YAP_TermNil())
return FALSE;
/* in case the matrix moved */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_long_data(mat,ndims);
ndata = matrix_long_data(nmat,newdims);
/* create a new matrix with smaller size */
for (i=0;i<nmat[MAT_SIZE];i++)
ndata[i] = 0;
for (i=0; i< mat[MAT_SIZE]; i++) {
int j, k;
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
matrix_get_index(mat, i, indx);
for (j = 0, k=0; j < ndims; j++) {
if (!conv[j]) {
nindx[k++]= indx[j];
}
}
ndata[matrix_get_offset(nmat, nindx)] += exp(data[i]);
}
} else {
double *data, *ndata;
/* create a new matrix with the same size */
tf = new_float_matrix(newdims,nindx,NULL);
if (tf == YAP_TermNil())
return FALSE;
/* in case the matrix moved */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_double_data(mat,ndims);
ndata = matrix_double_data(nmat,newdims);
/* create a new matrix with smaller size */
for (i=0;i<nmat[MAT_SIZE];i++)
ndata[i] = 0.0;
for (i=0; i< mat[MAT_SIZE]; i++) {
int j, k;
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
matrix_get_index(mat, i, indx);
for (j = 0, k=0; j < ndims; j++) {
if (!conv[j]) {
nindx[k++]= indx[j];
}
}
ndata[matrix_get_offset(nmat, nindx)] += exp(data[i]);
}
for (i=0; i< nmat[MAT_SIZE]; i++) {
ndata[i] = log(ndata[i]);
}
}
return YAP_Unify(YAP_ARG3, tf);
}
/* given a matrix M and a set of dims, build contract a matrix to follow
the new order
*/
static int
matrix_expand(void)
{
int ndims, i, *dims, newdims=0, olddims = 0;
int new[MAX_DIMS], indx[MAX_DIMS], nindx[MAX_DIMS];
YAP_Term tconv, tf;
int *mat = (int *)YAP_BlobOfTerm(YAP_ARG1), *nmat;
if (!mat) {
/* Error */
return FALSE;
}
/* we now have our target matrix, let us grab our conversion matrix */
tconv = YAP_ARG2;
ndims = mat[MAT_NDIMS];
dims = mat+MAT_DIMS;
for (i=0; i < MAX_DIMS; i++) {
YAP_Term th;
long int j;
if (!YAP_IsPairTerm(tconv)) {
if (tconv != YAP_TermNil())
return FALSE;
break;
}
th = YAP_HeadOfTerm(tconv);
if (!YAP_IsIntTerm(th))
return FALSE;
newdims++;
j = YAP_IntOfTerm(th);
if (j==0) {
new[i] = 0;
nindx[i] = dims[olddims];
olddims++;
} else {
new[i] = 1;
nindx[i] = j;
}
tconv = YAP_TailOfTerm(tconv);
}
if (olddims != ndims)
return FALSE;
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data, *ndata;
/* create a new matrix with the same size */
tf = new_int_matrix(newdims,nindx,NULL);
if (tf == YAP_TermNil())
return FALSE;
/* in case the matrix moved */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_long_data(mat,ndims);
ndata = matrix_long_data(nmat,newdims);
/* create a new matrix with the same size */
for (i=0; i< nmat[MAT_SIZE]; i++) {
int j,k=0;
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
matrix_get_index(nmat, i, indx);
for (j = 0; j < newdims; j++) {
if (!new[j])
nindx[k++] = indx[j];
}
ndata[i] = data[matrix_get_offset(mat, nindx)];
}
} else {
double *data, *ndata;
/* create a new matrix with the same size */
tf = new_float_matrix(newdims,nindx,NULL);
if (tf == YAP_TermNil())
return FALSE;
/* in case the matrix moved */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_double_data(mat,ndims);
ndata = matrix_double_data(nmat,newdims);
/* create a new matrix with the same size */
for (i=0; i < newdims; i++)
indx[i] = 0;
for (i=0; i< nmat[MAT_SIZE]; i++) {
int j,k=0;
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
for (j = 0; j < newdims; j++) {
if (!new[j])
nindx[k++] = indx[j];
}
ndata[i] = data[matrix_get_offset(mat, nindx)];
matrix_next_index(nmat+MAT_DIMS, newdims, indx);
}
}
return YAP_Unify(YAP_ARG3, tf);
}
/* given a matrix M and a set of dims, build contract a matrix to follow
the new order
*/
static int
matrix_set_all_that_disagree(void)
{
int ndims, i, *dims;
int indx[MAX_DIMS];
YAP_Term tf;
int *mat = (int *)YAP_BlobOfTerm(YAP_ARG1), *nmat;
int dim = YAP_IntOfTerm(YAP_ARG2);
int pos = YAP_IntOfTerm(YAP_ARG3);
if (!mat) {
/* Error */
return FALSE;
}
ndims = mat[MAT_NDIMS];
dims = mat+MAT_DIMS;
if (mat[MAT_TYPE] == INT_MATRIX) {
long int *data, *ndata, val;
/* create a new matrix with the same size */
tf = new_int_matrix(ndims,dims,NULL);
if (tf == YAP_TermNil())
return FALSE;
/* in case the matrix moved */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_long_data(mat,ndims);
ndata = matrix_long_data(nmat,ndims);
if (!YAP_IsIntTerm(YAP_ARG4))
return FALSE;
val = YAP_IntOfTerm(YAP_ARG4);
/* create a new matrix with the same size */
for (i=0; i< nmat[MAT_SIZE]; i++) {
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
matrix_get_index(mat, i, indx);
if (indx[dim] != pos)
ndata[i] = val;
else
ndata[i] = data[i];
}
} else {
double *data, *ndata, val;
/* create a new matrix with the same size */
tf = new_float_matrix(ndims,dims,NULL);
if (tf == YAP_TermNil())
return FALSE;
/* in case the matrix moved */
mat = (int *)YAP_BlobOfTerm(YAP_ARG1);
nmat = (int *)YAP_BlobOfTerm(tf);
data = matrix_double_data(mat,ndims);
ndata = matrix_double_data(nmat,ndims);
if (YAP_IsFloatTerm(YAP_ARG4))
val = YAP_FloatOfTerm(YAP_ARG4);
else if (YAP_IsIntTerm(YAP_ARG4))
val = YAP_IntOfTerm(YAP_ARG4);
else
return FALSE;
/* create a new matrix with the same size */
for (i=0; i< nmat[MAT_SIZE]; i++) {
/*
not very efficient, we could try to take advantage of the fact
that we usually only change an index at a time
*/
matrix_get_index(mat, i, indx);
if (indx[dim] != pos)
ndata[i] = val;
else
ndata[i] = data[i];
}
}
return YAP_Unify(YAP_ARG5, tf);
}
void PROTO(init_matrix, (void));
void
init_matrix(void)
{
YAP_UserCPredicate("new_ints_matrix", new_ints_matrix, 4);
YAP_UserCPredicate("new_ints_matrix_set", new_ints_matrix_set, 4);
YAP_UserCPredicate("new_floats_matrix", new_floats_matrix, 4);
YAP_UserCPredicate("new_floats_matrix_set", new_floats_matrix_set, 4);
YAP_UserCPredicate("matrix_set", matrix_set, 3);
YAP_UserCPredicate("matrix_set_all", matrix_set_all, 2);
YAP_UserCPredicate("matrix_add", matrix_add, 3);
YAP_UserCPredicate("matrix_get", do_matrix_access, 3);
YAP_UserCPredicate("matrix_inc", do_matrix_inc, 2);
YAP_UserCPredicate("matrix_dec", do_matrix_dec, 2);
YAP_UserCPredicate("matrix_inc", do_matrix_inc2, 3);
YAP_UserCPredicate("matrix_dec", do_matrix_dec2, 3);
YAP_UserCPredicate("matrix_to_list", matrix_to_list, 2);
YAP_UserCPredicate("matrix_dims", matrix_dims, 2);
YAP_UserCPredicate("matrix_ndims", matrix_ndims, 2);
YAP_UserCPredicate("matrix_size", matrix_size, 2);
YAP_UserCPredicate("matrix_type_as_number", matrix_type, 2);
YAP_UserCPredicate("matrix_arg_to_offset", matrix_arg_to_offset, 3);
YAP_UserCPredicate("matrix_offset_to_arg", matrix_offset_to_arg, 3);
YAP_UserCPredicate("matrix_max", matrix_max, 2);
YAP_UserCPredicate("matrix_maxarg", matrix_maxarg, 2);
YAP_UserCPredicate("matrix_min", matrix_min, 2);
YAP_UserCPredicate("matrix_minarg", matrix_minarg, 2);
YAP_UserCPredicate("matrix_sum", matrix_sum, 2);
YAP_UserCPredicate("matrix_shuffle", matrix_transpose, 3);
YAP_UserCPredicate("matrix_expand", matrix_expand, 3);
YAP_UserCPredicate("matrix_select", matrix_select, 4);
YAP_UserCPredicate("matrix_to_logs", matrix_log_all,1);
YAP_UserCPredicate("matrix_to_exps", matrix_exp_all, 1);
YAP_UserCPredicate("matrix_to_logs", matrix_log_all2,2);
YAP_UserCPredicate("matrix_to_exps", matrix_exp_all2, 2);
YAP_UserCPredicate("matrix_sum_out", matrix_sum_out, 3);
YAP_UserCPredicate("matrix_sum_out_several", matrix_sum_out_several, 3);
YAP_UserCPredicate("matrix_sum_logs_out", matrix_sum_out_logs, 3);
YAP_UserCPredicate("matrix_sum_logs_out_several", matrix_sum_out_logs_several, 3);
YAP_UserCPredicate("matrix_set_all_that_disagree", matrix_set_all_that_disagree, 5);
YAP_UserCPredicate("do_matrix_op", matrix_op, 4);
YAP_UserCPredicate("do_matrix_agg_lines", matrix_agg_lines, 3);
YAP_UserCPredicate("do_matrix_agg_cols", matrix_agg_cols, 3);
YAP_UserCPredicate("do_matrix_op_to_all", matrix_op_to_all, 4);
YAP_UserCPredicate("do_matrix_op_to_lines", matrix_op_to_lines, 4);
YAP_UserCPredicate("do_matrix_op_to_cols", matrix_op_to_cols, 4);
}
#ifdef _WIN32
int WINAPI PROTO(win_matrixs, (HANDLE, DWORD, LPVOID));
int WINAPI win_matrixs(HANDLE hinst, DWORD reason, LPVOID reserved)
{
switch (reason)
{
case DLL_PROCESS_ATTACH:
break;
case DLL_PROCESS_DETACH:
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
}
return 1;
}
#endif