From sources-request at octave dot org Thu Apr 13 13:53:53 2006
Subject: OVER / over(arrayX,arrayY, at func) / : function implemented.
From: Muthiah Annamalai <dearestchum at yahoo dot co dot in>
To: octave src <sources at octave dot org>
Cc: David dot Bateman at motorola dot com
Date: Thu, 13 Apr 2006 11:40:04 -0700 (PDT)

--0-564094898-1144953604=:37385
Content-Type: text/plain; charset=iso-8859-1
Content-Transfer-Encoding: 8bit
Content-Id: 
Content-Disposition: inline

Hello there,
I have a implementation of OVER function
[over(arrayX,arrayY, at func)] with some test
cases. Please have a look, and see if its good enough
to
make the Octave source tree.

I hope Im not reinventing the wheel.

Thanks
Muthu Annamalai

__________________________________________________
Do You Yahoo!?
Tired of spam?  Yahoo! Mail has the best spam protection around 
http://mail.yahoo.com 
--0-564094898-1144953604=:37385
Content-Type: text/plain; name="over.cpp"
Content-Description: 1267139252-over.cpp
Content-Disposition: inline; filename="over.cpp"

/* 
 * (C) 2006,April, Muthiah Annamalai, FSF. <muthiah dot annamalai at uta dot edu>
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details. 
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/* Include Octave header files */
#include<iostream>
#include<octave/oct.h>
#include<octave/parse.h>
#include<octave/dynamic-ld.h>
#include<octave/oct-map.h>
#include<octave/oct-stream.h>
#include<octave/ov.h>
#include<octave/parse.h>/* for feval */

#include<octave/Matrix.h>
#include<octave/ov-cx-mat.h>
#include<octave/ov-list.h>
#include<octave/ov-base-mat.h>

using namespace std;

  /*
   * is_vector finds out if the given matrix value,
   * is indeed a vector or not. Returns true or false.
   * 
   * PRECONDITION: Assume args is a valid octave_value
   *
   */
static  bool is_vector(octave_value args)
  {
    bool rval=false;

    /* See if its a Vector */
    if(args.is_matrix_type()&& !args.is_char_matrix())
      {
	Matrix m=args.matrix_value();
	if(m.cols()==1 || m.rows()==1)
	  rval=true;
      }

    return rval;
  }


  /*
   *PRECONDITION: Assume the user has called is_vector() function, and has got 'true' value.
   *
   *POSTCONDITION: New object is created & deployed.
   */
static  ColumnVector get_vector(octave_value args)
  {
    ColumnVector c;
    Matrix m=args.matrix_value();

    if(m.cols()==1 || m.rows()==1)
      {
	if(m.cols()==1)
	  c=m.column(0);
	else
	  {
	    /* row vector convert to column */
	    RowVector rv=m.row(0);
	    c=rv.transpose();
	  }
      }
    return c;
  }

/*
 * fcn_handle is what I want.
 * it has a reference to a octave_function
 */

/*
 * ISSUES:
 *
 * Can we take X or Y as a scalar iff the other one is a vector? Yes.
 * If we only take the names of functions using the  at FUNC_NAME notation,
 * we will be restricted to taking only names of loaded functions. Yes.
 * So how do we make a deal? 
 *
 */

DEFUN_DLD(over,args,,
	  "function over(VecX,VecY,opt:function)"\
	  "Return a MxN matrix with f(x,y) evaluated at x,y position"\
	  "for each x,y in VecX,VecY respectively"\
	  "If not function is provided, use '*' as default operation"\
	  "Function can be provided using  at FUNCTION_NAME "\
 	  "as a string. Both are compatible")
{
  int m=0,n=0,aLength=0;
  ColumnVector cv[2];
  bool function_present=false;
  octave_function *func=NULL;

  /* hope to use commutativity of the operators someday */
  bool is_commutative=false;

  aLength=args.length();

  if(aLength < 2)
    {
      std::cout<<"Error Invoking over();"<<std::endl;
      std::cout<<"Usage: function over(VecX,VecY,opt:function)"<<std::endl;
      std::cout<<"See: help over"<<std::endl;
      return octave_value(-1);
    }

  if(!(is_vector(args(0)) || is_vector(args(1))))
    {
      std::cout<<"Invalid argument arg- [1 or 2]Expected Row/Column Vector"<<std::endl;
      return octave_value(-1);
    }

  /* 
   * FIXME: [Support for String-Name functions]
   * Also allow functions to be passed by their names, and then replace the
   * name with a reference to the function-, later.
   */
  if(aLength>=3 && (args(2).is_function_handle() /* ||args(2).is_string() */))
    {
      function_present=true;
      is_commutative=false;
      
      func=args(2).function_value();

#if 0
      std::cout<<"Function Found"<<std::endl;
      std::cout<<func->name()<<std::endl;
#endif

    }

#if 0
  else
    {
      std::cout<<"Function Not Found"<<std::endl;
    }
#endif


  cv[0]=get_vector(args(0));
  cv[1]=get_vector(args(1));

  m=cv[0].length();
  n=cv[1].length();

  Matrix rmat(m,n);
  octave_value_list ovl;
  
  /*
   * If operator is commutative, then
   * do we want to handle this as a special
   * case?
   *
   */

  if(function_present && func!=NULL)
    {
      /* try a dummy invoke on the function,
       and verify if the return value is there. Otherwise
      we report and error & die.*/

      ovl(0)=0;
      ovl(1)=0;

      try
	{
	  if(feval(func,ovl).length() < 1)
	    {
	      std::cout<<"The function "<<func->name()<<" must return atleast one value, on invocation"<<std::endl;
	      return octave_value(-1);
	    }
	}
      catch (...)
	{
	  std::cout<<"Exception: Cannot find function specified"<<std::endl;
	  return octave_value(-1);
	}

      for(int itr=0;itr<m;itr++)
	  for(int icol=0;icol<n;icol++)
	    {
	      ovl(0)=cv[0].elem(itr);
	      ovl(1)=cv[1].elem(icol);
	      
	      /*
	       * Assume feval() returns succesfully, with
	       * a single argument.
	       */
	      rmat.elem(itr,icol)=feval(func,ovl)(0).double_value();
	    }
    }
  else 
    {

      if(m == n)
	{
	  /*
	   * FOR Square Matrices...
	   *
	   * products are commutative though.
	   * Calculate one half of the matrix, and
	   * copy/reflect the other half over.
	   */
	  
	  for(int itr=0;itr<m;itr++)
	    for(int icol=0;icol<=itr;icol++)
	      {
		rmat.elem(itr,icol)=cv[0].elem(itr)*cv[1].elem(icol);
		
		if(icol!=itr)
		  {
		    /* copy lower diagonal element to upper diagonal,
		     while we are outside the diagonals*/
		    rmat.elem(icol,itr)=rmat.elem(itr,icol);
		  }
	      }
	}
      else
	{
	  /*
	   * RedBlood are treated unlike the Blue.
	   */
	  for(int itr=0;itr<m;itr++)
	    for(int icol=0;icol<n;icol++)
	      {
		rmat.elem(itr,icol)=cv[0].elem(itr)*cv[1].elem(icol);
	      }
	}
    }

  return octave_value(rmat);
}
/* g++ -fpic over.cpp -shared -o over.oct -Wall -ggdb -Wall -Wunused -Wconversion -fno-exceptions -DDEBUG=1  `mkoctfile -p INCFLAGS` */

--0-564094898-1144953604=:37385
Content-Type: application/octet-stream; name="test.m"
Content-Transfer-Encoding: base64
Content-Description: 1670179878-test.m
Content-Disposition: attachment; filename="test.m"

IyEgL3Vzci9iaW4vb2N0YXZlIC1xCm92ZXIKZGlzcCgnUHJvZHVjdC0gdGVz
dGluZyA7LSkgSW1lYW4gdGhpcyAqIHByb2R1Y3QnKQpvdmVyKFsxIDJdLFsx
IDIgMyA0XSkKb3ZlcihbMV0sWzEgMiAzXSkKb3ZlcihbMSAyIDNdLFsxXSkK
b3ZlcihbMSAyIDNdLFsxIDIgM10pCm92ZXIoWzFdLFsyXSkgJWVycm9yCgpk
aXNwKCdGdW5jdGlvbnMgYmVpbmcgSW52b2tlZCcpCm92ZXIoWzEgMl0sWzEg
MiAzIDRdLEB4b3IpCm92ZXIoWzFdLFsxIDIgM10sQG1heCkKb3ZlcihbMTQg
MjAgMzUgNDBdLFs3XSxAZ2NkKQpvdmVyKFsxNCAyMCAzNSA0MF0sWzddLEBk
aXNwKSAlZnVuY3Rpb25zIHRoYXQgZG9udCByZXR1cm4gYW4gYXJndW1lbnQh
IApvdmVyKFsxNCAyMCAzNSA0MF0sWzddLEBid2FuZCkgJW5vbi1leGlzdGVu
dCBmdW5jdGlvbnMgdGhyb3cgZXJyb3JzIGF0IE9jdGF2ZSBwcm9tcHQgaXRz
ZWxmLgpvdmVyKFsxXSxbMl0pICVlcnJvcgoKCg==

--0-564094898-1144953604=:37385--