 		resetLazy(src._rows, src._columns)
 	}
 
-	// MARK: プロパティ
+	// MARK: - プロパティ
 
 	public var capacity: Int {
 		return _capacity

		}
	}

	// MARK: 計算
	
	public func fillZero() {
		_FloatBuffer_FillZero(_buffer, Int32(_capacity))

		return _columns
	}

	internal static let ALIGNMENT = 8
	
	internal var _buffer: Pointer
	internal var _rows: Int
	internal var _columns: Int
//	internal var _stride: Int
	internal var _capacity: Int
	internal var _allocationSize: Int
}


// MARK: - Save/Load

extension FloatBuffer {
	
	public convenience init(data: Data) {

		let headerBuffer = UnsafeMutableRawPointer.allocate(bytes: FloatBuffer.HEADERSIZE, alignedTo: FloatBuffer.ALIGNMENT)
		defer {
			headerBuffer.deallocate(bytes: FloatBuffer.HEADERSIZE, alignedTo: FloatBuffer.ALIGNMENT)
		}
		
		data.copyBytes(to: headerBuffer.assumingMemoryBound(to: UInt8.self), count: FloatBuffer.HEADERSIZE)
		
		let rows = headerBuffer.load(as: Int32.self)
		let columns = (headerBuffer + 4).load(as: Int32.self)

		self.init(Int(rows), Int(columns))
		
		
		data.copyBytes(to: UnsafeMutableRawPointer(_buffer).assumingMemoryBound(to: UInt8.self), count: _capacity)
	}

	public convenience init(contentsOf url: URL) throws {
		self.init(data: try Data(contentsOf: url))
	}

	public func write(to path: URL) throws {
		var data = Data(capacity: writeSize())
		write(to: &data)
		try data.write(to: path, options: Data.WritingOptions.atomic)
	}
	
	public func write(to data: inout Data) {
		
		let headerBuffer = UnsafeMutableRawPointer.allocate(bytes: FloatBuffer.HEADERSIZE, alignedTo: FloatBuffer.ALIGNMENT)
		defer {
			headerBuffer.deallocate(bytes: FloatBuffer.HEADERSIZE, alignedTo: FloatBuffer.ALIGNMENT)
		}
		headerBuffer.storeBytes(of: Int32(_rows), as: Int32.self)
		(headerBuffer + 4).storeBytes(of: Int32(_columns), as: Int32.self)
		
		data.append(UnsafeBufferPointer<UInt8>(start: headerBuffer.assumingMemoryBound(to: UInt8.self), count: FloatBuffer.HEADERSIZE))
		data.append(UnsafeBufferPointer<Float>(start: _buffer, count: _capacity))
	}
	
	public func writeSize() -> Int {
		return FloatBuffer.HEADERSIZE + _capacity
	}
	
	internal static let HEADERSIZE = 64

}

extension Data {
	
	init(floatBuffer: FloatBuffer) {
		
		self.init(capacity: floatBuffer.writeSize())
		
		floatBuffer.write(to: &self)
		
	}
	
}

