001/* 002 * Copyright 2006 - 2013 003 * Stefan Balev <stefan.balev@graphstream-project.org> 004 * Julien Baudry <julien.baudry@graphstream-project.org> 005 * Antoine Dutot <antoine.dutot@graphstream-project.org> 006 * Yoann Pigné <yoann.pigne@graphstream-project.org> 007 * Guilhelm Savin <guilhelm.savin@graphstream-project.org> 008 * 009 * This file is part of GraphStream <http://graphstream-project.org>. 010 * 011 * GraphStream is a library whose purpose is to handle static or dynamic 012 * graph, create them from scratch, file or any source and display them. 013 * 014 * This program is free software distributed under the terms of two licenses, the 015 * CeCILL-C license that fits European law, and the GNU Lesser General Public 016 * License. You can use, modify and/ or redistribute the software under the terms 017 * of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following 018 * URL <http://www.cecill.info> or under the terms of the GNU LGPL as published by 019 * the Free Software Foundation, either version 3 of the License, or (at your 020 * option) any later version. 021 * 022 * This program is distributed in the hope that it will be useful, but WITHOUT ANY 023 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A 024 * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. 025 * 026 * You should have received a copy of the GNU Lesser General Public License 027 * along with this program. If not, see <http://www.gnu.org/licenses/>. 028 * 029 * The fact that you are presently reading this means that you have had 030 * knowledge of the CeCILL-C and LGPL licenses and that you accept their terms. 031 */ 032package org.graphstream.algorithm.flow; 033 034import org.graphstream.algorithm.Algorithm; 035import org.graphstream.graph.Graph; 036import org.graphstream.graph.Node; 037 038/** 039 * Defines algorithm used to compute maximum flow. 040 */ 041public interface FlowAlgorithm extends Algorithm { 042 /** 043 * Get flow value of edge (u,v). 044 * 045 * @param u 046 * @param v 047 * @return flow of (u,v) 048 */ 049 double getFlow(Node u, Node v); 050 051 /** 052 * Set flow of edge (u,v). 053 * 054 * @param u 055 * @param v 056 * @param flow 057 * new flow 058 */ 059 void setFlow(Node u, Node v, double flow); 060 061 /** 062 * Get capacity of edge (u,v). 063 * 064 * @param u 065 * @param v 066 * @return capacity of (u,v)s 067 */ 068 double getCapacity(Node u, Node v); 069 070 /** 071 * Set capacity of (u,v). Capacities should be set between calls to 072 * {@link #init(Graph, String, String)} and {@link #compute()}. 073 * 074 * @param u 075 * @param v 076 * @param capacity 077 * new capacity of (u,v) 078 */ 079 void setCapacity(Node u, Node v, double capacity); 080 081 /** 082 * Set the key of the attribute from which capacities will be loaded. 083 * Attribute values of edge (u,v) should be an array of double where first 084 * element is the value of the capacity of (u,v) and second the capacity of 085 * (v,u). If there is only one value, the value of (v,u) will be zero. If no 086 * value is available, both capacities will be zero. 087 * 088 * If capacity attribute is null, you have to set capacities before calling 089 * {@link #compute()}. 090 * 091 * @param attribute 092 */ 093 void setCapacityAttribute(String attribute); 094 095 /** 096 * Get the key attribute from which capacities are loaded. 097 * 098 * @see #setCapacityAttribute(String) 099 * @return key attribute of capacities 100 */ 101 String getCapacityAttribute(); 102 103 /** 104 * Get maximum flow compute by {@link #compute()}. 105 * 106 * @return maximum flow 107 */ 108 double getMaximumFlow(); 109 110 /** 111 * Get id of the source. 112 * 113 * @return id of the source 114 */ 115 String getFlowSourceId(); 116 117 /** 118 * Get id of the sink. 119 * 120 * @return id of the sink 121 */ 122 String getFlowSinkId(); 123 124 /** 125 * Init the algorithm. This method replaces the {@link #init(Graph)} method 126 * of Algorithm so users just have to call this new method. 127 * 128 * @param g 129 * graph that should be used by the algorithm 130 * @param sourceId 131 * id of the source of the flow 132 * @param sinkId 133 * id of the sink of the flow 134 */ 135 void init(Graph g, String sourceId, String sinkId); 136}