github.com/wzzhu/tensor@v0.9.24/dense_generated.go (about)

     1  // Code generated by genlib2. DO NOT EDIT.
     2  
     3  package tensor
     4  
     5  import "reflect"
     6  
     7  // Ones creates a *Dense with the provided shape and type
     8  func Ones(dt Dtype, shape ...int) *Dense {
     9  	d := recycledDense(dt, shape)
    10  	switch d.t.Kind() {
    11  	case reflect.Int:
    12  		d.Memset(int(1))
    13  	case reflect.Int8:
    14  		d.Memset(int8(1))
    15  	case reflect.Int16:
    16  		d.Memset(int16(1))
    17  	case reflect.Int32:
    18  		d.Memset(int32(1))
    19  	case reflect.Int64:
    20  		d.Memset(int64(1))
    21  	case reflect.Uint:
    22  		d.Memset(uint(1))
    23  	case reflect.Uint8:
    24  		d.Memset(uint8(1))
    25  	case reflect.Uint16:
    26  		d.Memset(uint16(1))
    27  	case reflect.Uint32:
    28  		d.Memset(uint32(1))
    29  	case reflect.Uint64:
    30  		d.Memset(uint64(1))
    31  	case reflect.Float32:
    32  		d.Memset(float32(1))
    33  	case reflect.Float64:
    34  		d.Memset(float64(1))
    35  	case reflect.Complex64:
    36  		d.Memset(complex64(1))
    37  	case reflect.Complex128:
    38  		d.Memset(complex128(1))
    39  	case reflect.Bool:
    40  		d.Memset(true)
    41  	default:
    42  		// TODO: add a Oner interface
    43  	}
    44  	return d
    45  }
    46  
    47  // I creates the identity matrix (usually a square) matrix with 1s across the diagonals, and zeroes elsewhere, like so:
    48  //		Matrix(4,4)
    49  // 		⎡1  0  0  0⎤
    50  // 		⎢0  1  0  0⎥
    51  // 		⎢0  0  1  0⎥
    52  // 		⎣0  0  0  1⎦
    53  // While technically an identity matrix is a square matrix, in attempt to keep feature parity with Numpy,
    54  // the I() function allows you to create non square matrices, as well as an index to start the diagonals.
    55  //
    56  // For example:
    57  //		T = I(Float64, 4, 4, 1)
    58  // Yields:
    59  //		⎡0  1  0  0⎤
    60  //		⎢0  0  1  0⎥
    61  //		⎢0  0  0  1⎥
    62  //		⎣0  0  0  0⎦
    63  //
    64  // The index k can also be a negative number:
    65  // 		T = I(Float64, 4, 4, -1)
    66  // Yields:
    67  // 		⎡0  0  0  0⎤
    68  // 		⎢1  0  0  0⎥
    69  // 		⎢0  1  0  0⎥
    70  // 		⎣0  0  1  0⎦
    71  func I(dt Dtype, r, c, k int) *Dense {
    72  	ret := New(Of(dt), WithShape(r, c))
    73  	i := k
    74  	if k < 0 {
    75  		i = (-k) * c
    76  	}
    77  
    78  	var s *Dense
    79  	var err error
    80  	end := c - k
    81  	if end > r {
    82  		s, err = sliceDense(ret, nil)
    83  	} else {
    84  		s, err = sliceDense(ret, rs{0, end, 1})
    85  	}
    86  
    87  	if err != nil {
    88  		panic(err)
    89  	}
    90  	var nexts []int
    91  	iter := newFlatIterator(&s.AP)
    92  	nexts, err = iter.Slice(rs{i, s.Size(), c + 1})
    93  
    94  	switch s.t.Kind() {
    95  	case reflect.Int:
    96  		data := s.Ints()
    97  		for _, v := range nexts {
    98  			data[v] = 1
    99  		}
   100  	case reflect.Int8:
   101  		data := s.Int8s()
   102  		for _, v := range nexts {
   103  			data[v] = 1
   104  		}
   105  	case reflect.Int16:
   106  		data := s.Int16s()
   107  		for _, v := range nexts {
   108  			data[v] = 1
   109  		}
   110  	case reflect.Int32:
   111  		data := s.Int32s()
   112  		for _, v := range nexts {
   113  			data[v] = 1
   114  		}
   115  	case reflect.Int64:
   116  		data := s.Int64s()
   117  		for _, v := range nexts {
   118  			data[v] = 1
   119  		}
   120  	case reflect.Uint:
   121  		data := s.Uints()
   122  		for _, v := range nexts {
   123  			data[v] = 1
   124  		}
   125  	case reflect.Uint8:
   126  		data := s.Uint8s()
   127  		for _, v := range nexts {
   128  			data[v] = 1
   129  		}
   130  	case reflect.Uint16:
   131  		data := s.Uint16s()
   132  		for _, v := range nexts {
   133  			data[v] = 1
   134  		}
   135  	case reflect.Uint32:
   136  		data := s.Uint32s()
   137  		for _, v := range nexts {
   138  			data[v] = 1
   139  		}
   140  	case reflect.Uint64:
   141  		data := s.Uint64s()
   142  		for _, v := range nexts {
   143  			data[v] = 1
   144  		}
   145  	case reflect.Float32:
   146  		data := s.Float32s()
   147  		for _, v := range nexts {
   148  			data[v] = 1
   149  		}
   150  	case reflect.Float64:
   151  		data := s.Float64s()
   152  		for _, v := range nexts {
   153  			data[v] = 1
   154  		}
   155  	case reflect.Complex64:
   156  		data := s.Complex64s()
   157  		for _, v := range nexts {
   158  			data[v] = 1
   159  		}
   160  	case reflect.Complex128:
   161  		data := s.Complex128s()
   162  		for _, v := range nexts {
   163  			data[v] = 1
   164  		}
   165  	}
   166  	// TODO: create Oner interface for custom types
   167  	return ret
   168  }