   share an edge if they share an object.
   The edges of the graph have no direction, therefore just the upper
   entrys a_ij with i<=j have to be stored"
-  [context]
+  ^"[[I"[context]
   (let [attribute-derivations-of-context (mapv
                                            #(attribute-derivation context #{%})
                                            (attributes context))
         n (count attribute-derivations-of-context)]
-    (mapv
-      #(compute-row-for-object-or-attribute-matrix
-         (nth attribute-derivations-of-context %)
-         (drop % attribute-derivations-of-context))
-      (range 0 n))))
+    (into-array (map int-array (map
+                                 #(compute-row-for-object-or-attribute-matrix
+                                    (nth attribute-derivations-of-context %)
+                                    (drop % attribute-derivations-of-context))
+                                 (range 0 n))))))
 
 ;;; Functions to compute adjacency-maps.
 ;;; The following functions take a context as argument and return

  objects share an edge if they share an attribute.
  The edges of the graph have no direction, therefore just
  the upper entrys a_ij with i<=j have to be stored."
  [context]
  (let [object-derivations-of-context (mapv
                                        #(object-derivation context #{%})
                                        (objects context))
        n (count object-derivations-of-context)]
    (mapv
      #(compute-row-for-object-or-attribute-matrix
         (nth object-derivations-of-context %)
         (drop % object-derivations-of-context))
      (range 0 n))))

(defn attribute-projection-adjacency-matrix
  "Computes the adjacency-matrix for the graph, which has

  in the graph, nil is returned."
  [context projection]
  (assert (context? context) "Argument is not a formal context!")
  (let [^"[[I" matrix (projection context)
        n (count matrix)
        paths (do
                (dorun
                  (for [k (range 0 n) i (range 0 n) j (range i n)]
                    (floyd-step matrix k i j)))
                (remove zero?
                        (mapcat #(drop 1 %)
                                matrix)))]
    (if (empty? paths)
      nil
      (/ (reduce + paths) (count paths)))))
