Курсовой проект - Транспортная задача по критериям времени и стоимости. Вариант 3.5

6. Листинг фрагмента программы, реализующего алгоритм решения

задачи

module Prog where

import GHC.Ptr

import Maybe

import BaseOperations

import Foreign.C

import Foreign.Marshal.Array

foreign export ccall "getplan" getPlan :: CInt → CInt → CInt → Ptr CInt → IO

(Ptr CFloat)

getPlan :: CInt → CInt → CInt → Ptr CInt → IO (Ptr CFloat)

getPlan rC cC eC ptr

= do

aData ← peekArray (fromIntegral eC) ptr

let rCount = fromIntegral rC

cCount = fromIntegral cC

cData = map fromIntegral aData

a = take rCount cData

b = take cCount ◊ drop rCount cData

tT = take (rCount*cCount) ◊ drop (rCount+cCount) cData

cT = drop (rCount*cCount+rCount+cCount) cData

t = [[ tT !! (i*cCount + j) |

j ← [0 cCount-1] ] | ‥

i ← [0 rCount-1] ] ‥

c = [[ cT !! (i*cCount + j) |

j ← [0 cCount-1] ] | ‥

i ← [0 rCount-1] ] ‥

-- Проверка баланса и добавление фиктивного пункта

mx = checkForClosing a b

aV = getAddedVector a b

mColCount = if aV ≡ 2

then (cCount + 1)

else cCount

mRowCount = if aV ≡ 1

then (rCount + 1)

else rCount

-- Строим опорнный план

basePlan = northWesternCorner (fst mx) (snd mx) 1

prd = 2 * sum [ t !! i !! j | i ← [0 rCount-1], j ← [0 cCount-1]] ‥ ‥

maxi = maximum [ t !! i !! j |

i ← [0 rCount-1], j ← [0 cCount-1], (basePlan !! (i*cCount + j))‥ ‥

≠ 0]

-- Избавляемся от вырожденности.

lNDPlan = makeNonDegeneratePlan basePlan mColCount

-- Находим оптимальный план по критерию времени.

ans = addConditions lNDPlan t mRowCount mColCount rCount cCount aV maxi

[]

optimPlan = last ◊ fst ◊ fst ◊ last ◊ init ans

-- Находим максимальноое время перевозки

maxT = maximum [ t !! ((fst ◊ fst el) - 1) !! ((snd ◊ fst el) - 1)|

el ← optimPlan,

(snd el ≥ 0.9) &&

(((aV ≡ 1 ) ((fst ◊ fst el) ≠ mRowCount)) || ∧

((aV ≡ 2 ) ((snd ◊ fst el) ≠ mColCount)) || ∧

(aV ≡ 3 )) ]

cM = 2 * sum [ c !! i !! j | i ← [0 rCount-1], j ← [0 cCount-1]] ‥ ‥

-- Блокируем

c1 = [[(case aV of

1 → if i ≡ mRowCount - 1

then cM

else (if (t !! i !! j) > maxT

11

then cM

else c !! i !! j)

2 → if j ≡ mColCount - 1

then cM

else (if (t !! i !! j) > maxT

then cM

else (c !! i !! j))

3 → (if (t !! i !! j) > maxT

then cM

else (c !! i !! j))) |

j ← [0 mColCount-1] ] | ‥

i ← [0 mRowCount-1] ] ‥

nonDPlan = listToArrayList lNDPlan mColCount

-- Потенциалы и оценочная матрица

rt = potentials c1 (map snd optimPlan) ([(0,0)],[])

c0 = [[ (c1 !! i !! j) - ((fromJust ◊ lookup j ◊ snd rt) - (fromJust ◊

lookup i ◊ fst rt)) |

j ← [0 mColCount-1] ] | ‥

i ← [0 mRowCount-1] ] ‥

fstSum = sum ◊ zipWith (*) (mkNonClsdPlan optimPlan mColCount aV) ◊

concat c

-- Находим план, дооптимизированный по стоимости.

pl = if null [ minimum i | i ← c0, (minimum i) < 0 ]

then (([optimPlan,optimPlan], [c1,c0]),([maxT,maxT],[fstSum,fstSum])

)

else

let newStepsPlan = fst ◊ mkNewPlan c0 optimPlan mRowCount mColCount

sndSum = sum ◊ zipWith (*) (mkNonClsdPlan newStepsPlan mColCount

aV) ◊ concat c

maximm = maximum [ t !! i !! j |

i ← [0 rCount-1], j ← [0 cCount-1], ‥ ‥

(snd (newStepsPlan !! (i*cCount + j))) ≠ 0]

in (potentialsMethod t (mkNonClsdPlan2 c1 aV) ([maxT,maxT,maximm],

[fstSum,sndSum,sndSum])

mColCount aV False [optimPlan,optimPlan,newStepsPlan]

[c1,c0])

parameters = [mRowCount, mColCount, 1 + length ans] [ length ◊ fst ◊⊕

fst el | el ← ans ]

[fromIntegral ◊ length ◊ fst ◊ fst pl] ⊕

pr ← newArray ([ fromIntegral i | i ← parameters ]

(concat [[ fromRational ◊ toRational el | ⊕

el ← map snd (concat ◊ fst ◊ fst et)] ++

(map fromIntegral ◊ concat ◊ concat ◊ snd ◊ fst et) |

et ← ans])

( [ fromRational ◊ toRational el | ⊕

el ← map snd (concat ◊ fst ◊ fst pl)] ++

(map fromIntegral ◊ concat ◊ concat ◊ snd ◊ fst pl))

---et ← ans])

(map fromIntegral ◊ concat [fst ◊ snd et | et ← ans]) ⊕

(map fromIntegral ◊ concat [snd ◊ snd et | et ← ans]) ⊕

(map fromIntegral ◊ fst ◊ snd pl) ⊕

(map fromIntegral ◊ snd ◊ snd pl)) ⊕

return pr

module BaseOperations where

import List

import Maybe

type Plan = [((Int, Int), Float)]

type Ansset = (([Plan],[[[Int]]]),([Int],[Int]))

addConditions :: [Float] → [[Int]] → Int → Int → Int → Int → Int → Int →

[Ansset] → [Ansset]

addConditions plan t mRC mCC rC cC aV maxi dec = (

12

-- blok - Значение, которым будем блокировать перевозки.

let blok = 5 * sum [ t !! i !! j | i ← [0 rC-1], j ← [0 cC-1]] ‥ ‥

-- Блокируем в матрице временных затрат те элементы,

-- которые больше максимального времени перевозок, соответсвующего

опорному плану, или равны ему.

tBl = [[(case aV of

1 → (if (i ≡ mRC - 1) ((t !! i !! j) ≥ maxi) ∨

then blok

else t !! i !! j)

2 → (if (j ≡ mCC - 1) ((t !! i !! j) ≥ maxi) ∨

then blok

else (t !! i !! j))

3 → (if (t !! i !! j) ≥ maxi

then blok

else (t !! i !! j))) |

j ← [0 mCC-1] ] | ‥

i ← [0 mRC-1] ] ‥

--sumNew = sum ◊ zipWith (*) (map round plan) ◊ concat t

nonClosedModelTime = (case aV of

1 → listToArrayList (concat ◊ init tBl) mCC

2 → listToArrayList (concat ◊ [ init i | i ← tBl ]) (mCC-1)

3 → listToArrayList (concat ◊ tBl) mCC)

nonDPlan = listToArrayList plan mCC

-- Вычисляем потенциалы

pts = potentials tBl plan ([(0,0)],[])

-- Рассчитываем матрицу T1

t1 = [[ (tBl !! i !! j) - ((fromJust ◊ lookup j ◊ snd pts) - (fromJust

◊ lookup i ◊ fst pts)) |

j ← [0 mCC-1] ] | ‥

i ← [0 mRC-1] ] ‥

fstSum = sum ◊ zipWith (*) (mkNonClsdPlan nonDPlan mCC aV) ◊ concat t

-- Проверяем на наличие отрицательных элементов в T1

in if null [ minimum i | i ← t1, (minimum i) < 0 ]

then

-- Если нету, то выдаем ответ.

if null dec

then [(([nonDPlan,nonDPlan], [tBl,t1]), ([maxi,maxi],[fstSum,fstSum]))]

else dec {-++ [([nonDPlan], [t1 [[maxi]]])]-} ⊕

-- Иначе строим новый, улучшенный план.

else (let newStepsPlan = fst ◊ mkNewPlan t1 nonDPlan mRC mCC

-- После предварительного этапа и первой итерации приступаем к следующим

итеррациям и находим

-- оптимальный план при данных условиях.

planT = mkNonClsdPlan newStepsPlan mCC aV

maximm = maximum [ t !! i !! j |

i ← [0 rC-1], j ← [0 cC-1], (planT !! (i*cC + j)) ≠ 0] ‥ ‥

sndSum = sum ◊ zipWith (*) (mkNonClsdPlan newStepsPlan mCC aV) ◊

concat ◊ mkNonClsdPlan2 tBl aV

decision = potentialsMethod (mkNonClsdPlan2 tBl aV) []

([maxi,maxi,maximm],[fstSum,fstSum,sndSum]) mCC aV True

[nonDPlan, nonDPlan, newStepsPlan] [tBl, t1]

pl = last ◊ fst ◊ fst decision

-- Убираем из оптимального плана добавленную при переходе к закрытой модели

строку или столбец,

-- если модель была открытой.

newPlan = mkNonClsdPlan pl mCC aV

newPlan1 = mkNonClsdPlan1 pl mCC aV

in if or

[(fst el) `elem` (map fst ◊ filter ( λa → snd a≥ 0.9) newPlan1) |

el ← (filter (λa → snd a > (blok `div` 2)) nonClosedModelTime) ]

then dec [decision] ⊕

else addConditions plan t mRC mCC rC cC aV

(maximum [ t !! i !! j |

i ← [0 rC-1], j ← [0 cC-1], newPlan !! (i*cC + j) > 0 ]) ‥ ‥

(dec [decision]))) ⊕

mkNonClsdPlan :: Plan → Int → Int → [Int]

mkNonClsdPlan plan mCC addV =

13

let mRC = (length plan) `div` mCC

in (case addV of

1 → map (round snd) ◊ take ((mRC-1)*mCC) plan ∘

2 → map (round snd) ◊ concat [ init ◊ drop ((i-1)*mCC) ◊ take∘

(i*mCC) plan | i ← [1 mRC] ] ‥

3 → map (round snd) plan) ∘

mkNonClsdPlan2 :: [[a]] → Int → [[a]]

mkNonClsdPlan2 plan addV =

(case addV of

1 → init plan

2 → map init plan

3 → plan)

mkNonClsdPlan1 :: [a] → Int → Int → [a]

mkNonClsdPlan1 plan mCC addV =

let mRC = (length plan) `div` mCC

in (case addV of

1 → take ((mRC-1)*mCC) plan

2 → concat [ init ◊ drop ((i-1)*mCC) ◊ take (i*mCC) plan | i ← [1‥

mRC] ]

3 → plan)

mkNewPlan :: [[Int]] → Plan → Int → Int → (Plan, Int)

mkNewPlan t1 nonDPlan mRC mCC =

let minEl = minimum [ minimum i | i ← t1, (minimum i) < 0 ]

rowOfMinEl = head [ i |

i ← [1 length t1], ‥

(findIndex (≡ minEl) (t1 !! (i-1))) ≠ Nothing ]

colOfMinEl = 1 + fromJust (findIndex (≡ minEl) (t1 !!

(rowOfMinEl-1)))

-- Далее находим подматрицу в опорном плане, содержащую цикл, и число

колонок в этой подматрице.

mCycle = findCycle rowOfMinEl colOfMinEl mCC 1 nonDPlan

mCol = length ◊ filter (≡(fst ◊ fst ◊ head mCycle)) ◊ map

(fst fst) mCycle ∘

-- Находим номер нулевого элемента плана, который соотетствует минимальному

отрицательному марицы T1

indexX = fromJust ◊ findIndex (≡((rowOfMinEl, colOfMinEl), 0.0))

mCycle

-- Составляем цикл

cy = getCycle ((indexX `div` mCol)+1) ((indexX `mod` mCol)+1)

mCol mCycle

-- Находим минимальный нечетный элемент

cymin = minimum [ snd (cy !! (i-1)) | i ← [1 length cy], even ‥

i]

-- Отнимаем его из нечётных, и прибавляем к чsum ◊ zipWith (*) plan ◊

concat tbaseётным

tempCycle = [ if even i

then (fst (cy !! (i-1)), snd (cy !! (i-1)) - cymin)

else (fst (cy !! (i-1)), snd (cy !! (i-1)) + cymin) | i ←

[1 length cy] ] ‥

-- Находим в преобразованном цикле нулевые элементы

zeroMass = [ fst ◊ (tempCycle !! (i-1)) |

i ← [1 length tempCycle], ‥

(even i) (snd (tempCycle !! (i-1)) ≡ 0) ] ∧

-- Если число нулевых елементов больше 1, то заменяем все , кроме одного, на

0.0001

modifiedCycle = if (length zeroMass) > 1

then [ if(findIndex (≡(fst (tempCycle !! (i-1)))) ◊ tail

zeroMass) ≠ Nothing

then ((fst (tempCycle !! (i-1))), 0.000001)

else tempCycle !! (i-1) | i ← [1 length tempCycle]] ‥

else tempCycle

-- Записываем полученную цепочку в матрицу опроного плана вместо

первоначальных значений.

in ([ (if (lookup (i+1,j+1) modifiedCycle) ≠ Nothing

14

then ((i+1,j+1), fromJust (lookup (i+1,j+1) modifiedCycle))

else (nonDPlan !! (i*mCC + j))) |

i ← [0 mRC-1], j ← [0 mCC-1] ], minEl * round ‥ ‥

cymin)

potentialsMethod :: [[Int]] → [[Int]] → ([Int],[Int]) → Int → Int → Bool →

[Plan] → [[[Int]]] → Ansset

potentialsMethod tbase cbase sm colCount aV byTime x1 t1 =

let x = last x1

t = last t1

significantIndices = [ fst i |

i ← x,

(snd i ≠ 0) ((t !! ((fst ◊ fst i)-1) !! ((snd ◊ fst i)-1)) ≡ 0) ] ∧

minEl = minimum [ minimum i | i ← t ]

rowOfMinEl = head [ i |

i ← [1 length t], ‥

(findIndex (≡ minEl) (t !! (i-1))) ≠ Nothing ]

newT = processMarkedRnC

(getMarkedRowsNColoumns [(1, rowOfMinEl)] significantIndices)

minEl

t

rowCount = (length x) `div` colCount

in if null [filter (<0) i | i ← newT, ¬ (null (filter (<0) i)) ]

then ((x1, t1 [newT]), sm) ⊕

else let newX = mkNewPlan newT x rowCount colCount

plan = mkNonClsdPlan (fst newX) colCount aV

calcMax = maximum [ tbase !! i !! j |

i ← [0 (length tbase)-1], j ← [0 (length ◊ head ‥ ‥

tbase)-1],

(plan !! (i*(length ◊ head tbase) + j)) ≠ 0]

calcSum = if byTime

then sum ◊ zipWith (*) plan ◊ concat tbase

else sum ◊ zipWith (*) plan ◊ concat cbase

in if(calcSum ≡ (last ◊ snd sm) + (snd newX))

then potentialsMethod tbase cbase

((fst sm) [calcMax],(snd sm) [calcSum]) ⊕ ⊕

colCount aV byTime (x1 [fst ◊ newX]) (t1 [newT]) ⊕ ⊕

else error ("potentialsMethod: error!! " (show ◊ length x1)) ⊕

-- | Функция прибавляет модуль минимального отрицательного элемента ко всем

строкам

-- и отнимает из столбцов матрицы Ti

processMarkedRnC :: [(Int, Int)] → Int → [[Int]] → [[Int]]

processMarkedRnC indices mint t =

let isRow = fst ◊ head indices

vecNumber = snd ◊ head indices

in if null indices

then t

else if isRow ≡ 1

then processMarkedRnC (tail indices) mint

[ if i ≡ vecNumber

then map (+(- mint)) (t !! (i-1))

else t !! (i-1) |

i ← [1 length t] ] ‥

else processMarkedRnC (tail indices) mint

[[ if j ≡ vecNumber

then (t !! (i-1) !! (j-1)) + mint

else (t !! (i-1) !! (j-1))

| j ← [1 length ◊ head t] ] | ‥

i ← [1 length t] ] ‥

-- | Функция ищет по списку индексов существенных нулей те строки и столбцы, к

элементам

-- которых нужно соотвеветсвенно добавить или отнять модуль минимального

-- отрицательного элемента матрицы времени (стоимости).

getMarkedRowsNColoumns :: [(Int,Int)] → [(Int,Int)] → [(Int,Int)]

15

getMarkedRowsNColoumns indices arr =

let indicesGroup = last ◊ groupBy (λa b → (fst a ≡ fst b)) indices

newEl = if (fst ◊ head indicesGroup) ≡ 1

then [ (2, snd j) |

i ← indicesGroup,

j ← arr,

(snd i ≡ fst j) ¬ ((2, snd j) `elem` indices) ] ∧

else [ (1, fst j) |

i ← indicesGroup,

j ← arr,

(snd i ≡ snd j) ¬ ((1, fst j) `elem` indices) ] ∧

in if null newEl

then indices

else getMarkedRowsNColoumns (indices newEl) arr ⊕

-- | Фукнция находит в плане X подматрицу, которая содержит цикл.

findCycle :: Int → Int → Int → Int → Plan → Plan

findCycle i j colCount counter plan

| colCount < 1 = []

| counter > (colCount + (length plan) `div` colCount) = plan

| otherwise =

let rowCount = (length plan) `div` colCount

rowMass = [ fst ◊ fst ◊ (plan !! (n*colCount)) |

n ← [0 rowCount-1] ] ‥

colMass = map (snd fst) ◊ drop ((rowCount - 1) * colCount) plan ∘

in (if counter ≤ rowCount

then

-- Образуем список из ненулевых элементов текущей строки, и

проверяем его длину.

(if (length [ plan !! ((counter-1)*colCount + m) |

m ← [0 colCount-1], ‥

let curRow = rowMass !! (counter-1),

let curCol = colMass !! m,

((fromJust ◊ lookup (curRow, curCol) plan) ≠ 0) ||

((curRow ≡ i ) (curCol ≡ j))]) > 1 ∧

then findCycle i j colCount (counter + 1) plan

-- Если в строке не больше одного ненулевего элемента, то

удаляем строку.

else findCycle i j colCount 1 [ plan !! ((n-1)*colCount + (m-1))

|

n ← [1 rowCount], ‥

m ← [1 colCount], ‥

n ≠ counter])

else

-- Образуем список из ненулевых элементов текущего столбца, и

проверяем его длину.

(if (length [ plan !! (n*colCount + (counter - rowCount) - 1)

|

n ← [0 rowCount-1], ‥

let curRow = rowMass !! n,

let curCol = colMass !! (counter - rowCount - 1) ,

((fromJust ◊ lookup (curRow, curCol) plan) ≠ 0) ||

((curRow ≡ i) (curCol ≡ j))]) > 1 ∧

then findCycle i j colCount (counter + 1) plan

-- Если в солбце не больше одного ненулевего элемента, то

удаляем столбец.

else findCycle i j (colCount - 1) 1 [ plan !! ((n-1)*colCount +

(m-1)) |

n ← [1 rowCount], ‥

m ← [1 colCount], ‥

m ≠ (counter - rowCount)]))

listToArrayList :: [a] → Int → [((Int, Int), a)]

listToArrayList t colCount = [((i, j), (t !!((i-1)*colCount + j - 1))) |

i ← [1 ((length t) `div` colCount)], j ← [1 colCount]] ‥ ‥

16

-- | Функция рассчитывает потенциалы для опорного плана basePlan и матрицы

временных затрат t.

-- Возвращает пару списков: первый содержит вектор U, второй - V.

potentials :: [[Int]] → [Float] → ([(Int, Int)], [(Int, Int)]) → ([(Int,

Int)], [(Int, Int)])

potentials t basePlan pt =

let rC = (length t)

cC = (length ◊ head t)

in if ((length ◊ fst pt) ≥ rC) ((length ◊ snd pt) ≥ cC) ∧

then pt

else potentials t basePlan

((fst pt) [(n, (snd el) - t !! n !! (fst el) ) | ⊕

el ← snd pt,

n ← [0 rC-1], ‥

((last ◊ take ((fst el)+1) ◊ drop (n*cC) basePlan) ≠ 0.0) ∧

((lookup n ◊ fst pt) ≡ Nothing) ],

(snd pt) [(m, (snd el) + t !! (fst el) !! m) | ⊕

m ← [0 cC-1], ‥

el ← fst pt,

((last ◊ take (m+1) ◊ drop ((fst el)*cC) basePlan) ≠ 0.0) ∧

((lookup m ◊ snd pt) ≡ Nothing) ])

-- | Функция проверяет модель и (если нужно) добавляет фиктивный пункт

потребления или производства.

checkForClosing :: [Int] → [Int] → ([Int], [Int])

checkForClosing _ [] = error "checkForClosing: Can't process an empty list!"

checkForClosing [] _ = error "checkForClosing: Can't process an empty list!"

checkForClosing a b

| (sum a) ≡ (sum b) = (a, b)

| (sum a) > (sum b) = (a, b [sum a - sum b]) ⊕

| otherwise = (a [sum b - sum a], b) ⊕

getAddedVector :: [Int] → [Int] → Int

getAddedVector _ [] = error "getAddedVector: Can't process an empty list!"

getAddedVector [] _ = error "getAddedVector: Can't process an empty list!"

getAddedVector a b

| (sum a) < (sum b) = 1

| (sum a) > (sum b) = 2

| otherwise = 3

-- | Функция, реализующая метод северозападного угла, для построения опорного

плана.

northWesternCorner :: [Int] → [Int] → Int → [Int]

northWesternCorner [] _ _ = error "northWesternCorner: Can't process an empty

list!"

northWesternCorner _ [] _ = error "northWesternCorner: Can't process an empty

list!"

northWesternCorner a b c

| c > ((length a) * (length b)) = []

| otherwise = [me] northWesternCorner ⊕

((take ((c - 1) `div` (length b)) a) [ca - me] (drop (((c - 1)⊕ ⊕

`div` (length b)) + 1) a))

((take ((c - 1) `mod` (length b)) b) [cb - me] (drop (((c - 1)⊕ ⊕

`mod` (length b)) + 1) b))

(c + 1)

where

ca = a !! ((c - 1) `div` (length b))

cb = b !! ((c - 1) `mod` (length b))

me = min ca cb

-- | Функция, преобразующая вырожденный план в невырожденный.

makeNonDegeneratePlan :: [Int] → Int → [Float]

makeNonDegeneratePlan basePlan cC = [

if (i < ((length basePlan) `div` cC) - 1) (j > 0) && ∧

((basePlan !! (i*cC + j)) ≡ 0) ((basePlan !! ((i + 1)*cC + (j - 1))) ≡∧

0) &&

((basePlan !! (i*cC + (j - 1))) ≠ 0) ((basePlan !! ((i + 1)*cC + j)) ≠∧

0)

17

then 0.000001

else fromInteger ◊ toInteger (basePlan !! (i*cC + j)) |

i ← [0 ((length basePlan) `div` cC)-1], j ← [0 cC-1] ] ‥ ‥

-- | Функция, строящая цепочку из элементов подматрицы текущего плана, которая

содержит цикл.

--

getCycle :: Int -- ↑ i - строка элемента, вводимого в цепочку

→ Int -- ↑ j - столбец элемента, вводимого в цепочку

→ Int -- ↑ сС - количество столбцов подматрицы

→ [((Int, Int), Float)] -- ↑ cycle - подматрица, содержащая цикл

→ [((Int, Int), Float)] -- ↑ возвращается цепочка из не

использованных на текущей

-- и предыдущих итерациях положительных

элементов

getCycle i j cC cycle =

let rC = ((length cycle) `div` cC) - 1

-- Ниже обнуляем текущий элемент цепочки в подматрице (чтобы не обращать больше

на него внимания).

mCycle = [ (if (i ≠ n+1) (j ≠ m+1) ∨

then cycle !! (n*cC + m)

else (fst (cycle !! (n*cC + m)), 0.0)) |

n ← [0 rC], m ← [0 cC-1]] ‥ ‥

-- Ищем индекс ненулевого элемента в той же строке, в которой находится вводимый

в цепочку элемент.

id = (findIndex (>0) [ snd (mCycle !! ((i-1)*cC + m)) | m ← [0 cC-‥

1] ])

-- Проверка на отсутствие элементов, который можно ввести в цепочку

in if (length ◊ filter (>0) ◊ snd ◊ unzip mCycle) ≡ 0

then [cycle !! ((i-1)*cC + j - 1)]

else (if id ≠ Nothing

then [cycle !! ((i-1)*cC + j - 1)] (getCycle i ((fromJust id)+1) ⊕

cC mCycle)

else let idi = findIndex (>0) [ snd (mCycle !! (n*cC + j-1)) | n ←

[0 rC]] ‥

in if idi ≠ Nothing

then ([cycle !! ((i-1)*cC + j-1)] (getCycle ((fromJust idi)⊕

+1) j cC mCycle))

else error "getCycle: no non-zero elements in this row or

coloumn!")

18

7. Руководство пользователя

7.1. Системные требования

Процессор: Pentium I или аналогичный AMD, 400 MHz и выше.

ОЗУ: 64 Мб и более.

ОС: Windows 98, 2000, ХР.

7.2. Описание возможностей

Данная программа предназначена для решения транспортной задачи по

критерию времени вариантом метода потенциалов, при дополнительных

условиях, вводимых последовательно в процесс решения, а также

дооптимизации полученного решения по критерию стоимости.

Производится оптимизация транспортных перевозок, тем самым

сокращаются время перевозок и издержки.

В программе есть "Инженерный" режим работы, с помощью которого

можно просмотреть все этапы вычисления. Этот режим предназначен для

специалистов в данной области.

19

7.3. Основное окно программы

7.4. Главное меню программы

Главное меню программы содержит пункты «Файл», «Режим»,

«Помощь».

В пункте «Файл» находится подпункт «Выход», который используется

для завершения работы программы.

В пункте «Режим» находятся подпункты «Обычный» и

«Инженерный».

20

Курсовой проект - Транспортная задача по критериям времени и стоимости. Вариант 3.5

Подождите немного. Документ загружается.