 
     /// get total size of memory in bytes
     public var bytesCount: Int {
-      get {
-        return Int(TFLib.TensorByteSize(tensor))
-      }
+      return Int(TFLib.TensorByteSize(tensor))
     }
 
     /// dimensions
     public var dim: [Int64] {
-      get {
-        do {
-          let sz = dimensionCount
-          var array = [Int64]()
-          if sz > 0 {
-            for i in 0 ... sz - 1 {
-              array.append(try dimension(i))
-            }//next i
-          }//end if
-          return array
-        }catch {
-          return [Int64]()
-        }
+      do {
+        let sz = dimensionCount
+        var array = [Int64]()
+        if sz > 0 {
+          for i in 0 ... sz - 1 {
+            array.append(try dimension(i))
+          }//next i
+        }//end if
+        return array
+      }catch {
+        return [Int64]()
       }
     }
 


    /// get tensorflow type from the Swift one, will be nil if not available
    public var matched: DataType? {
      get {
        switch "\(T.self)" {
        case "Float":  return  DataType.dtFloat
        case "Double":  return  DataType.dtDouble
        case "Int32":  return  DataType.dtInt32
        case "UInt8":  return  DataType.dtUint8
        case "Int16":  return  DataType.dtInt16
        case "Int8":  return  DataType.dtInt8
        case "Int64", "Int":  return  DataType.dtInt64
        case "Bool":  return  DataType.dtBool
        case "UInt16":  return  DataType.dtUint16
        case "String", "Data": return DataType.dtString
        default:
          return nil
        }//end switch
      }//end case
    }//end var

    /// size of the type
    public var size: Int? {
      get {
        guard let tp = matched else { return nil }
        do {
          return try TensorFlow.SizeOf(Type: tp)
        }catch {
          return nil
        }
      }//end get
    }//end var

    public var description: String {
      get {
        return "<\(T.self): \(size ?? 0)>"
      }//end get
    }//end var
  }//end class DType



    /// get node definition
    public var nodeDefinition: NodeDef? {
      do {
        let status = try Status()
        let buffer = try Buffer()
        TFLib.OperationToNodeDef(operation, buffer.buffer, status.status)
        guard status.code == .OK,
          let data = buffer.data
          else { return nil }
        return try NodeDef(serializedData: data)
      }catch {
        return nil
      }//end try
    }//end var

    /// get operation name
    public var name: String? {
      if let nm = TFLib.OperationName(operation) {
        return String(cString: nm)
      } else {
        return nil
      }//end if
    }//end var

    /// get operation type
    public var `type`: String? {
      if let tp = TFLib.OperationOpType(operation) {
        return String(cString: tp)
      } else {
        return nil
      }//end if
    }//end var

    /// get device type
    public var device: String {
      if let dev = TFLib.OperationDevice(operation) {
        return String(cString: dev)
      } else {
        return ""
      }//end if
    }//end var

    public var description: String {
      let tp = type ?? ""
      let nm = name ?? ""
      let dev = device
      let ni =  numberOfInputs
      let no = numberOfOutputs
      return "Operation: {type = \(tp), name = \(nm), device = \(dev), input = \(ni), output = \(no)}"
    }

    /// get number of inputs of the operation
    public var numberOfInputs: Int {
      return Int(TFLib.OperationNumInputs(operation))
    }//end var

    /// get number of outputs of the operation
    public var numberOfOutputs: Int {
      return Int(TFLib.OperationNumOutputs(operation))
    }//end var

    /// get type of the input
