Vogel's approximation method: Difference between revisions

* [[Transportation_problem|Transportation problem]]

 

 

=={{header|C}}==

{{trans|Kotlin}}

#include <limits.h>

 

printf("\nTotal cost = %d\n", total_cost);

return 0;

 

{{output}}

 

If the program is changed to this (to accomodate the second Ruby example):

#include <limits.h>

printf("\nTotal cost = %d\n", total_cost);

return 0;

 

then the output, which agrees with the Phix output but not with the Ruby output itself is:

Total cost = 60748

</pre>

 

=={{header|D}}==

Strongly typed version (but K is not divided in Task and Contractor types to keep code simpler).

{{trans|Python}}

import std.stdio, std.string, std.algorithm, std.range;

 

supply = [W: 50, X: 60, Y: 50, Z: 50];

 

auto res = costs.byKey.zip((int[K]).init.repeat).assocArray;

K[][K] g;

}

writeln("\nTotal Cost = ", cost);

{{out}}

 

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

}

fmt.Println("\nTotal cost =", totalCost)

 

{{out}}

 

If the program is changed as follows to accomodate the second Ruby example:

 

import (

}

fmt.Println("\nTotal cost =", totalCost)

 

then the output, which agrees with the C and Phix output but not with the Ruby output itself, is:

Implementation:

 

:

exceeding=. 0 <. -&(+/)

end.

_1 _1 }. R

 

Note that for our penalty we are using the difference between the two smallest relevant costs multiplied by 1 larger than the highest represented cost and we subtract from that multiple the smallest relevant cost. This gives us the tiebreaker mechanism currently specified for this task.

Task example:

 

src=: 50 60 50 50

cost=: 16 16 13 22 17,14 14 13 19 15,19 19 20 23 50,:50 12 50 15 11

30 0 20 0 10

0 20 0 30 0

 

=={{header|Java}}==

{{works with|Java|8}}

import static java.util.Arrays.stream;

import java.util.concurrent.*;

return isRow ? new int[]{pm, pc, mc, md} : new int[]{pc, pm, mc, md};

}

 

<pre>[0, 0, 50, 0, 0]

 

<code>Resource</code> stores the currently available quantity of a given supply or demand as well as its penalty, cost, and some meta-data. <code>isavailable</code> indicates whether any of the given resource remains. <code>isless</code> is designed to make the currently most usable resource appear as a maximum compared to other resources.

immutable TProblem{T<:Integer,U<:String}

sd::Array{Array{T,1},1}

isavailable(r::Resource) = 0 < r.quant

Base.isless(a::Resource, b::Resource) = a.p < b.p || (a.p == b.p && b.q < a.q)

 

'''Functions'''

 

<code>vogel</code> implements Vogel's approximation method on a <code>TProblem</code>. It is somewhat straightforward, given the types and <code>penalize!</code>.

function penalize!{T<:Integer,U<:String}(sd::Array{Array{Resource{T},1},1},

tp::TProblem{T,U})

return sol

end

 

'''Main'''

 

sup = [50, 60, 50, 50]

end

println("The total cost is: ", cost)

 

{{out}}

=={{header|Kotlin}}==

{{trans|Java}}

 

val supply = intArrayOf(50, 60, 50, 50)

}

println("\nTotal Cost = $totalCost")

 

{{out}}

</pre>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

}

{{out}}

 

 

=={{header|Phix}}==

{{trans|YaBasic}}

{{trans|Go}}

{{out}}

<pre>

</pre>

Using the sample from Ruby:

{{Out}}

Note this agrees with C and Go but not Ruby

=={{header|Python}}==

{{trans|Ruby}}

 

costs = {'W': {'A': 16, 'B': 16, 'C': 13, 'D': 22, 'E': 17},

print "\t",

print

{{out}}

<pre> A B C D E

somehow at the same total cost!

 

(define-values (1st 2nd 3rd) (values first second third))

 

(DEMAND (hash 'A 30 'B 20 'C 70 'D 30 'E 60))

(SUPPLY (hash 'W 50 'X 60 'Y 50 'Z 50)))

 

{{out}}

 

Total Cost: 3100</pre>

 

=={{header|Ruby}}==

Breaks ties using lowest cost cell.

===Task Example===

#

# Nigel_Galloway

puts

end

{{out}}

<pre>

===Reference Example===

Replacing the data in the Task Example with:

S2: {D1: 12, D2: 75, D3: 6, D4: 36, D5: 48},

S3: {D1: 35, D2: 199, D3: 4, D4: 5, D5: 71},

S5: {D1: 85, D2: 60, D3: 14, D4: 25, D5: 79}}

demand = {D1: 278, D2: 60, D3: 461, D4: 116, D5: 1060}

Produces:

<pre>

=={{header|Sidef}}==

{{trans|Ruby}}

W => :(A => 16, B => 16, C => 13, D => 22, E => 17),

X => :(A => 14, B => 14, C => 13, D => 19, E => 15),

}

 

{{out}}

<pre>

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

 

# A sort that works by sorting by an auxiliary key computed by a lambda term

}

return $res

Demonstration:

W {A 16 B 16 C 13 D 22 E 17}

X {A 14 B 14 C 13 D 19 E 15}

}] \t]

}

{{out}}

<pre>

Y 20 30

Z 50

 

Total Cost = 3100

=={{header|Yabasic}}==

{{trans|C}}

N_ROWS = 4 : N_COLS = 5

print

next i

 

=={{header|zkl}}==

{{trans|Python}}{{trans|Ruby}}

"W",Dictionary("A",16, "B",16, "C",13, "D",22, "E",17),

"X",Dictionary("A",14, "B",14, "C",13, "D",19, "E",15),

"Z",Dictionary("A",50, "B",12, "C",50, "D",15, "E",11)).makeReadOnly();

demand:=Dictionary("A",30, "B",20, "C",70, "D",30, "E",60); // gonna be modified

res :=vogel(costs,supply,demand);

cost:=0;

println();

}

// a Dictionary can be created via a list of (k,v) pairs

res:= Dictionary(costs.pump(List,fcn([(k,_)]){ return(k,D()) }));

}//while

res

{{out}}

<pre>