         return ComputedArray(shape: shape, baseArray: self)
     }
     
-    /// Reshapes a new DenseArray with the contents of `self` as a vector.
+    /// Returns a new ComputedArray with the contents of `self` as a vector.
     public func ravel() -> ComputedArray<Element> {
-        return allElements.ravel()
+        return ComputedArray(shape: [Int(allElements.count)], baseArray: self)
     }
     
     // TODO: Supporting the full APL-style axes enclose requires support for general dimensional reodering.

        let partialResults = try slice.map { try $0.vectorMap(byRows: rowVector, transform: transform) }
        return ComputedArray(rowVector ? DenseArray(collection: partialResults) : DenseArray(collectionOnLastAxis: partialResults))
    }

    /// Returns a sequence containing pairs of cartesian indices and `Element`s.
    public func coordinate() -> AnySequence<([Int], Element)> {
        let indexGenerator = makeRowMajorIndexGenerator(shape)

            return internalIndices
        }
        
        return ComputedArray(shape: newShape, linear: { ComputedArray(self[internalIndicesList[$0]]) })
    }
    
    /// Reverse the order of Elements along the last axis (columns).
    public func reverse() -> ComputedArray<Element> {
        return self.vectorMap(byRows: true, transform: { $0.reverse() } )
    }
    
    /// Reverse the order of Elements along the first axis.
    public func flip() -> ComputedArray<Element> {
        return self.vectorMap(byRows: false, transform: { $0.reverse() } )
    }
    
    /// Returns a ComputedArray whose dimensions are reversed.
    public func transpose() -> ComputedArray<Element> {
        return ComputedArray(shape: shape.reverse(), cartesian: {indices in
            self[indices.reverse()]
        })
    }
    
    /// Returns a DenseArray with the contents of additionalItems appended to the last axis of the Array.
