anchor.diff:              
               let _edges = loop 0 []
               if  _edges = List.empty then None
  -            else Some _edges   
  -    
  -    // Returns the number of edges that originate from the vertex v.
  +            else Some (_edges |> Array.ofList)   
  +    
  +    ///Lookup all edges that originate from the vertex v in the graph, returning an array of connected edges.
  +    member this.GetOutEdges((v:'Vertex)) =
  +        match (this.TryGetOutEdges(v)) with
  +            |Some x -> x
  +            |None   -> [||]
  +    
  +    ///Lookup the weight of the edge defined by source and vertex. If it exists, return Some value, else none.
  +    member this.TryGetWeight((source:'Vertex),(target:'Vertex)) =
  +        match (this.TryGetEdge((source),(target))) with
  +            |Some x -> Some(fun (s, t, w) -> w)
  +            |None   -> None
  +    
  +    ///Return the weight of the edge defined by source and vertex
  +    member this.GetWeight((source:'Vertex),(target:'Vertex)) =
  +        match (this.TryGetEdge((source),(target))) with
  +            |Some x -> (fun (s, t, w) -> w)
  +            |None   -> failwith "No weight found"
  +
  +    ///Set the weight of the LEdge defined by source and vertex to be equal weight.
  +    member this.setWeight((source:'Vertex),(target:'Vertex),(weight:'Edge)) =
  +        let edgeListSource = 
  +            match (Dictionary.tryGetValue source vertexOutEdges) with
  +                | Some x    -> x |> Array.map (fun (s, t, w) -> if t=target then (s, t, weight) else (s, t, w))
  +                | None      -> failwith "The source vertex of the edge does not exist in this graph."
  +                 
  +        let edgeListTarget = 
  +            match (Dictionary.tryGetValue target vertexOutEdges) with
  +                | Some x    -> x |> Array.map (fun (s, t, w) -> if s=source then (s, t, weight) else (s, t, w))
  +                | None      -> failwith "The target vertex of the edge does not exist in this graph."
  +        
  +        vertexOutEdges.Item source <- (edgeListSource)
  +        vertexOutEdges.Item target <- (edgeListTarget)
  +        this
  +
  +    ///Returns the number of edges that originate from the vertex v.
       member this.InDegree((v:'Vertex)) =
           this.TryGetInEdges v
  -        |> Option.map (List.length)
  -    
  -    // Returns the number of edges that target the vertex v.
  +        |> Option.map (Array.length)
  +    
  +    ///Returns the number of edges that target the vertex v.
       member this.OutDegree((v:'Vertex)) =
           this.TryGetOutEdges v
  -        |> Option.map (List.length)
  +        |> Option.map (Array.length)
   
       //member this.OutEdge(v:'Edge, index:int) :LEdge<'Vertex,'Edge>=
       //    vertexOutEdges.[v].[index]
           
  -    // Returns true, since the graph model is always directed.
  +    ///Returns true, since the graph model is always directed.
       member this.IsDirected :bool =
           true
   
  -    // Returns true, since parallel edges are allowed
  +    ///Returns true, since parallel edges are allowed
       member this.AllowParallelEdges :bool =
           true
   
  -    // Returns true, if the graph contains the vertex, else false.
  +    ///Returns true, if the graph contains the vertex, else false.
       member this.ContainsVertex(vertex:'Vertex) :bool =
           vertexOutEdges.ContainsKey(vertex)
   
  -    // Returns true, if there are no vertices in the graph, else false.
  +    ///Returns true, if there are no vertices in the graph, else false.
       member this.IsVerticesEmpty :bool =
           vertexOutEdges.Count = 0
   
  -    // Returns the number of vertices of the graph.
  +    ///Returns the number of vertices of the graph.
       member this.VertexCount :int =
           vertexOutEdges.Count
       
  -    // Returns the vertices of the graph.
  +    ///Returns the vertices of the graph.
       member this.Vertices  =
           //for vertices in vertexOutEdges.Keys do
           let result = Array.zeroCreate vertexOutEdges.Count
  
positive.code:             
              let _edges = loop 0 []
              if  _edges = List.empty then None
              else Some _edges   
      
      // Lookup all edges that originate the vertex v in the graph, returning a Some value if a binding exists and None if not.
      member this.TryGetOutEdges((v:'Vertex)) =
          let tryGetSource = (Dictionary.tryGetValue v vertexOutEdges)
          
  
negative.code:                 if (edges.[i]|>fun (s,t,w) -> t) = target then Some edges.[i]  else loop (i+1)
              loop 0                
      
      ///Return the first edge in the graph that matches the conditions.
      member this.getEdge((source:'Vertex),(target:'Vertex)) :LEdge<'Vertex,'Edge> =
          match (this.TryGetEdge(source,target)) with
              |Some x -> x
              |None   -> failwith "Edge does not exist"
  
      ///Lookup all edges in the graph that matches the conditions, returning a Some value if it exists and None if not.
      member this.TryGetEdges((source:'Vertex),(target:'Vertex)) :LEdge<'Vertex,'Edge> list option=
          let tryGetSource =
              Dictionary.tryGetValue source vertexOutEdges
  