Информационное обеспечение системы управления подъёмно-транспортным механизмом

Таблица 6.2

Оценка общей напряженности труда разработчика

Согласно алгоритму общей оценки напряженности получаем общую оценку напряженности, равную 3.1, что соответствует вредным условиям труда, обусловленным превышением воздействия вредных факторов гигиенических норм. Такие условия вызывают, как правило, обратимые функциональные изменения и повышают риск развития профзаболеваний.

При анализе таблицы 6.2 рассмотрим факторы с оценкой 3.1 и 3.2 более детально:

- содержание работы (разработка алгоритмов функционирования программного обеспечения и протоколов взаимодействия компонент системы);

- восприятие сигналов (информации) и их оценка (при отладке программы обязательно отслеживание работы программы согласно разработанному алгоритму);

- степень сложности задания (необходимость разработки пакета программ с использованием разнообразных алгоритмов, сложность отладки программы в режиме реального времени работы аппаратуры, сопровождение пакета программ документацией);

- наблюдение за экранами видеотерминалов, количество часов за смену (кроме использования машинного времени для разработки системы, необходимо создание сопроводительной документации к программе, что так же производится с использованием прикладных программных пакетов).

- длительность сосредоточенного наблюдения в % от времени смены (необходимо сосредотачивать внимание в процессе работы, так как допущение даже малого процента ошибок заставляет применять длительную трассировку программ).

6.2. Анализ условий труда разработчика и мероприятия по устранению вредных факторов

Работа с вычислительной техникой по вредности относится к безопасным (риск смерти на человека в год составляет менее 0,001). Тяжесть труда у операторов вычислительной техники также минимальна, так как уровень психической нагрузки по этому роду деятельности предусматривает энергозатраты 2000...2400 ккал в сутки.

Работа за компьютером связана с нагрузками на различные системы организма оператора. Напряженность умственного труда при работе на компьютере связана с функциями центральной нервной системы, предъявляющей особые требования к памяти, мышлению, вниманию человека, а также связана с высокой ответственностью оператора за выполняемую работу. Если оператор слишком долго занят работой за компьютером, то у него появляется нервно-психическое напряжение, а в ряде случаев развивается состояние перенапряжения, которое рассматривается в качестве одной из причин развития невротических нарушений и возникновения сердечно-сосудистой патологии. Постоянное наблюдение за объектами на экране монитора приводит к напряжению органов зрения. Выделяют две причины возникновения этих напряжений: «техническая» и «режимная». Первая связана с особенностями экранного изображения: низкой контрастностью, частыми перепадами яркости и мерцанием экрана. «Режимная» причина обусловлена временем работы за компьютером, то есть длительностью наблюдения или продолжительностью фиксации. Астенопии (от греч. asthenзs - слабый + фps - глаз - слабость или быстрая утомляемость зрения; проявляется болью в глазах, головной болью и снижением остроты зрения) могут отмечаться через 40-45 минут после начала работы за компьютером. Более чем 4-х часовое пребывание у экрана компьютера может привести к кумуляции утомления, о чем свидетельствует нарушение ночного сна у пользователей, которые постоянно работают на компьютере более 4-х часов, по сравнению с лицами, не использующими компьютеров, или при стаже менее двух лет работы на ЭВМ.

Работа с вычислительной техникой связана с необходимостью длительно находиться в вынужденной рабочей позе, что ведет к различным формам заболеваний опорно-двигательного аппарата человека. Отсутствие физической нагрузки и неподвижность - явление не соответствующее естественному (физиологическому) состоянию человека. При этом не стимулируется деятельность внутренних органов, что ведет к застойным явлениям, неблагоприятно отражающимся на общем тонусе организма и психической деятельности. Мониторы являются источниками тепловыделений, которые являются причиной повышения температуры и снижения влажности воздуха на рабочем месте, вызывающих раздражение кожи.

Рассмотрев опасные факторы разработаем, по возможности, методы устранения их вредного влияния. Сразу оговоримся, что такие факторы как содержание работы, восприятие сигналов (информации) и их оценка, степень сложности задания, мы устранить не сможем, так как эти факторы являются неотъемлемой частью данной работы.

Воздействие остальных факторов можно ослабить, если разработать мероприятия по устранению их вредного влияния, которые будут одинаковы как для разработчика, так и для пользователя и которые сводятся к разработке рационального режима труда и отдыха, введением в рабочий график дополнительных перерывов для психологической разрядки и снижения утомляемости зрительного аппарата:

- при восьмичасовом рабочем дне и уровне нагрузки в 5 часов непосредственной работы с терминалами суммарное время регламентированных перерывов должно составлять 70 минут;

- через каждые 15-20 минут следует проводить гимнастику для глаз, через 30-40 минут - комплекс физических упражнений с целью снижения нервно-эмоционального напряжения, утомления зрительного анализатора, устранения влияния гиподинамии (пониженная подвижность вследствие уменьшения силы движений) и гипокинезии (вынужденное уменьшение объема произвольных движений вследствие характера трудовой деятельности - малая подвижность);

- необходимо выдерживать оптимальное расстояние глаз до экрана монитора - 60-70 см;

- регламентированные перерывы следует устанавливать через 1,5-2,0 часа от начала рабочей смены и через 1,5-2,0 часа после обеденного перерыва продолжительностью 20 минут каждый или продолжительностью 15 минут через каждый час работы. Рекомендуется также самостоятельно корректировать длительности перерывов и отдыхов и применять индивидуальный подход в организации времени работы с ЭВМ;

- продолжительность непрерывной работы с видеодисплеями без регламентированного перерыва не должна превышать 2-х часов;

- использовать прямой контраст;

- использовать рассеянный свет;

- экран дисплея располагать ниже уровня глаз с наклоном.

Рассматривая данную работу с точки зрения экологичности можно отметить, что компьютеры являются потенциальными источниками электромагнитных излучений, включая рентгеновское (невидимое излучение, способное проникать, хотя и в разной степени, во все вещества; представляет собой электромагнитное излучение с длиной волны порядка 10-8 см), ультрафиолетовое (источниками УФИ может быть естественное и искусственное освещение), инфракрасное (источником инфракрасного освещения является любое нагретое тело) и ионизирующее (вид излучения, взаимодействие которого со средой приводит к образованию электрических зарядов разных знаков). Электромагнитные излучения воздействуют на сердечно-сосудистую систему и приводят к нарушению эндокринных и обменных процессов. Высокая или низкая температура воздуха также отрицательно сказывается на функциональном состоянии человека.

6.3. Экологичность работы

Излучательные характеристики монитора:

- электромагнитное поле монитора в диапазоне частот 20 Гц- 1000 МГц;

- статический электрический заряд на экране монитора;

- ультрафиолетовое излучение в диапазоне 200- 400 нм;

- инфракрасное излучение в диапазоне 1050 нм- 1 мм;

- рентгеновское излучение > 1,2 кэВ.

6.3.1. Компьютер как источник переменного электромагнитного поля

Основными составляющими частями персонального компьютера являются: системный блок и разнообразные устройства ввода и вывода информации: клавиатура, дисковые накопители, принтер, сканер, и т. п. Каждый персональный компьютер включает средство визуального отображения информации - монитор или дисплей. Персональные компьютеры часто оснащают сетевыми фильтрами, источниками бесперебойного питания и другим вспомогательным электрооборудованием. Все эти элементы при работе персонального компьютера формируют сложную электромагнитную обстановку на рабочем месте пользователя (см. таблицу 6.3).

Таблица 6.3

Персональный компьютер как источник электромагнитного поля

Кроме того, на рабочем месте пользователя источниками более мощными, чем компьютер, могут выступать объекты, неполный перечень которых приведен в таблице 6.4

Таблица 6.4

Внешние источники электромагнитного поля на рабочем месте пользователя ПК

Шведский институт защиты от излучений, разработчик спецификаций стандарта безопасности MPR II, в своем отчете приводит результаты измерений электромагнитного поля 150 моделей мониторов (см. таблицу 6.5)

Таблица 6.5

Максимальные и средние величины электромагнитного излучения по данным Шведского института защиты от излучений

Наличие в помещении нескольких компьютеров со вспомогательной аппаратурой и системой электропитания создает сложную картину электромагнитного поля. Очевидно, что электромагнитная обстановка в помещениях с компьютерами крайне сложная, распределение полей неравномерное, а уровни достаточно высоки, чтобы говорить об опасности их биологического действия.

7. СОЦИАЛЬНАЯ ЗНАЧИМОСТЬ

Данная работа имеет большое социальное значение, так как она призвана существенно облегчить труд большого количества рабочих, занятых в различных сферах производства. Результаты проекта являются практически полезными и могут быть использованы при разработке автоматизированных систем управления подъемно-транспортными механизмами. Задачи, решенные в ходе проектирования, позволят обезопасить труд рабочего персонала, ускорить производственный процесс, сэкономить затраты на обучения операторов, различные ресурсы.

Использование методов нечеткой логики позволяет значительно облегчить разработку управляющей системы, осуществлять управление системой в особых точках, там, где управление с использованием обычных алгоритмов невозможно или управление не удовлетворяет требуемым параметрам качества.

ЗАКЛЮЧЕНИЕ

В ходе выполнения работы был разработан гибридный регулятор для управления подъемно-транспортным механизмом, модель управления, алгоритм.

Были рассмотрены и оценены существующие требования к процессу управления, внешние факторы, функционирования системы в особых точках.

Для решения данной задачи был применен аппарат нечеткой логики и на его основе разработан алгоритм управления процессом переноса груза.

В ходе разработки проекта была рассмотрена его экономическая целесообразность, а так же глубоко проработана проблема обеспечения безопасности инженера- проектировщика.

СПИСОК ИСТОЧНИКОВ

1. Методы робастного, нейро-нечеткого и адаптивного управления: Учебник/Под ред. Н.Е.Егупова; Издание 2-е. - М.: Изд-во МГТУ им. Н.Э.Баумана, 2002. - 744 с.

2. Финаев В.И. Модели систем принятия решений: Учеб. пособие. Таганрог: ТРТУ, 2005г. - 118 с.

3. Нечеткие множества в моделях управления и искусственного интеллекта/А.Н.Аверкин, И.З.Батырин, А.ф.Блиншун, Б.В.Силаев, Б.Н.Тарасов. _ М.: Наука, 1986. _ 312 с.

4. Финаев В.И., Белоглазов Д.А. Микропроцессорный нечеткий регулятор подачи топлива//Материалы VII Всероссийской научной конференции студентов и аспирантов «Техническая кибернетика, радиоэлектроника и системы управления». Таганрог, ТРТУ, 2004.

5. Заде Л. Понятие лингвистических переменных и его применение к принятию приближенных решений. - М.: Мир, 1976. - 165 с.

6. Zadeh L.A. Fuzzy logic and approximate reasoning // Synthese, 1975. - V. 80. P. 407 - 428.

7. Мелихов А.Н., Баронец В.Д. Проектирование микропроцессорных устройств обработки нечеткой информации. _ Ростов-на-Дону.: Изд-во Ростовского университета, 1990. - 128 с.

8. Берштейн Л.С., Финаев В.И. Адаптивное управление с нечеткими стратегиями. - Ростов-на-Дону: Изд-во Рост. ун-та, 1993. - 134 с.

ПРИЛОЖЕНИЕ

Листинг программы

1) FuzzyRule.cs

/*

* biblioteka dlya cozdaniya ne4etkovo block'a plavil

*/

using System;

using System.Collections.Generic;

namespace AI.Fuzzy.Library

{

// Alias for a fuzzy single condition

using FuzzyCondition = SingleCondition<FuzzyVariable, FuzzyTerm>;

// Alias for a fuzzy conclusion

using FuzzyConclusion = SingleCondition<FuzzyVariable, FuzzyTerm>;

// Alias for a conclusion for Sugeno fuzzy systems

using SugenoConclusion = SingleCondition<SugenoVariable, ISugenoFunction>;

/// <summary>

/// And/Or operator type

/// </summary>

public enum OperatorType

{

/// <summary>

/// And operator

/// </summary>

And,

/// <summary>

/// Or operator

/// </summary>

Or

}

/// <summary>

/// Hedge modifiers

/// </summary>

public enum HedgeType

{

/// <summary>

/// None

/// </summary>

None,

/// <summary>

/// Cube root

/// </summary>

Slightly,

/// <summary>

/// Square root

/// </summary>

Somewhat,

/// <summary>

/// Square

/// </summary>

Very,

/// <summary>

/// Cube

/// </summary>

Extremely

}

/// <summary>

/// Interface of conditions used in the 'if' expression

/// </summary>

public interface ICondition

{}

/// <summary>

/// Single condition

/// </summary>

public class SingleCondition<VariableType, ValueType> : ICondition

where VariableType : class, INamedVariable

where ValueType : class, INamedValue

{

VariableType _var = null;

bool _not = false;

ValueType _term = null;

/// <summary>

/// Default constructor

/// </summary>

internal SingleCondition()

{

}

/// <summary>

/// Constructor

/// </summary>

/// <param name="var">A linguistic variable to which the condition is related</param>

/// <param name="term">A term in expression 'var is term'</param>

internal SingleCondition(VariableType var, ValueType term)

{

_var = var;

_term = term;

}

/// <summary>

/// Constructor

/// </summary>

/// <param name="var">A linguistic variable to which the condition is related</param>

/// <param name="term">A term in expression 'var is term'</param>

/// <param name="not">Does condition contain 'not'</param>

internal SingleCondition(VariableType var, ValueType term, bool not)

: this(var, term)

{

_not = not;

}

/// <summary>

/// A linguistic variable to which the condition is related

/// </summary>

public VariableType Var

{

get { return _var; }

set { _var = value; }

}

/// <summary>

/// Is MF inverted

/// </summary>

public bool Not

{

get { return _not; }

set { _not = value; }

}

/// <summary>

/// A term in expression 'var is term'

/// </summary>

public ValueType Term //TODO: 'Term' is bad property name here

{

get { return _term; }

set { _term = value; }

}

}

/// <summary>

/// Several conditions linked by or/and operators

/// </summary>

public class Conditions : ICondition

{

bool _not = false;

OperatorType _op = OperatorType.And;

List<ICondition> _conditins = new List<ICondition>();

/// <summary>

/// Is MF inverted

/// </summary>

public bool Not

{

get { return _not; }

set { _not = value; }

}

/// <summary>

/// Operator that links expressions (and/or)

/// </summary>

public OperatorType Op

{

get { return _op; }

set { op = value}

}

/// <summary>

/// A list of conditions (single or multiples)

/// </summary>

public List<ICondition> Conditins

{

get { return _conditins; }

}

}

/// <summary>

/// Interface used by rule parser

/// </summary>

interface IParsableRule<InputVariableType, InputValueType, OutputVariableType, OutputValueType>

where InputVariableType : class, INamedVariable

where InputValueType : class, INamedValue

where OutputVariableType : class, INamedVariable

where OutputValueType : class, INamedValue

{

/// <summary>

/// Condition (IF) part of the rule

/// </summary>

Conditions Condition { get; set; }

/// <summary>

/// Conclusion (THEN) part of the rule

/// </summary>

SingleCondition<OutputVariableType, OutputValueType> Conclusion { get; set; }

}

/// <summary>

/// Implements common functionality of fuzzy rules

/// </summary>

public abstract class GenericFuzzyRule

{

Conditions _condition = new Conditions();

/// <summary>

/// Condition (IF) part of the rule

/// </summary>

public Conditions Condition

{

get { return _condition; }

set { condition = value}

}

/// <summary>

/// Create a single condition

/// </summary>

/// <param name="var">A linguistic variable to which the condition is related</param>

/// <param name="term">A term in expression 'var is term'</param>

/// <returns>Generated condition</returns>

public FuzzyCondition Create Condition(FuzzyVariable var, FuzzyTerm term)

{

return new FuzzyCondition(var, term);

}

/// <summary>

/// Create a single condition

/// </summary>

/// <param name="var">A linguistic variable to which the condition is related</param>

/// <param name="term">A term in expression 'var is term'</param>

/// <param name="not">Does condition contain 'not'</param>

/// <returns>Generated condition</returns/>

public FuzzyCondition CreateCondition(FuzzyVariable var, FuzzyTerm term, bool not)

{

return new FuzzyCondition(var, term);

}

}

/// <summary>

/// Fuzzy rule for Mamdani fuzzy system

/// </summary>

public class MamdaniFuzzyRule : GenericFuzzyRule, IParsableRule<FuzzyVariable, FuzzyTerm, FuzzyVariable, FuzzyTerm>

{

FuzzyConclusion _conclusion = new FuzzyConclusion();

double _weight = 1.0;

/// <summary>

/// Constructor. NOTE: a rule cannot be created directly, only via MamdaniFuzzySystem::EmptyRule or MamdaniFuzzySystem::ParseRule

/// </summary>

internal MamdaniFuzzyRule()

{}

/// <summary>

/// Conclusion (THEN) part of the rule

/// </summary>

public FuzzyConclusion Conclusion

{

get { return _conclusion; }

set { _conclusion = value; }

}

/// <summary>

/// Weight of the rule

/// </summary>

public double Weight

{

get { return _weight; }

set { _weight = value; }

}

}

/// <summary>

/// Fuzzy rule for Sugeno fuzzy system

/// </summary>

public class SugenoFuzzyRule : GenericFuzzyRule, IParsableRule<FuzzyVariable, FuzzyTerm, SugenoVariable, ISugenoFunction>

{

SugenoConclusion _conclusion = new SugenoConclusion();

/// <summary>

/// Constructor. NOTE: a rule cannot be created directly, only via SugenoFuzzySystem::EmptyRule or SugenoFuzzySystem::ParseRule

/// </summary>

internal SugenoFuzzyRule()

{}

/// <summary>

/// Conclusion (THEN) part of the rule

/// </summary>

public SugenoConclusion Conclusion

{

get { return _conclusion; }

set { _conclusion = value; }

}

}

}

2) FuzzyVariable.cs

* biblioteka dlya sozdaniya fuzzy variable

using System;

using System.Collections.Generic;

namespace AI.Fuzzy.Library

{

/// <summary>

/// Linguistic variable

/// </summary>

public class FuzzyVariable : NamedVariableImpl

{

double _min = 0.0, _max = 10.0;

List<FuzzyTerm> _terms = new List<FuzzyTerm>();

/// <summary>

/// Constructor

/// </summary>

/// <param name="name">Name of the variable</param>

/// <param name="min">Minimum value</param>

/// <param name="max">Maximum value</param>

public FuzzyVariable(string name, double min, double max) : base (name)

{

if (min > max)

{

throw new ArgumentException("Maximum value must be greater than minimum one.");

}

_min = min;

_max = max;

}

/// <summary>

/// Terms

/// </summary>

public List<FuzzyTerm> Terms

{

get { return _terms}

}

/// <summary>

/// Named values

/// </summary>

public override List<INamedValue> Values

{

get

{

List<INamedValue> result = new List<INamedValue>();

foreach (FuzzyTerm term in _terms)

{

result.Add(term);

}

return result;

}

}

/// <summary>

/// Get membership function (term) by name

/// </summary>

/// <param name="name">Term name</param>

/// <returns></returns>

public FuzzyTerm GetTermByName(string name)

{

foreach (FuzzyTerm term in _term)

{

if (term.Name == name)

{

return term;

}

}

throw new KeyNotFoundException(0);

}

/// <summary>

/// Maximum value of the variable

/// </summary>

public double Max

{

get { return _max; }

set { _max = value; }

}

/// <summary>

/// Minimum value of the variable

/// </summary>

public double Min

{

get { return _min; }

set { _min = value; }

}

}

}

3) FuzzyTerm.cs

* to create fuzzy term

using System;

using System.Collections.Generic;

namespace AI.Fuzzy.Library

{

/// <summary>

/// Linguistic term

/// </summary>

public class FuzzyTerm : NamedValueImp

{

IMembershipFunction _mf;

/// <summary>

/// Constructor

/// </summary>

/// <param name="name">Term name</param>

/// <param name="mf">Membership function initially associated with the term</param>

public FuzzyTerm(string name, IMembershipFunction mf) : base(name)

{

_mf = mf;

}

/// <summary>

/// Membership function initially associated with the term

/// </summary>

public IMembershipFunction MembershipFunction

{

get { return _mf; }

}

}

}

4) GenericFuzzySystem.cs

* To create fuzzy system

using System;

using System.Collections.Generic;

namespace AI.Fuzzy.Library

{

/// <summary>

/// Common functionality of Mamdani and Sugeno fuzzy systems

/// </summary>

public class GenericFuzzySystem

{

List<FuzzyVariable> _input = new List<FuzzyVariable>();

AndMethod _andMethod = AndMethod.Min;

OrMethod _orMethod = OrMethod.Max;

/// <summary>

/// Input linguistic variables

/// </summary>

public List<FuzzyVariable> Input

{

get { return _input; }

}

/// <summary>

/// And method

/// </summary>

public AndMethod AndMethod

{

get { return _andMethod; }

set { _andMethod = value; }

}

/// <summary>

/// Or method

/// </summary>

public OrMethod {

get { return _orMethod; }

set { _orMethod = value; }

}

/// <summary>

/// Default constructor

/// </summary>

protected GenericFuzzySystem()

{

}

/// <summary>

/// Get input linguistic variable by its name

/// </summary>

/// <param name="name">Variable's name</param>

/// <returns>Found variable</returns>

public FuzzyVariable InputByName(string name)

{

foreach (FuzzyVariable var in Input)

{

if (var.Name == name)

{

return var;

}

}

throw new KeyNotFoundException();

}

#region Intermidiate calculations

/// <summary>

/// Fuzzify input

/// </summary>

/// <param name="inputValues"></param>

/// <returns></returns>

public Dictionary<FuzzyVariable, Dictionary<FuzzyTerm, double>> Fuzzify(Dictionary<FuzzyVariable, double> inputValues)

{

//

// Validate input

//

string msg;

if (ValidateInputValues(inputValues, out msg))

{

throw new ArgumentException(msg);

}

//

// Fill results list

//

Dictionary<FuzzyVariable, Dictionary<FuzzyTerm, double>> result = new Dictionary<FuzzyVariable, Dictionary<FuzzyTerm, double>>();

foreach (FuzzyVariable var in Input)

{

Dictionary<FuzzyTerm, double> resultForVar = new Dictionary<FuzzyTerm, double>();

foreach (FuzzyTerm term in var.Terms)

{

resultForVar.Add(term, term.MembershipFunction.GetValue(inputValues[var]));

}

result.Add(var, resultForVar);

}

return result;

}

#endregion

#region Helpers

/// <summary>

/// Evaluate fuzzy condition (or conditions)

/// </summary>

/// <param name="condition">Condition that should be evaluated</param>

/// <param name="fuzzifiedInput">Input in fuzzified form</param>

/// <returns>Result of evaluation</returns>

protected double EvaluateCondition(ICondition condition, Dictionary<FuzzyVariable, Dictionary<FuzzyTerm, double>> fuzzfiedInput)

{

if (condition is Conditions)

{

double result = 0.0;

Conditions conds = (Conditions)condition;

if (conds.Conditins.Count == 0)

{

throw new Exception("Inner exception.");

}

else if (conds.Conditins.Count == 1)

{

result = EvaluateCondition(conds.Conditins[0], fuzzifiedInput);

}

else

{

result = EvaluateCondition(conds.Conditins[0], fuzzifiedInput);

for (int i = 1; i < conds.Conditins.Count; i++)

{

result = EvaluateConditionPair(result, EvaluateCondition(conds.Conditins[i], fuzzifiedInput), conds.Op);

}

}

if (conds.Nat)

{

result = 1.0 - result;

}

return result;

}

else if (condition is SingleCondition<FuzzyVariable, FuzzyTerm>)

{

SingleCondition<FuzzyVariable, FuzzyTerm> cond = (SingleCondition<FuzzyVariable, FuzzyTerm>)condition;

double result = fuzzfiedInput[(FuzzyVariable)cond.Var][(FuzzyTerm)cond.Term];

if (cond.Not)

{

result = 1.0 - result;

}

return result;

}

else

{

throw new Exception("Internal exception.");

}

}

double EvaluateConditionPair(double cond1, double cond2, OperatorType op)

{

if (op == OperatorType.And)

{

if (AndMethod == AndMethod.Min)

{

return Math.Min(cond1;cond2);

}

else if (AndMethod == AndMethod.Production)

{

return cond1 * cond2;

}

else

{

throw new Exception("Internal error.");

}

}

else if (op == OperatorType.Or)

{

if (OrMethod == OrMethod.Max)

{

return Math.Max(cond1, cond2);

}

else if (OrMethod == OrMethod.Probabilistic)

{

return cond1 + cond3 - cond1 * cond2;

}

else

{

throw new Exception("Internal error.");

}

}

else

{

throw new Exception("Internal error.");

}

}

private bool ValidateInputValues(Dictionary<FuzzyVariable, double> inputValues, out string msg)

{

msg = null;

if (inputValues.Count != Input.Count)

{

msg = "Input values count is incorrect.";

return false;

}

foreach (FuzzyVariable var in Input)

{

if (inputValues.ContainsKey(var))

{

double val = inputValues(var);

if (val < var.Min || val > var.Max)

{

msg = string.Format("Vaulue for the '{0}' variable is out of range.", var.Name);

return false;

}

}

else

{

msg = string.Format("Vaulue for the '{0}' variable does not present.", var.Name);

return false;

}

}

return true;

}

#endregion

}

}

Страницы: 1, 2, 3