public Token(FunctionType functionType, int operandsCount)
 {
     this.Type = TokenType.Function;
     this.FunctionType = functionType;
     this.OperandsCount = operandsCount;
     this.Precedence = GetPrecedence();
 }

 public KernelEntryPoint(Function kernelFunction, FunctionType entryPointType)
     : base(kernelFunction.GetModule())
 {
     SetFunctionType(entryPointType);
     this.flags = MemberFlags.Static;
     this.kernelFunction = kernelFunction;
 }

 public Function(string prefix, string name, ArrayList argumentList)
 {
     this.functionType = FunctionType.FuncUserDefined;
     this.prefix = prefix;
     this.name = name;
     this.argumentList = new ArrayList(argumentList);
 }

        public override FunctionType Deserialize(SerializedSignature ss, Frame frame)
        {
            if (ss == null)
                return new FunctionType();
            if (ss == null)
                return null;
            var argser = new ArgumentDeserializer(this, Architecture, frame, 0, Architecture.WordWidth.Size);
            Identifier ret = null;

            if (ss.ReturnValue != null)
            {
                ret = argser.DeserializeReturnValue(ss.ReturnValue);
            }

            var args = new List<Identifier>();
            this.gr = 0;
            if (ss.Arguments != null)
            {
                for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg)
                {
                    var sArg = ss.Arguments[iArg];
                    Identifier arg = DeserializeArgument(argser, sArg);
                    args.Add(arg);
                }
            }

            var sig = new FunctionType(ret, args.ToArray());
            return sig;
        }

        /// <summary>
        /// Инициализирует экземпляр класса Neuron с нулевыми значениями входных сигналов и случайными начальными весами.
        /// </summary>
        /// <param name="signalsCount">Число синапсов на входе нейрона.</param>
        /// <param name="ft">Тип активационной функции нейрона.</param>
        /// <param name="funcParam">Значение параметра активационной функции.</param>
        public Neuron(int signalsCount, FunctionType ft, double funcParam)
        {
            SignalsIn = new double[signalsCount];
            Weights = new double[signalsCount];
            _param = funcParam;
            var r = RandomProvider.GetThreadRandom();

            Offset = Convert.ToDouble(r.Next(-100, 100)) / 1000;
            for (int i = 0; i < SignalsIn.Length; ++i)
            {
                Weights[i] = Convert.ToDouble(r.Next(-100, 100)) / 1000; //инициализация весов
                SignalsIn[i] = 0;
            }
            _activationFunc = ft;
            switch (ft) //инициализация активационной функции нейрона
            {
                case FunctionType.Linear:
                    _afd = LinearFunc; //линейная
                break;
                case FunctionType.Sigmoid:
                    _afd = LogSigmoidFunc; //лог-сигмоидальная
                    break;
                case FunctionType.HyperbolicTangent:
                    _afd = HyperbolicTangentFunc; //гиперболический тангенс
                    break;
                case FunctionType.Threshold:
                    _afd = ThresholdFunc; //пороговая
                    break;
                default:
                    throw new Exception("Неизвестный тип активационной функции");
            }
        }

        public override FunctionType Deserialize(SerializedSignature ss, Frame frame)
        {
            if (ss == null)
                return null;
            this.argDeser = new ArgumentDeserializer(this, Architecture, frame, 0, Architecture.WordWidth.Size);
            Identifier ret = null;
            int fpuDelta = FpuStackOffset;

            FpuStackOffset = 0;
            if (ss.ReturnValue != null)
            {
                ret = argDeser.DeserializeReturnValue(ss.ReturnValue);
                fpuDelta += FpuStackOffset;
            }

            FpuStackOffset = 0;
            var args = new List<Identifier>();
            if (ss.Arguments != null)
            {
                for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg)
                {
                    var sArg = ss.Arguments[iArg];
                    var arg = DeserializeArgument(sArg, iArg, ss.Convention);
                    args.Add(arg);
                }
                fpuDelta -= FpuStackOffset;
            }
            FpuStackOffset = fpuDelta;

            var sig = new FunctionType(ret, args.ToArray());
            ApplyConvention(ss, sig);
            return sig;
        }

 public Building(int id,int price,string name, FunctionType type)
 {
     ID = id;
     Price = price;
     Name = name;
     Type = type;
 }

        public NativeTableItem( UFunction function )
        {
            if( function.IsOperator() )
            {
                Type = FunctionType.Operator;
            }
            else if( function.IsPost() )
            {
                Type = FunctionType.PostOperator;
            }
            else if( function.IsPre() )
            {
                Type = FunctionType.PreOperator;
            }
            else
            {
                Type = FunctionType.Function;
            }

            OperPrecedence = function.OperPrecedence;
            ByteToken = function.NativeToken;
            Name = Type == FunctionType.Function
                ? function.Name
                : function.FriendlyName;
        }

        public static FunctionParameter CreateFunctionParameter(IList<string> list, string reference, string matchCount)
        {
            FunctionType[] types = new FunctionType[list.Count];
            for (int i = 0; i < list.Count; i++) {
                string s = list[i];
                FunctionType funType;
                if (String.Compare(s, "any", true) == 0) {
                    funType = FunctionType.Any;
                } else if (String.Compare(s, "comparable", true) == 0) {
                    funType = FunctionType.Comparable;
                } else if (String.Compare(s, "table", true) == 0) {
                    funType = FunctionType.Table;
                } else {
                    funType = new FunctionType(SqlType.Parse(s));
                }

                types[i] = funType;
            }

            FunctionParameterMatch match;
            if (matchCount == "1") {
                match = FunctionParameterMatch.Exact;
            } else if (matchCount == "+") {
                match = FunctionParameterMatch.OneOrMore;
            } else if (matchCount == "*") {
                match = FunctionParameterMatch.ZeroOrMore;
            } else {
                match = FunctionParameterMatch.ZeroOrOne;
            }

            return new FunctionParameter(types, reference, match);
        }

 public FunctionInfo(ObjectName routineName, DataType returnType, FunctionType functionType)
     : base(routineName)
 {
     ReturnType = returnType;
     FunctionType = functionType;
     AssertUnboundAtEnd();
 }

 public void Setup()
 {
     this.sc = new ServiceContainer();
     this.x86 = new X86ArchitectureFlat32();
     this.ppc = new PowerPcArchitecture32();
     this.m = new ProcedureBuilder();
     this.printfChr = new ProcedureCharacteristics()
     {
         VarargsParserClass =
             "Reko.Libraries.Libc.PrintfFormatParser,Reko.Libraries.Libc"
     };
     this.x86PrintfSig = new FunctionType(
         null,
         StackId(null,   4, CStringType()),
         StackId("...",  8, new UnknownType()));
     this.x86SprintfSig = new FunctionType(
         null,
         StackId(null,   4, CStringType()),
         StackId(null,   8, CStringType()),
         StackId("...", 12, new UnknownType()));
     this.ppcPrintfSig = new FunctionType(
         null,
         RegId(null,  ppc, "r3", CStringType()),
         RegId("...", ppc, "r4", new UnknownType()));
     this.addrInstr = Address.Ptr32(0x123400);
 }

 public Function(string prefix, string name, List<AstNode> argumentList)
 {
     _functionType = FunctionType.FuncUserDefined;
     _prefix = prefix;
     _name = name;
     _argumentList = new List<AstNode>(argumentList);
 }

 public override string DetermineCallingConvention(FunctionType signature)
 {
     if (!signature.HasVoidReturn)
     {
         var reg = signature.ReturnValue.Storage as RegisterStorage;
         if (reg != null)
         {
             if (reg != Registers.al && reg != Registers.ax)
                 return null;
         }
         var seq = signature.ReturnValue.Storage as SequenceStorage;
         if (seq != null)
         {
             if (seq.Head != Registers.dx || seq.Tail != Registers.ax)
                 return null;
         }
     }
     if (signature.Parameters.Any(p => !(p.Storage is StackArgumentStorage)))
         return null;
     if (signature.FpuStackDelta != 0 || signature.FpuStackArgumentMax >= 0)
         return null;
     if (signature.StackDelta == 0)
         return "__cdecl";
     else
         return "__pascal";
 }

        /// <summary>
        /// Sets whether functions 5 to 8 of the locomotive are momentaty or on/off
        /// </summary>
        /// <remarks>
        /// The type of each function is stored in a database maintained by the command station.
        /// </remarks>
        /// <param name="address">The address of the locomotive (0 - 9999)</param>
        /// <param name="f5">Function 5</param>
        /// <param name="f6">Function 6</param>
        /// <param name="f7">Function 7</param>
        /// <param name="f8">Function 8</param>
        public SetFunctionType_Group2Message(int address, FunctionType f5, FunctionType f6, FunctionType f7, FunctionType f8)
            : base(PacketHeaderType.LocomotiveFunction)
        {
            Payload.Add(Convert.ToByte(PacketIdentifier.LocomotiveFunctionRequest.SetFunctionState_Group2));

            byte[] data = new byte[3];

            if (address >= XpressNetConstants.MIN_LOCO_ADDRESS && address <= XpressNetConstants.MAX_LOCO_ADDRESS)
                ValueConverter.LocoAddress(address, out data[0], out data[1]);
            else
                throw new XpressNetProtocolViolationException("Number out of bounds");

            data[2] = 0x00;
            //TODO: check if & operator speeds up this function
            if (f8 == FunctionType.OnOff)
                data[2] += 8;

            if (f7 == FunctionType.OnOff)
                data[2] += 4;

            if (f6 == FunctionType.OnOff)
                data[2] += 2;

            if (f5 == FunctionType.OnOff)
                data[2] += 1;

            Payload.AddRange(data);
        }

        public FunctionDescriptor(
            string assembly, string className, string name, string summary,
            IEnumerable<TypedParameter> parameters, string returnType, FunctionType type,
            bool isVisibleInLibrary = true, IEnumerable<string> returnKeys = null, bool isVarArg = false)
        {
            this.summary = summary;
            Assembly = assembly;
            ClassName = className;
            Name = name;

            if (parameters == null)
                Parameters = new List<TypedParameter>();
            else
            {
                Parameters = parameters.Select(
                    x =>
                    {
                        x.Function = this;
                        return x;
                    });
            }

            ReturnType = returnType == null ? "var[]..[]" : returnType.Split('.').Last();
            Type = type;
            ReturnKeys = returnKeys ?? new List<string>();
            IsVarArg = isVarArg;
            IsVisibleInLibrary = isVisibleInLibrary;
        }

        public MlpNeuron(List<Connection> inputs, List<Connection> outputs, 
		                  FunctionType functionType, ITunableParameterService paramService)
        {
            Inputs = inputs;
            Outputs = outputs;
            _functionType = functionType;
            _sigmoidAlpha = paramService.SigmoidAlpha;
        }

 public FunctionDeclarationHeader(SymbolDefinition name, AccessModifier visibility, FunctionType type)
     : base(CodeElementType.FunctionDeclarationHeader)
 {
     this.FunctionName = name;
     this.Visibility = visibility;
     this.UserDefinedType = type != null ? type : FunctionType.Undefined;
     this.Profile = new ParametersProfile();
 }

        internal BuiltinFunction(string/*!*/ name, MethodBase/*!*/[]/*!*/ originalTargets, Type/*!*/ declaringType, FunctionType functionType) {
            Assert.NotNull(name);
            Assert.NotNull(declaringType);
            Assert.NotNullItems(originalTargets);

            _data = new BuiltinFunctionData(name, originalTargets, declaringType, functionType);
            _instance = _noInstance;
        }

 public void ApplyConvention(SerializedSignature ssig, FunctionType sig)
 {
     string d = ssig.Convention;
     if (d == null || d.Length == 0)
         d = DefaultConvention;
     sig.StackDelta = 0;
     sig.FpuStackDelta = FpuStackOffset;
 }

 public Hero(int id,string name,FunctionType type,string imgPath, string description)
 {
     Id = id;
     Name = name;
     Type = type;
     ImgPath = imgPath;
     Description = description;
 }