Changeset 30871 in project


Ignore:
Timestamp:
05/15/14 05:03:20 (6 years ago)
Author:
Ivan Raikov
Message:

flsim: updates to tensor lib

Location:
release/4/flsim/trunk/sml-lib/tensor
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • release/4/flsim/trunk/sml-lib/tensor/sparse.sml

    r29960 r30871  
    3434        type array = IntArray.array
    3535        type nonzero = { indptr: array, indices: array }
    36         type indexer = t -> int option
     36        type indexer = t -> int option
    3737        datatype storage = CSR | CSC
    3838
     
    4545        val inBounds : t -> t -> bool
    4646
     47        val eq : t * t -> bool
     48
    4749        val app : t -> nonzero -> (t -> unit) -> unit
     50        val iteri : t -> nonzero -> (t * int -> unit) -> unit
    4851
    4952    end
     
    6972        Builds a sparse matrix up from a tensor.
    7073        fromTensor converts the tensor to sparse format;
    71         fromTensor uses it as-is
     74        fromTensor' uses it as-is
    7275
    7376 fromTensorList  [[number,number,...]*]
     
    9093 matrix * matrix
    9194 matrix / matrix
    92  ~ matrix
     95 *> n matrix
    9396        Elementwise operations.
    9497*)
     
    103106        type index = Index.t
    104107        type elem = Number.t
     108
    105109        type matrix
    106110
    107111        exception Data and Shape
    108112
     113        val zero : Number.t
     114
     115        val fromList : index -> ((int * (int * elem) list) list * index * (index option)) -> matrix
    109116        val fromTensor : index -> (Tensor.tensor * (index option)) -> matrix
    110117        val fromTensorList : index -> {tensor: Tensor.tensor, offset: index, sparse: bool} list -> matrix
     
    120127        val map : (elem -> elem) -> matrix -> matrix
    121128        val app : (elem -> unit) -> matrix -> unit
     129        val appi : (index * elem -> unit) -> matrix -> unit
     130
     131        val *> : elem -> matrix -> matrix
    122132
    123133        datatype slice = SLSPARSE of {offset: index, indices: Index.array, data: Tensor.tensor}
    124134                       | SLDENSE  of {offset: index, data: TensorSlice.slice}
     135
    125136        val slice : (matrix * int * int) ->  slice list
    126137        val sliceAppi: ((int * elem) -> unit) -> slice list -> unit
    127138        val sliceFoldi: ((int * elem * 'a) -> 'a) -> 'a -> slice list -> 'a
    128139
    129 (*
    130         val mapi : (index * elem -> elem) -> matrix -> matrix
    131         val appi : (index * elem -> unit) -> matrix -> unit
    132         val map2 : (elem * elem -> elem) -> matrix -> matrix -> matrix
    133 
    134 
    135         val + : matrix * matrix -> matrix
    136         val - : matrix * matrix -> matrix
    137         val * : matrix * matrix -> matrix
    138         val / : matrix * matrix -> matrix
    139         val ~ : matrix -> matrix
    140 *)
     140                                                                         
    141141    end
    142142
     
    159159        fun validShape shape = List.all (fn x => x > 0) shape
    160160        fun validIndex index = List.all (fn x => x >= 0) index
     161
     162        fun compare ([],[]) = EQUAL
     163          | compare (_, []) = raise Index
     164          | compare ([],_) = raise Index
     165          | compare (a::ra, b::rb) =
     166            case Int.compare (a,b) of
     167                EQUAL => compare (ra,rb)
     168              | LESS => LESS
     169              | GREATER => GREATER
     170
     171        fun eq (a, b) = compare(a,b) = EQUAL
    161172
    162173        val sub = IntArray.sub
     
    210221            end
    211222
    212         fun app shape {indptr, indices}   =
     223        fun iteri shape {indptr, indices} f  =
    213224            (case order of
    214                  CSR =>
     225                 CSC =>
    215226                 (let
    216227                      val ni = IntArray.length indices
    217228                      val nj = IntArray.length indptr
    218                       fun iterator j f =
    219                           if (j < nj)
    220                           then (let
    221                                     val jj  = sub (indptr, j)
    222                                     val jj' = sub (indptr, if (j < (nj-1)) then j+1 else ni-1)
    223                                 in
    224                                     (List.app f (List.tabulate (jj'-jj, fn (jk) => [sub(indices,jj+jk),j]));
    225                                      iterator (j+1) f)
    226                                 end)
    227                           else ()
    228229                  in
    229                       iterator 0
     230                      Loop.app (0, nj,
     231                                fn (j) =>
     232                                   (let
     233                                        val jj  = sub (indptr, j)
     234                                        val jj' = if (j < (nj-1)) then sub (indptr, j+1) else ni
     235                                    in
     236                                        List.app f (List.tabulate
     237                                                     (jj'-jj,
     238                                                      fn (jk) =>
     239                                                         let val n = jj+jk
     240                                                         in
     241                                                             ([sub(indices,n),j],n)
     242                                                         end))
     243                                end))
    230244                  end)
    231                | CSC =>
     245               | CSR =>
    232246                 (let
    233247                      val nj = IntArray.length indices
    234248                      val ni = IntArray.length indptr
    235                       fun iterator i f =
    236                           if (i < ni)
    237                           then (let
    238                                     val ii  = sub (indptr, i)
    239                                     val ii' = sub (indptr, if (i < (ni-1)) then i+1 else nj-1)
    240                                 in
    241                                     (List.app f (List.tabulate (ii'-ii, fn (ik) => [i,sub(indices,ii+ik)]));
    242                                      iterator (i+1) f)
    243                                 end)
    244                           else ()
    245249                  in
    246                       iterator 0
     250                      Loop.app (0, ni,
     251                                fn (i) =>
     252                                   (let
     253                                        val ii  = sub (indptr, i)
     254                                        val ii' = if (i < (ni-1)) then sub (indptr, i+1) else nj
     255                                    in
     256                                        List.app f (List.tabulate
     257                                                         (ii'-ii,
     258                                                          fn (ik) =>
     259                                                             let
     260                                                                 val n = ii+ik
     261                                                             in
     262                                                                 ([i,sub(indices,n)],n)
     263                                                             end))
     264                                    end))
    247265                  end)
    248266            )
    249267
     268        fun app shape nz f = iteri shape nz (fn (index,i) => f index)
    250269    end
    251270
     
    263282    type nonzero = Index.nonzero
    264283    type elem    = Number.t
     284
     285    val zero     = Number.zero
     286
    265287    datatype block =
    266              SPARSE of {offset: index, shape: index, nz: nonzero, data: elem array}
     288             SPARSE of {offset: index, shape: index, nz: nonzero, data: Tensor.Array.array}
    267289           | DENSE of {offset: index, data: Tensor.tensor}
    268290
     
    282304
    283305    fun array_map f a =
    284         let fun apply index = f(Array.sub(a,index)) in
    285             Array.tabulate(Array.length a, apply)
     306        let fun apply index = f(Tensor.Array.sub(a,index)) in
     307            Tensor.Array.tabulate(Tensor.Array.length a, apply)
    286308        end
    287309
    288     fun array_mapi f a =
    289         let fun apply index = f(index,Array.sub(a,index)) in
    290             Array.tabulate(Array.length a, apply)
    291         end
    292310
    293311    fun findBlock (i,j,blocks) =
     
    315333        end
    316334
    317     fun intArrayWrite file x = Array.app (fn (i) => putStr file ((Int.toString i) ^ " ")) x
    318 
    319335    (* --- CONSTRUCTORS --- *)
     336
     337    fun fromList shape (a, shape_a, offset) =
     338        (let
     339             val len_a = List.length a
     340             val (rows,cols) = dimVals shape_a
     341        in
     342            case Index.order of
     343                Index.CSC =>
     344                let
     345                    val data: (((int * elem) DynArray.array) option) Array.array = Array.array(cols,NONE)
     346                    val nzcount = ref 0
     347                    val _ = List.app
     348                                (fn (icol,lst) =>
     349                                    case lst of
     350                                        [(irow,v)] => if not (Number.== (v,zero))
     351                                                      then (Array.update (data, icol, SOME (DynArray.fromList [(irow,v)]));
     352                                                            nzcount := (!nzcount) + 1)
     353                                                      else ()
     354                                      | (_ :: _) =>
     355                                        (Array.update (data, icol, SOME (DynArray.fromList lst));
     356                                         nzcount := (!nzcount) + (List.length lst))
     357                                      | [] => ()) a
     358                    val data'   = Tensor.Array.array (!nzcount, zero)
     359                    val indices = IntArray.array (!nzcount, 0)
     360                    val indptr  = IntArray.array (cols, 0)
     361                    val update  = IntArray.update
     362                    val fi      = Array.foldli
     363                                      (fn (n,SOME cols,i) =>
     364                                          let
     365                                              val i' = DynArray.foldr
     366                                                           (fn ((rowind,v),i) =>
     367                                                               (Tensor.Array.update (data',i,v);
     368                                                                update (indices,i,rowind);
     369                                                                i+1))
     370                                                           i cols
     371                                          in
     372                                              (update (indptr,n,i); i')
     373                                          end
     374                                      | (n,NONE,i) => (update (indptr,n,i); i))
     375                                      0 data
     376                in
     377                    {shape=shape,
     378                     blocks=[SPARSE {offset=case offset of NONE => [0, 0] | SOME i => i,
     379                                     shape=shape_a, nz={ indptr= indptr, indices=indices },
     380                                     data=data'}]}
     381                end
     382              | Index.CSR =>
     383                let
     384                    val data: (((int * elem) DynArray.array) option) Array.array  = Array.array(rows,NONE)
     385                    val nzcount = ref 0
     386                    val _ = List.app
     387                                (fn (irow,lst) =>
     388                                    case lst of
     389                                        [(icol,v)] => if not (Number.== (v,zero))
     390                                                      then (Array.update (data, irow, SOME (DynArray.fromList [(icol,v)]));
     391                                                            nzcount := (!nzcount) + 1)
     392                                                      else ()
     393                                      | (_ :: _) =>
     394                                        (Array.update (data, irow, SOME (DynArray.fromList lst));
     395                                         nzcount := (!nzcount) + (List.length lst))
     396                                      | [] => ()) a
     397                    val data'   = Tensor.Array.array (!nzcount, zero)
     398                    val indices = IntArray.array (!nzcount, 0)
     399                    val indptr  = IntArray.array (rows, 0)
     400                    val update  = IntArray.update
     401                    val fi      = Array.foldli
     402                                      (fn (n,SOME rows,i) =>
     403                                          let
     404                                              val i' = DynArray.foldr
     405                                                           (fn ((colind,v),i) =>
     406                                                               (Tensor.Array.update (data',i,v);
     407                                                                update (indices,i,colind);
     408                                                                i+1))
     409                                                           i rows
     410                                          in
     411                                              (update (indptr,n,i); i')
     412                                          end
     413                                      | (n,NONE,i) => (update (indptr,n,i); i))
     414                                      0 data
     415                in
     416                    {shape=shape,
     417                     blocks=[SPARSE {offset = case offset of NONE => [0,0] | SOME i => i,
     418                                     shape=shape_a, nz={ indptr= indptr, indices=indices }, data=data'}]}
     419                end
     420        end)
    320421
    321422    fun fromTensor shape (a: Tensor.tensor, offset) =
     
    327428                Index.CSC =>
    328429                let
    329                     val v0: (int * elem) list = []
    330430                    val data: (((int * elem) DynArray.array) option) Array.array  =
    331431                        Array.array(cols,NONE)
     
    336436                                              val v = Tensor.sub (a, i)
    337437                                          in
    338                                               if not (Number.== (v, Number.zero))
     438                                              if not (Number.== (v, zero))
    339439                                              then
    340440                                                  let
     
    351451                                              else ()
    352452                                          end)
    353                     val data'   = Array.array (!nzcount, Number.zero)
     453                    val data'   = Tensor.Array.array (!nzcount, zero)
    354454                    val indices = IntArray.array (!nzcount, 0)
    355455                    val indptr  = IntArray.array (cols, 0)
     
    360460                                              val i' = DynArray.foldr
    361461                                                           (fn ((rowind,v),i) =>
    362                                                                (Array.update (data',i,v);
     462                                                               (Tensor.Array.update (data',i,v);
    363463                                                                update (indices,i,rowind);
    364464                                                                i+1))
     
    372472                    {shape=shape,
    373473                     blocks=[SPARSE {offset=case offset of NONE => [0, 0] | SOME i => i,
    374                                      shape=shape_a, nz={ indptr= indptr, indices=indices }, data=data'}]}
     474                                     shape=shape_a, nz={ indptr= indptr, indices=indices },
     475                                     data=data'}]}
    375476                end
    376477              | Index.CSR =>
    377478                let
    378                     val v0: (int * elem) list = []
    379479                    val data: (((int * elem) DynArray.array) option) Array.array  =
    380480                        Array.array(rows,NONE)
     
    385485                                                      val v = Tensor.sub (a, i)
    386486                                                  in
    387                                                       if not (Number.== (v, Number.zero))
     487                                                      if not (Number.== (v, zero))
    388488                                                      then
    389489                                                          let
     
    400500                                                      else ()
    401501                                                  end)
    402                     val data'   = Array.array (!nzcount, Number.zero)
     502                    val data'   = Tensor.Array.array (!nzcount, zero)
    403503                    val indices = IntArray.array (!nzcount, 0)
    404504                    val indptr  = IntArray.array (rows, 0)
     
    409509                                              val i' = DynArray.foldr
    410510                                                           (fn ((colind,v),i) =>
    411                                                                (Array.update (data',i,v);
     511                                                               (Tensor.Array.update (data',i,v);
    412512                                                                update (indices,i,colind);
    413513                                                                i+1))
     
    443543                Index.CSC =>
    444544                let
    445                     val v0: (int * elem) list = []
    446545                    val data: (((int * elem) DynArray.array) option) Array.array  =
    447546                        Array.array(cols,NONE)
     
    453552                                        val v = f (i)
    454553                                    in
    455                                         if not (Number.== (v, Number.zero))
     554                                        if not (Number.== (v, zero))
    456555                                        then
    457556                                            let
     
    468567                                        else ()
    469568                                    end)
    470                     val data'   = Array.array (!nzcount, Number.zero)
     569                    val data'   = Tensor.Array.array (!nzcount, zero)
    471570                    val indices = IntArray.array (!nzcount, 0)
    472571                    val indptr  = IntArray.array (cols, 0)
     
    477576                                              val i' = DynArray.foldr
    478577                                                           (fn ((rowind,v),i) =>
    479                                                                (Array.update (data',i,v);
     578                                                               (Tensor.Array.update (data',i,v);
    480579                                                                update (indices,i,rowind);
    481580                                                                i+1))
     
    493592              | Index.CSR =>
    494593                let
    495                     val v0: (int * elem) list = []
    496594                    val data: (((int * elem) DynArray.array) option) Array.array  =
    497595                        Array.array(rows,NONE)
     
    502600                                                      val v = f (i)
    503601                                                  in
    504                                                       if not (Number.== (v, Number.zero))
     602                                                      if not (Number.== (v, zero))
    505603                                                      then
    506604                                                          let
    507605                                                              val (irow,icol) = dimVals i
    508606                                                              val rowv  = Array.sub (data, irow)
    509                                                               (*val row' = (icol,v) :: row*)
    510607                                                          in
    511608                                                              (case rowv of
    512                                                                    (*Array.update(data,irow,row');*)
    513609                                                                   SOME row => DynArray.update (row,DynArray.length row,(icol,v))
    514610                                                                 | NONE => Array.update (data, irow, SOME (DynArray.fromList [(icol,v)]));
     
    517613                                                      else ()
    518614                                                  end)
    519                     val data'   = Array.array (!nzcount, Number.zero)
     615                    val data'   = Tensor.Array.array (!nzcount, zero)
    520616                    val indices = IntArray.array (!nzcount, 0)
    521617                    val indptr  = IntArray.array (rows, 0)
     
    526622                                              val i' = DynArray.foldr
    527623                                                           (fn ((colind,v),i) =>
    528                                                                (Array.update (data',i,v);
     624                                                               (Tensor.Array.update (data',i,v);
    529625                                                                update (indices,i,colind);
    530626                                                                i+1))
     
    678774                         val p = Index.toInt shape nz [i-m,j-n]
    679775                       in
    680                            case p of SOME p' => Array.sub (data, p')
    681                                    | NONE => Number.zero
     776                           case p of SOME p' => Tensor.Array.sub (data, p')
     777                                   | NONE => zero
    682778                       end)
    683779                     | DENSE {offset, data} =>
     
    688784                       end)
    689785                )
    690               | NONE => Number.zero
     786              | NONE => zero
    691787        end
    692788
     
    704800                         val p     = Index.toInt shape nz [i-m,j-n]
    705801                     in
    706                          case p of SOME p' => Array.update (data, p', new) | NONE => ()
     802                         case p of SOME p' => Tensor.Array.update (data, p', new) | NONE => ()
    707803                     end)
    708804                     | DENSE {offset, data} =>
     
    764860                     (Index.CSC,1) => (let
    765861                                           val s   = IntArray.sub (indptr, i')
    766                                            val e   = (if i' < n-1
    767                                                       then IntArray.sub (indptr, i'+1) else Array.length data)
     862                                           val e   = (if i' < (n-1)
     863                                                      then IntArray.sub (indptr, i'+1)
     864                                                      else Tensor.Array.length data)
    768865                                           val len = e-s
    769                                            val res = RNumberArray.array (len, Number.zero)
     866                                           val res = Tensor.Array.array (len, zero)
    770867                                           val rsi = IntArray.array (len, 0)
    771868                                           fun loop (i,n) = if i < e
    772                                                             then (RNumberArray.update (res,n,Array.sub (data,i));
     869                                                            then (Tensor.Array.update (res,n,Tensor.Array.sub (data,i));
    773870                                                                  IntArray.update (rsi,i-s,Index.sub (indices,i));
    774871                                                                  loop (i+1,n+1))
     
    783880                                       end)
    784881                   | (Index.CSR,0) => (let val s   = IntArray.sub (indptr, i')
    785                                            val e   = (if i'< (m-1)
    786                                                       then IntArray.sub (indptr, i'+1) else Array.length data)
     882                                           val e   = (if i' < (m-1)
     883                                                      then IntArray.sub (indptr, i'+1)
     884                                                      else Tensor.Array.length data)
    787885                                           val len = e-s
    788                                            val res = RNumberArray.array (len, Number.zero)
     886                                           val res = Tensor.Array.array (len, zero)
    789887                                           val rsi = IntArray.array (len, 0)
    790888                                           fun loop (i,n) = if i < e
    791                                                             then (RNumberArray.update (res,n,Array.sub (data,i));
     889                                                            then (Tensor.Array.update (res,n,Tensor.Array.sub (data,i));
    792890                                                                  IntArray.update (rsi,i-s,Index.sub (indices,i));
    793891                                                                  loop (i+1,n+1))
     
    801899                                           else NONE
    802900                                       end)
    803                    | (Index.CSC,0) => (let val vs = IntArray.foldri
    804                                                         (fn (n,ii,ax) =>  if ii=i then (Array.sub(data,n),ii)::ax else ax)
     901                   | (Index.CSC,0) => (let fun findcol (n) = case IntArray.findi (fn (_,x) => n < x) indptr of
     902                                                                 SOME (m,_) => (m-1)
     903                                                               | NONE => m-1
     904                                           val vs = IntArray.foldri
     905                                                        (fn (n,ii,ax) => if i'=ii then (Tensor.Array.sub(data,n),findcol n)::ax else ax)
    805906                                                        [] indices
    806907                                           val len = List.length vs
     
    812913                                           else NONE
    813914                                       end)
    814                    | (Index.CSR,1) => (let val vs = IntArray.foldri
    815                                                         (fn (n,ii,ax) =>  if ii=i then (Array.sub(data,n),ii)::ax else ax)
     915                   | (Index.CSR,1) => (let fun findrow (n) = case IntArray.findi (fn (_,x) => n < x) indptr of
     916                                                                 SOME (n,_) => (n-1)
     917                                                               | NONE => n-1
     918                                           val vs = IntArray.foldri
     919                                                        (fn (n,ii,ax) =>  if i'=ii then (Tensor.Array.sub(data,n),findrow n)::ax else ax)
    816920                                                        [] indices
    817921                                           val len = List.length vs
     
    852956                     (fn (SPARSE {offset, shape, nz, data}) =>
    853957                         (SPARSE {offset=offset, shape=shape, nz=nz, data=array_map f data})
    854                      |  (DENSE {offset, data}) =>
    855                          (DENSE {data=(Tensor.map f data), offset=offset}))
     958                       |  (DENSE {offset, data}) =>
     959                          (DENSE {data=(Tensor.map f data), offset=offset}))
    856960                     blocks)}
     961
    857962
    858963    fun app f {shape, blocks} =
    859964        List.app (fn (SPARSE {offset, shape, nz, data}) =>
    860                      Array.app f data
    861                  | (DENSE {offset, data}) =>
    862                    Tensor.app f data)
     965                     Tensor.Array.app f data
     966                   | (DENSE {offset, data}) =>
     967                     Tensor.app f data)
    863968                 blocks
     969
     970
     971    fun appi f {shape, blocks} =
     972        List.app (fn (SPARSE {offset, shape, nz, data}) =>
     973                     Index.iteri shape nz (fn (idx,i) =>
     974                                              f (ListPair.map (op +) (offset, idx),
     975                                                 Tensor.Array.sub (data,i)))
     976                   | (DENSE {offset, data}) =>
     977                     Tensor.appi (fn (i,v) => f (ListPair.map (op +) (offset, i),v)) data)
     978                 blocks
     979
     980
     981    fun *> n a = map (fn x => Number.*(n,x)) a
     982
     983
     984    (* --- BINOPS --- *)
     985
     986
     987    fun map2 f ({shape', blocks'}) ({shape'', blocks''}) =
     988        if Index.eq(shape',shape')
     989        then {shape=shape',
     990              blocks=(ListPair.map
     991                          (fn (SPARSE {offset=offset', shape=shape', nz=nz', data=data'},
     992                               SPARSE {offset=offset'', shape=shape'', nz=nz'', data=data''}) =>
     993                              (if Index.eq (offset',offset'') andalso
     994                                  Index.eq (shape',shape'')
     995                               then (let
     996                                         val t = Tensor.new (shape', zero)
     997                                         val _ = Index.iteri shape' nz'
     998                                                             (fn (idx,i) => Tensor.update (t,idx,Tensor.Array.sub (data',i)))
     999                                         val _ = Index.iteri shape' nz''
     1000                                                             (fn (idx,i) =>
     1001                                                                 let val v' = Tensor.sub (t,idx)
     1002                                                                     val v'' = f(v',Tensor.Array.sub(data'',i))
     1003                                                                 in
     1004                                                                     Tensor.update (t,idx,v'')
     1005                                                                 end)
     1006                                     in
     1007                                         hd (#blocks (fromTensor shape' (t, SOME offset')))
     1008                                     end)
     1009                               else raise Match)
     1010                            |  (DENSE {offset=offset', data=data'},
     1011                                DENSE {offset=offset'', data=data''}) =>
     1012                              (if Index.eq (offset',offset'')
     1013                               then
     1014                                   DENSE {offset=offset',data=Tensor.map2 f data' data''}
     1015                               else raise Match)
     1016                            | (_, _) => raise Match)
     1017                          (blocks',blocks''))}
     1018        else raise Index
     1019
     1020
     1021    (* --- SLICE OPERATIONS --- *)
    8641022
    8651023    fun sliceAppi f sl =
     
    9151073            init sl 
    9161074
    917 
    918     (* --- BINOPS --- *)
    919 (*
    9201075    fun a + b = map2 Number.+ a b
    9211076    fun a * b = map2 Number.* a b
    9221077    fun a - b = map2 Number.- a b
    9231078    fun a / b = map2 Number./ a b
    924     fun ~ a = map Number.~ a
    925 *)
     1079
    9261080end
    9271081
  • release/4/flsim/trunk/sml-lib/tensor/tensor.sml

    r29960 r30871  
    180180  +,-
    181181        Index addition and subtraction
     182  incr,decr
     183        Index increment and decrement by a constant
    182184
    183185  validShape t
     
    185187        Checks whether 't' conforms a valid shape or index.
    186188
    187   iteri shape f
    188189*)
    189190
     
    218219        val - : t * t -> t
    219220        val + : t * t -> t
    220         val decr: t -> t
    221221
    222222        val validShape : t -> bool
     
    461461   
    462462
    463         fun a < b = compare(a,b) = LESS
    464         fun a > b = compare(a,b) = GREATER
    465         fun eq (a, b) = compare(a,b) = EQUAL
    466         fun a <> b = not (a = b)
    467         fun a <= b = not (a > b)
    468         fun a >= b = not (a < b)
    469         fun a - b = ListPair.map Int.- (a,b)
    470         fun a + b = ListPair.map Int.+ (a,b)
    471 
    472         fun decr a = List.map (fn (x) => Int.-(x,1)) a
    473 
    474     end
     463    fun a < b = compare(a,b) = LESS
     464    fun a > b = compare(a,b) = GREATER
     465    fun eq (a, b) = compare(a,b) = EQUAL
     466    fun a <> b = not (a = b)
     467    fun a <= b = not (a > b)
     468    fun a >= b = not (a < b)
     469    fun a - b = ListPair.map Int.- (a,b)
     470    fun a + b = ListPair.map Int.+ (a,b)
     471               
     472    fun decr n a = List.map (fn (x) => Int.-(x,n)) a
     473    fun incr n a = List.map (fn (x) => Int.+(x,n)) a
     474                 
     475  end
    475476
    476477
     
    503504        val iteri_range : (index * index -> bool) -> t -> bool
    504505        val iteri2_range : (((index * index) * (index * index)) -> bool) -> (t * t) -> bool
     506
    505507        val foldi_range : (((index * index) * 'a) -> 'a) -> 'a -> t -> 'a
    506508       
     
    10111013        val map2 : ('a * 'b -> 'c) -> 'a tensor -> 'b tensor -> 'c tensor
    10121014        val app : ('a -> unit) -> 'a tensor -> unit
    1013         val appi : (int * 'a -> unit) -> 'a tensor -> unit
     1015        val appi : (index * 'a -> unit) -> 'a tensor -> unit
    10141016        val foldl : ('a * 'b -> 'b) -> 'b -> 'a tensor -> 'b
    10151017        val foldln : ('c * 'a -> 'c) -> 'c -> 'a tensor -> int -> 'c tensor
     
    12571259        end
    12581260
    1259         fun appi f tensor = Array.appi f (toArray tensor)
     1261        fun appi f tensor =
     1262            let
     1263                val shape = shape tensor
     1264                val next = Index.next shape
     1265            in
     1266                (Array.foldl
     1267                     (fn (v,i) => (f (i,v); valOf (next i)))
     1268                     (Index.first shape)
     1269                     (toArray tensor); ())
     1270            end
    12601271
    12611272        fun app f tensor = Array.app f (toArray tensor)
     
    14821493        val map2 : (elem * elem -> elem) -> tensor -> tensor -> tensor
    14831494        val app : (elem -> unit) -> tensor -> unit
    1484         val appi : (int * elem -> unit) -> tensor -> unit
     1495        val appi : (index * elem -> unit) -> tensor -> unit
    14851496        val foldl : (elem * 'a -> 'a) -> 'a -> tensor -> 'a
    14861497        val foldln : (elem * elem -> elem) -> elem -> tensor -> int -> tensor
     
    15251536 so as to build an algebraic structure named Tensor.
    15261537 *)
    1527 
    1528 signature NUMBER =
    1529     sig
    1530         type t
    1531         val zero : t
    1532         val one  : t
    1533         val ~ : t -> t
    1534         val + : t * t -> t
    1535         val - : t * t -> t
    1536         val * : t * t -> t
    1537         val / : t * t -> t
    1538         val toString : t -> string
    1539     end
    15401538
    15411539signature NUMBER =
     
    22802278                    raise Match
    22812279        end
    2282         fun appi f tensor = Array.appi f (toArray tensor)
     2280        fun appi f tensor =
     2281            let
     2282                val shape = shape tensor
     2283                val next = Index.next shape
     2284            in
     2285                (Array.foldl
     2286                     (fn (v,i) => (f (i,v); valOf (next i)))
     2287                     (Index.first shape)
     2288                     (toArray tensor); ())
     2289            end
    22832290        fun app f tensor = Array.app f (toArray tensor)
    22842291        fun all f tensor =
     
    26612668                    raise Match
    26622669        end
    2663         fun appi f tensor = Array.appi f (toArray tensor)
     2670        fun appi f tensor =
     2671            let
     2672                val shape = shape tensor
     2673                val next = Index.next shape
     2674            in
     2675                (Array.foldl
     2676                     (fn (v,i) => (f (i,v); valOf (next i)))
     2677                     (Index.first shape)
     2678                     (toArray tensor); ())
     2679            end
    26642680        fun app f tensor = Array.app f (toArray tensor)
    26652681        fun all f tensor =
     
    29732989                    raise Match
    29742990        end
    2975         fun appi f tensor = Array.appi f (toArray tensor, 0, NONE)
     2991        fun appi f tensor =
     2992            let
     2993                val shape = shape tensor
     2994                val next = Index.next shape
     2995            in
     2996                (Array.foldl
     2997                     (fn (v,i) => (f (i,v); valOf (next i)))
     2998                     (Index.first shape)
     2999                     (toArray tensor); ())
     3000            end
    29763001        fun app f tensor = Array.app f (toArray tensor)
    29773002        fun all f tensor =
Note: See TracChangeset for help on using the changeset viewer.