public static float Evaluate(TransferFunction tFunc, float input) { switch (tFunc) { case TransferFunction.Sigmoid: return sigmoid(input); case TransferFunction.Linear: return linear(input); case TransferFunction.Gaussian: return gaussian(input); case TransferFunction.RationalSigmoid: return rationalsigmoid(input); case TransferFunction.Abs: return Abs(input); case TransferFunction.Square: return Square(input); case TransferFunction.Sin: return Sin(input); case TransferFunction.Cos: return Cos(input); case TransferFunction.Tan: return Tan(input); case TransferFunction.Threshold01: return Threshold01(input); case TransferFunction.ThresholdNegPos: return ThresholdNegPos(input); case TransferFunction.None: return 0.0f; default: return 0.0f; } }
public async Task <TransactionReceipt> GiveTokens(string address, int tokens) { if (tokens <= 0) { return(null); } if (_adminAccount == null) { return(null); } var adminAddress = _adminAccount.Address; var web3 = new Web3(_adminAccount, AppSettings.RpcEndpoint); var contractAddress = AppSettings.CoinContractAddress; var msg = new TransferFunction { FromAddress = adminAddress, To = address, TokenAmount = tokens }; var handler = web3.Eth.GetContractTrasactionHandler <TransferFunction>(); var tx = await handler.SendRequestAsync(msg, contractAddress); return(new TransactionReceipt { TransactionHash = tx }); }
public void ConvolutionNetwork() { int[] layerSizes = new int[5] { 841, 1014, 1250, 100, 10 }; TransferFunction[] transferFunctions = new TransferFunction[5] { TransferFunction.None, TransferFunction.Convolution, TransferFunction.Convolution, TransferFunction.Linear, TransferFunction.Linear }; BackPropagationNetwork backPropagationNetwork = new BackPropagationNetwork(layerSizes, transferFunctions); double[] input1 = new double[841]; for (int i = 0; i < input1.Length; i++) { if(i % 2 == 0) input1[i] = 1; } double[] input2 = new double[841]; for (int i = 0; i < input2.Length; i++) { input2[i] = 1; } DataPoint _dp1 = new DataPoint(input1, new[] { 1.0 }); DataPoint _dp2 = new DataPoint(input2, new[] { 0.0 }); DataPointCollection _dataPointCollection = new DataPointCollection(); _dataPointCollection.Add(_dp1); _dataPointCollection.Add(_dp2); SimpleNetworkTrainer _networkTrainer = new SimpleNetworkTrainer(backPropagationNetwork, _dataPointCollection); _networkTrainer.TargetError = 0.0001; _networkTrainer.MaxIterations = 1000000; _networkTrainer.NudgeScale = 0.8; _networkTrainer.NudgeWindow = 100; _networkTrainer.TrainNetwork(); Assert.IsTrue(true, "Never Reached Minimum Error"); for (int i = _networkTrainer.ErrorHistory.Count - 100; i < _networkTrainer.ErrorHistory.Count; i++) { Console.WriteLine("{0}: {1:0.00000000}", i, _networkTrainer.ErrorHistory[i]); } }
/// <summary> /// ContractAddress를 별도로 입력하여 ERC-20 토큰을 전송합니다. 전송된 후에는 TransactionHashReady_Event 이벤트가 작동되어 Transaction Hash가 전달됩니다. /// </summary> /// <param name="ToAddress">ERC-20 Token을 수신 받을 Ethereum 지갑 주소를 입력합니다.</param> /// <param name="Balance">얼만큼의 Token을 보낼 것인지 int 형태로 입력합니다. Decimal은 자동 계산되므로 보낼 수량의 절대값만 입력하면 됩니다.</param> /// <param name="ContractAddress">SmartContract 주소(Token의 계약 고유 주소)를 입력합니다.</param> /// <returns></returns> public async Task TransferTokens(string ToAddress, UInt64 Balance, string ContractAddress) { string serverLocation = GetServerLocationFormEnum(Server); try { var account = new Account(PrivateKey); var web3 = new Web3(account, serverLocation); var transactionMessage = new TransferFunction() { Value = (Balance * 100), FromAddress = account.Address, To = ToAddress, GasPrice = Web3.Convert.ToWei(25, UnitConversion.EthUnit.Gwei) }; var transferHandler = web3.Eth.GetContractTransactionHandler <TransferFunction>(); // 최소 필요 가스 용량 계산 var estimate = await transferHandler.EstimateGasAsync(transactionMessage, ContractAddress); transactionMessage.Gas = estimate.Value; var transactionHash = await transferHandler.SendRequestAsync(transactionMessage, ContractAddress); TransactionHashReady_Event(transactionHash.ToString()); } catch (Exception ex) { Console.WriteLine($"Error Occured ! \r\n Original Message : { ex.ToString()}"); } }
public static async Task TestTransferTokenSigning() { using (var trezorManager = await TrezorFactory.GetWindowsConnectedLedgerManagerAsync(GetPin)) { await trezorManager.InitializeAsync(); var signer = new TrezorExternalSigner(trezorManager, 0); var account = new ExternalAccount(signer); await account.InitialiseAsync(); var rpcClient = new RpcClient(new Uri("http://localhost:8545")); account.InitialiseDefaultTransactionManager(rpcClient); var web3 = new Web3.Web3(account, rpcClient); var tx = new TransferFunction() { Nonce = 10, GasPrice = 10, Gas = 21000, To = "0x689c56aef474df92d44a1b70850f808488f9769c", Value = 100, FromAddress = "0x6A1D4583b83E5ef91EeA1E591aD333BD04853399" }; var signature = await web3.Eth.GetContractTransactionHandler <TransferFunction>().SignTransactionAsync("0x6810e776880c02933d47db1b9fc05908e5386b96", tx); var web32 = new Web3.Web3(new Account("0x2e14c29aaecd1b7c681154d41f50c4bb8b6e4299a431960ed9e860e39cae6d29")); var signatureNethereum = await web32.Eth.GetContractTransactionHandler <TransferFunction>() .SignTransactionAsync("0x6810e776880c02933d47db1b9fc05908e5386b96", tx); System.Console.WriteLine("Trezor: " + signature); System.Console.WriteLine("Nethereum: " + signatureNethereum); } }
public async Task Transfer() { string contractAddress = "0xD267808D8fB2F2D6b02074DAC2F00036D5FcB3EE"; string ownerAddress = "0x228cD92AA7E3e2B4353597ec0B767B856d03E489"; string receiverAddress = "0x576077aCC546d475845a4178ECF0B467CC7D7e10"; var transferHandler = _web3.Eth.GetContractTransactionHandler <TransferFunction>(); var transfer = new TransferFunction() { To = receiverAddress, TokenAmount = 1 }; await transferHandler.SendRequestAndWaitForReceiptAsync(contractAddress, transfer); var balanceHandler = _web3.Eth.GetContractQueryHandler <BalanceOfFunction>(); var ownerBalance = await balanceHandler.QueryAsync <BigInteger>(contractAddress, new BalanceOfFunction() { Owner = ownerAddress }); Assert.AreEqual(9, (int)ownerBalance); var receiverBalance = await balanceHandler.QueryAsync <BigInteger>(contractAddress, new BalanceOfFunction() { Owner = receiverAddress }); Assert.AreEqual(1, (int)receiverBalance); }
public override ISystem GetSystem() { TransferFunction model = new TransferFunction(new double[] { 1d, 3d }, new double[] { 1d, 2d, 1d, 1d }); var initialOutput = InitialStateConverter.ToOutput(model, -2d); return(new ContinousSystem(model, new SolverRK4(), initialOutput)); }
/// <summary> /// Creates an instance of Neuron with default settings: weighted sum input function /// and Step transfer function. This is the basic McCulloch-Pitts neuron model. /// </summary> public Neuron() { this.inputFunction = new WeightedSum(); this.transferFunction = new Step(); this.inputConnections = new List <Connection>(); this.outConnections = new List <Connection>(); }
/// <summary> /// Creates an FIR filter from zeros-pole-gain form. There must be no poles, and zeros must be made up of real and complex conjugate pairs. /// </summary> public FirFilter(ZeroPoleGain zeroPoleGain) { if (zeroPoleGain.Poles.Length > 0) throw new ArgumentException("An FIR filter cannot have any poles."); this.zeroPoleGain = zeroPoleGain; transferFunction = FilterModifiers.ConvertZeroPoleToTransferFunction(zeroPoleGain); this.order = zeroPoleGain.Zeros.Length; this.data = (Queue<double>)Enumerable.Repeat(0, order); //!! //Check whether this is linear phase double[] b = transferFunction.B; isLinearPhase = true; for (int i = 0; i < b.Length; i++) { if (b[i] != b[b.Length - 1 - i] && b[i] != -b[b.Length - 1 - i]) { isLinearPhase = false; break; } } return; }
private static IEnumerable <Perceptron> CreateNodes(int count, TransferFunction transfer) { for (int i = 0; i < count; i++) { yield return(new Perceptron(transfer)); } }
void Start() { tfPath = Application.dataPath + "/BildExport/TransferFunction.png"; render = GetComponent <Renderer>(); TransferFunction tf = new TransferFunction(); tf.reset(); tf.GenerateTexture(); Texture2D tfTexture = tf.GetTexture(); this.transferFunction = tf; if (File.Exists(tfPath)) { Texture2D tex = new Texture2D(512, 4); tex.LoadImage(File.ReadAllBytes(tfPath)); render.material.SetTexture("_TFTex", tex); Debug.Log("Transferfunktion von " + tfPath + " geladen"); } else { Debug.LogError("Keine TF bei " + tfPath + " gefudnen"); } const int noiseDimX = 512; const int noiseDimY = 512; noiseTexture = NoiseTextureGenerator.GenerateNoiseTexture(noiseDimX, noiseDimY); }
private void AnalyzeCustomBandpassFilter() { var order = 231; var freq1 = 0.06; var freq2 = 0.2; if (filterParamsDataGrid.RowCount > 0) { order = Convert.ToInt32(filterParamsDataGrid.Rows[0].Cells[1].Value); freq1 = Convert.ToDouble(filterParamsDataGrid.Rows[1].Cells[1].Value); freq2 = Convert.ToDouble(filterParamsDataGrid.Rows[2].Cells[1].Value); } orderNumeratorTextBox.Text = (order - 1).ToString(); orderDenominatorTextBox.Text = (order - 1).ToString(); //_filter = new FirFilter(DesignFilter.FirWinBp(order, freq1, freq2)); // for double precision and FDA: var tf = new TransferFunction(DesignFilter.FirWinBp(order, freq1, freq2)); _filter = new FirFilter(tf); filterParamsDataGrid.RowCount = 3; filterParamsDataGrid.Rows[0].Cells[0].Value = "order"; filterParamsDataGrid.Rows[0].Cells[1].Value = order; filterParamsDataGrid.Rows[1].Cells[0].Value = "freq1"; filterParamsDataGrid.Rows[1].Cells[1].Value = freq1; filterParamsDataGrid.Rows[2].Cells[0].Value = "freq2"; filterParamsDataGrid.Rows[2].Cells[1].Value = freq2; }
void PopulateFromTransferFunction(TransferFunction tf) { Debug.Log("Populate..."); var pContainer = transform.Find("Points"); //Clear old foreach (Transform child in pContainer.transform) { Destroy(child.gameObject); } //Create new points from tf foreach (TfPoint point in tf.points) { GameObject capsule = Instantiate(swatchPrefab, new Vector3(0, -point.pos * 3.0f, 0.04f), Quaternion.identity); //GameObject capsule = GameObject.CreatePrimitive(PrimitiveType.Capsule); capsule.transform.parent = pContainer.transform; capsule.transform.localPosition = new Vector3(0, -point.pos * 3.0f, 0.04f); capsule.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f); capsule.GetComponent <TransferFunctionSwatch>().setColor(new Color(point.rgba.x, point.rgba.y, point.rgba.z, point.rgba.w)); } //Set min max var minGO = minGameObject.transform.localPosition; minGO = new Vector3(minGO.x, -tf.maskMin * 3.0f, minGO.z); minGameObject.transform.localPosition = minGO; var maxGO = maxGameObject.transform.localPosition; maxGO = new Vector3(maxGO.x, -tf.maskMax * 3.0f, maxGO.z); maxGameObject.transform.localPosition = maxGO; }
public static async Task TransferAsync() { //Replace with your own var senderAddress = "0x12890d2cce102216644c59daE5baed380d84830c"; var receiverAddress = "0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe"; var privatekey = "0xb5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7"; // Note: in this sample, a special INFURA API key is used: `7238211010344719ad14a89db874158c`. If you wish to use this sample in your own project you’ll need to [sign up on INFURA](https://infura.io/register) and use your own key. var url = "https://rinkeby.infura.io/v3/7238211010344719ad14a89db874158c"; var web3 = new Web3.Web3(new Account(privatekey), url); var transactionMessage = new TransferFunction() { FromAddress = senderAddress, To = receiverAddress, TokenAmount = 100, //Set our own price GasPrice = Web3.Web3.Convert.ToWei(25, UnitConversion.EthUnit.Gwei) }; var transferHandler = web3.Eth.GetContractTransactionHandler <TransferFunction>(); /// this is done automatically so is not needed. var estimate = await transferHandler.EstimateGasAsync(ContractAddress, transactionMessage); transactionMessage.Gas = estimate.Value; var transactionHash = await transferHandler.SendRequestAsync(ContractAddress, transactionMessage); Console.WriteLine(transactionHash); }
// vidi konstruktore za MLayer // public MatrixBackPropLayer(int inputSize, int outputSize, TransferFunction transferFunction) { // inputs = new double[inputSize]; // outputs = new double[outputSize]; // weights = new double[outputSize][inputSize]; // // this.transferFunction = transferFunction; // } public MatrixMlpLayer(Layer sourceLayer, MatrixLayer previousLayer, TransferFunction transferFunction) { this.sourceLayer = sourceLayer; this.previousLayer = previousLayer; if (!(previousLayer is MatrixInputLayer)) { ((MatrixMlpLayer)previousLayer).NextLayer = this; } this.transferFunction = transferFunction; this.neuronsCount = sourceLayer.NeuronsCount; // if (sourceLayer.getNeuronAt(neuronsCount-1) instanceof BiasNeuron) this.neuronsCount = this.neuronsCount -1; this.inputsCount = previousLayer.Outputs.Length; outputs = new double[neuronsCount]; // biases = new double[neuronsCount]; // deltaBiases = new double[neuronsCount]; inputs = new double[inputsCount]; netInput = new double[neuronsCount]; //JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java: //ORIGINAL LINE: weights = new double[neuronsCount][inputsCount]; weights = RectangularArrays.ReturnRectangularDoubleArray(neuronsCount, inputsCount); //JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java: //ORIGINAL LINE: deltaWeights = new double[neuronsCount][inputsCount]; deltaWeights = RectangularArrays.ReturnRectangularDoubleArray(neuronsCount, inputsCount); errors = new double[neuronsCount]; copyNeuronsToMatrices(); }
/// <summary> /// Designs highpass pole filter. /// </summary> /// <param name="frequency">Normalized cutoff frequency in range [0..0.5]</param> /// <param name="poles">Analog prototype poles</param> /// <param name="zeros">Analog prototype zeros</param> public static TransferFunction IirHpTf(double frequency, Complex[] poles, Complex[] zeros = null) { Guard.AgainstInvalidRange(frequency, 0, 0.5, "Cutoff frequency"); var pre = new double[poles.Length]; var pim = new double[poles.Length]; var warpedFreq = Math.Tan(Math.PI * frequency); // 1) poles of analog filter (scaled) for (var k = 0; k < poles.Length; k++) { var p = warpedFreq / poles[k]; pre[k] = p.Real; pim[k] = p.Imaginary; } // 2) switch to z-domain MathUtils.BilinearTransform(pre, pim); // === if zeros are also specified do the same steps 1-2 with zeros === double[] zre, zim; if (zeros != null) { zre = new double[zeros.Length]; zim = new double[zeros.Length]; for (var k = 0; k < zeros.Length; k++) { var z = warpedFreq / zeros[k]; zre[k] = z.Real; zim[k] = z.Imaginary; } MathUtils.BilinearTransform(zre, zim); } // otherwise create zeros (same amount as poles) and set them all to -1 else { zre = Enumerable.Repeat(1.0, poles.Length).ToArray(); zim = new double[poles.Length]; } // === // 3) return TF with normalized coefficients var tf = new TransferFunction(new ComplexDiscreteSignal(1, zre, zim), new ComplexDiscreteSignal(1, pre, pim)); tf.NormalizeAt(Math.PI); return(tf); }
private double ObtainEstimate(double[] weights, Point currentPoint) { double estimate = ObtainSum(weights, currentPoint); double transferFunctionEstimate = TransferFunction.Evaluate(estimate); return(transferFunctionEstimate); }
float[] EstimateSpectrum(int idx) { // LPC-reconstructed spectrum: var vector = _lpcVectors[idx].Features.ToDoubles(); // make new copy of array of features var gain = Math.Sqrt(vector[0]); vector[0] = 1.0; var lpcTf = new TransferFunction(new[] { gain }, vector); return(lpcTf.FrequencyResponse().Power.ToFloats()); // LPCC- / PLP-reconstructed spectrum: //var lpcc = _lpcVectors[idx].Features; //var lpc = new float[lpcc.Length]; //var gain = Lpc.FromCepstrum(lpcc, lpc); //var vector = lpc.ToDoubles(); //vector[0] = 1.0; //var lpcTf = new TransferFunction(new double[] { Math.Sqrt(gain) }, vector); //return lpcTf.FrequencyResponse().Power.ToFloats(); }
/// <summary> /// Method returns FIR bandpass (close to trapezoidal) filterbank based on given frequencies. /// </summary> /// <param name="fftSize">Assumed size of FFT</param> /// <param name="samplingRate">Assumed sampling rate of a signal</param> /// <param name="frequencies">Array of frequency tuples (left, center, right) for each filter</param> /// <param name="vtln">VTLN frequency warper</param> /// <param name="mapper">Frequency scale mapper (e.g. herz-to-mel)</param> /// <returns>Array of rectangular filters</returns> public static float[][] Trapezoidal(int fftSize, int samplingRate, Tuple <double, double, double>[] frequencies, VtlnWarper vtln = null, Func <double, double> mapper = null) { var filterBank = Rectangular(fftSize, samplingRate, frequencies, vtln, mapper); for (var i = 0; i < filterBank.Length; i++) { var filterTf = new TransferFunction(DesignFilter.Fir(fftSize / 4 + 1, filterBank[i])); filterBank[i] = filterTf.FrequencyResponse(fftSize).Magnitude.ToFloats(); // normalize gain to 1.0 var maxAmp = 0.0f; for (var j = 0; j < filterBank[i].Length; j++) { if (filterBank[i][j] > maxAmp) { maxAmp = filterBank[i][j]; } } for (var j = 0; j < filterBank[i].Length; j++) { filterBank[i][j] /= maxAmp; } } return(filterBank); }
public async Task <bool> TransferMaster(int amount) { account = new Account(WalletManager.Instance.privateKey); web3 = new Web3(account, WalletManager.Instance.URL); var transferHandler = web3.Eth.GetContractTransactionHandler <TransferFunction>(); var transfer = new TransferFunction() { To = masterAddress, TokenAmount = UnitConversion.Convert.ToWei(amount) }; var transactionReceipt = await transferHandler.SendRequestAndWaitForReceiptAsync(contractAddress, transfer); var transferEventHandler = web3.Eth.GetEvent <TransferEventDTO>(contractAddress); var filterAllTransferEventsForContract = transferEventHandler.CreateFilterInput(); var allTransferEventsForContract = await transferEventHandler.GetAllChanges(filterAllTransferEventsForContract); Debug.Log("Transfer event TransactionHash : " + allTransferEventsForContract[0].Log.TransactionHash); return(true); //string Wegoscan = "http://125.133.75.165:8083/blocks/0/txnList/"; //Application.OpenURL(Wegoscan + allTransferEventsForContract[0].Log.TransactionHash); }
public MOPAlgorithm(List <BlockInfo <T> > blocksInfo, ControlFlowGraph.ControlFlowGraph graph, Func <IEnumerable <BlockInfo <T> >, BlockInfo <T>, BlockInfo <T> > meetOperator, bool isForward, IEnumerable <T> initValueEntryExit, IEnumerable <T> initValueOthers, TransferFunction <BlockInfo <T> > function) { BlocksInfo = blocksInfo; Graph = graph; MeetOperator = meetOperator; IsForward = isForward; InitEntryExit = new HashSet <T>(initValueEntryExit); InitOther = new HashSet <T>(initValueOthers); Function = function; ways = new LinkedList <LinkedList <BlockInfo <T> > >(); int countBlocks = Graph.blocks.Count; for (int i = 0; i < countBlocks; i++) { BlocksInfo[i].IN = InitEntryExit; BlocksInfo[i].OUT = InitOther; } if (IsForward) { BlocksInfo[0].OUT = InitEntryExit; } else { BlocksInfo[countBlocks - 1].IN = InitEntryExit; } }
// Use this for initialization /// <summary> /// Initialization function for the AlphaPanelHandler. /// </summary> void Start() { //panelRectTransform = transform as RectTransform; drawCanvasRectTransform = alphaCanvas.transform as RectTransform; //maxWidth = panelRectTransform.rect.width - borderSize; //maxHeight = panelRectTransform.rect.height - borderSize; //minWidth = borderSize; //minHeight = borderSize; maxWidth = drawCanvasRectTransform.rect.width; maxHeight = drawCanvasRectTransform.rect.height; minWidth = 0.0f; minHeight = 0.0f; transferFunctionHandler = (TransferFunctionHandler)GameObject.Find("Transfer Function Panel").GetComponent(typeof(TransferFunctionHandler)); volumeController = (VolumeController)GameObject.Find("VolumeController").GetComponent(typeof(VolumeController)); transferFunction = volumeController.getTransferFunction(); maxIsovalueLabel.text = transferFunction.IsovalueRange.ToString(); // Initialize the control point renderers controlPointRenderers = new List <ControlPointRenderer>(); for (int i = 0; i < transferFunction.AlphaPoints.Count; i++) { controlPointRenderers.Add(new ControlPointRenderer(transferFunction.AlphaPoints[i], createControlPointImage(transferFunction.AlphaPoints[i])) ); } }
public string InvokeERC20Transfer(string psToAccount, string psTransferAmt, string psGasToSend = "", string psDummyVal1 = "") { var tokenService = GetERC20TokenService(); psTransferAmt = psTransferAmt.StartsWith("0x") ? psTransferAmt.Replace("0x", "0") : psTransferAmt; var nAmtToSend = System.Numerics.BigInteger.Parse(psTransferAmt, System.Globalization.NumberStyles.HexNumber); var ERC20TransferFunction = new TransferFunction() { To = psToAccount, Value = nAmtToSend }; if (!String.IsNullOrEmpty(psGasToSend)) { var nGasToSend = System.Numerics.BigInteger.Parse(psGasToSend, System.Globalization.NumberStyles.HexNumber); ERC20TransferFunction.Gas = nGasToSend; } var trxReceipt = tokenService.TransferRequestAndWaitForReceiptAsync(ERC20TransferFunction).Result; return(trxReceipt.TransactionHash); }
public static async Task TransferAsync() { //Replace with your own var senderAddress = "0x12890d2cce102216644c59daE5baed380d84830c"; var receiverAddress = "0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe"; var privatekey = "0xb5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7"; var url = "ws://localhost:8546"; var web3 = new Web3.Web3(new Account(privatekey), new WebSocketClient(url)); var transactionMessage = new TransferFunction() { FromAddress = senderAddress, To = receiverAddress, TokenAmount = 100, //Set our own price GasPrice = Web3.Web3.Convert.ToWei(25, UnitConversion.EthUnit.Gwei) }; var transferHandler = web3.Eth.GetContractTransactionHandler <TransferFunction>(); /// this is done automatically so is not needed. var estimate = await transferHandler.EstimateGasAsync(ContractAddress, transactionMessage); transactionMessage.Gas = estimate.Value; var transactionHash = await transferHandler.SendRequestAsync(ContractAddress, transactionMessage); Console.WriteLine(transactionHash); }
/// <summary> /// Creates an IIR filter from zeros and poles. The zeros and poles must be made up of real and complex conjugate pairs. /// </summary> public IirFilter(ZeroPoleGain zeroPoleGain) { Debug.Assert(zeroPoleGain.Zeros.Length == zeroPoleGain.Poles.Length); this.zeroPoleGain = zeroPoleGain; transferFunction = FilterModifiers.ConvertSosToTransferFunction(sosGain); sosGain = FilterModifiers.ConvertZeroPoleToSosFilter(zeroPoleGain); this.sections = new FilterChain(sosGain.Sections); this.order = sosGain.Sections.Sum(x => x.Order); //Check whether this is linear phase double[] b = transferFunction.B; isLinearPhase = true; for (int i = 0; i < b.Length; i++) { if (b[i] != b[b.Length - 1 - i] && b[i] != -b[b.Length - 1 - i]) { isLinearPhase = false; break; } } return; }
TransferFunction SerializeToTransferFunction() { TransferFunction serTf = new TransferFunction(); serTf.type = 0; serTf.maskMax = -maxGameObject.transform.localPosition.y / 3.0f; serTf.maskMin = -minGameObject.transform.localPosition.y / 3.0f; serTf.points = new List <TfPoint>(); var pContainer = transform.Find("Points"); //Clear old foreach (Transform child in pContainer.transform) { //Position TfPoint tp = new TfPoint(); tp.pos = Mathf.Abs(child.localPosition.y / 3.0f); //Color Color colTemp = child.GetComponent <TransferFunctionSwatch>().selectedColor; tp.rgba = new Vector4(colTemp.r, colTemp.g, colTemp.b, colTemp.a); serTf.points.Add(tp); } return(serTf); }
public async Task <IHttpActionResult> estimatedGas(GasPayload gasdetails) { var context = new stakingapiEntities(); var metamaskdetails = context.stk_users.Where(x => x.metamask == gasdetails.metamask).FirstOrDefault(); if (metamaskdetails == null) { return(BadRequest("Invalid Wallet address")); } var keys = context.stk_admin.FirstOrDefault(); var account = new Account(keys.private_key); var web3 = new Nethereum.Web3.Web3(account, "https://mainnet.infura.io/v3/14063be7fce843b18bfbd7beae73caca"); var receiverAddress = gasdetails.metamask; var transferHandler = web3.Eth.GetContractTransactionHandler <TransferFunction>(); var transfer = new TransferFunction() { To = receiverAddress, TokenAmount = Web3.Convert.ToWei((BigDecimal)metamaskdetails.total_reward), GasPrice = Nethereum.Web3.Web3.Convert.ToWei(gasdetails.GasPrice, UnitConversion.EthUnit.Gwei), Gas = Convert.ToInt64(keys.gas_limit) }; var estimate = await transferHandler.EstimateGasAsync(keys.zinTokenAddress, transfer); return(Ok(estimate.Value)); }
/// <summary> /// This method implements weights update procedure for the output neurons /// Calculates delta/error and calls updateNeuronWeights to update neuron's weights /// for each output neuron /// </summary> /// <param name="outputError"> error vector for output neurons </param> protected internal virtual void calculateErrorAndUpdateOutputNeurons(double[] outputError) { int i = 0; // for all output neurons List <Neuron> outputNeurons = neuralNetwork.OutputNeurons; foreach (Neuron neuron in outputNeurons) { // if error is zero, just se;t zero error and continue to next neuron if (outputError[i] == 0) { neuron.Error = 0; i++; continue; } // otherwise calculate and set error/delta for the current neuron TransferFunction transferFunction = neuron.TransferFunction; double neuronInput = neuron.NetInput; double delta = outputError[i] * transferFunction.getDerivative(neuronInput); // delta = (d-y)*df(net) neuron.Error = delta; // and update weights of the current neuron this.updateNeuronWeights(neuron); i++; } // for }
private Button saveButton; // The button used to save the current transfer function /// <summary> /// Initialization function for the TransferFunctionHandler. /// </summary> void Start() { // Set up the reference to the VolumeController volumeController = (VolumeController)GameObject.Find("Main Camera").GetComponent(typeof(VolumeController)); // Initialize the reference to the transfer function stored in the volume controller transferFunction = volumeController.TransferFunction; // Initialize the panel script references alphaPanelHandler = (AlphaPanelHandler)alphaPanel.GetComponent(typeof(AlphaPanelHandler)); colorPanelHandler = (ColorPanelHandler)colorPanel.GetComponent(typeof(ColorPanelHandler)); colorPaletteHandler = (ColorPalette)colorPalettePanel.GetComponent(typeof(ColorPalette)); // Set up the transfer function loading drop down menu and load the first transfer function in the list if (transferFunction.IsovalueRange == 255) { savedTransferFunctionFolderPath = "Assets/Resources/TransferFunctions8Bit/"; } else { savedTransferFunctionFolderPath = "Assets/Resources/TransferFunctions16Bit/"; } transferFunctionFileExtension = ".txt"; Button loadButton = (GameObject.Find("Load Button").GetComponent <Button>()); Button saveButton = (GameObject.Find("Save Button").GetComponent <Button>()); // Load "Assets/Resources/TransferFunctions" files into a list of strings List <string> fileNames = new List <string>(Directory.GetFiles(savedTransferFunctionFolderPath, "*.txt")); // Trim the directories from the file names for (int i = 0; i < fileNames.Count; i++) { fileNames[i] = Path.GetFileNameWithoutExtension(fileNames[i]); } // Populate the dropdown menu with these OptionData objects if (fileNames.Count > 0) { // Add the list of files to the dropdown menu dropdownMenu.AddOptions(fileNames); // Set the currentTransferFunctionFile to the first one in the list currentTransferFunctionFile = fileNames[0]; // Load the control points from the currentTransferFunctionFile, if there is one loadTransferFunction(); } else { // Populate the dropdown menu with dropdownMenu.AddOptions(new List <string>(new string[] { "New Transfer Function" })); // Deactivate the load button loadButton.interactable = false; } // Reset the flag transferFunction.TransferFunctionChanged = true; }
public Task<TransactionReceipt> TransferRequestAndWaitForReceiptAsync(string to, BigInteger value, CancellationTokenSource cancellationToken = null) { var transferFunction = new TransferFunction(); transferFunction.To = to; transferFunction.Value = value; return ContractHandler.SendRequestAndWaitForReceiptAsync(transferFunction, cancellationToken); }
public string jsonString() { currentTransferFunction = SerializeToTransferFunction(); lastSentTransferFunction = currentTransferFunction; string json = currentTransferFunction.json(); return(json); }
public TransferFunction loadTransferFunction(string filename) { Debug.LogWarning("No loading for Megamol tfs"); TransferFunction tf = new TransferFunction(); tf.points = new List <TfPoint>(); return(tf); }
public Task<string> TransferRequestAsync(string to, BigInteger value) { var transferFunction = new TransferFunction(); transferFunction.To = to; transferFunction.Value = value; return ContractHandler.SendRequestAsync(transferFunction); }
static void Main(string[] args) { int[] layerSizes = new int[3] { 2, 2, 1 }; TransferFunction[] tFuncs = new TransferFunction[3] { TransferFunction.None, TransferFunction.Sigmoid, TransferFunction.Linear }; BackPropagation bpn = new BackPropagation(layerSizes, tFuncs); double[][] input, output; input = new double[4][]; output = new double[4][]; for (int i = 0; i < 4; i++) { input[i] = new double[2]; output[i] = new double[1]; } input[0][0] = 0.0; input[0][1] = 0.0; output[0][0] = 0.0; // Case 1 F xor F = F input[1][0] = 1.0; input[1][1] = 0.0; output[1][0] = 1.0; // Case 2 T xor F = T input[2][0] = 0.0; input[2][1] = 1.0; output[2][0] = 1.0; // Case 3 F xor T = T input[3][0] = 1.0; input[3][1] = 1.0; output[3][0] = 0.0; // Case 4 T xor T = F // Train double error = 0.0; int max_count = 10000, count = 0; do { // Prepare training epoch count++; error = 0.0; // Train for (int i = 0; i < 4; i++) { // TrainRate and Momentm picked arbitrarilly error += bpn.Train(ref input[i], ref output[i], 0.15, 0.10); } // Show Progress if (count % 100 == 0) { Console.WriteLine("Epoch {0} completed with error {1:0.0000}", count, error); } } while (error > 0.0001 && count <= max_count); // Display results double[] networkOutput = new double[1]; for (int i = 0; i < 4; i++) { bpn.Run(ref input[i], out networkOutput); Console.WriteLine("Case {3}: {0:0.0} xor {1:0.0} = {2:0.0000}", input[i][0], input[i][1], networkOutput[0], i + 1); } // End Program Console.WriteLine("Press Enter ..."); Console.ReadLine(); }
public BackPropagationNetwork(int[] initLayerSizes, TransferFunction[] initTransferFunctions) { //Validate the input data if (initTransferFunctions.Length != initLayerSizes.Length || initTransferFunctions[0] != TransferFunction.None) throw new ArgumentException("Invalid parameters"); NetworkName = "Default"; _initLayerSizes = initLayerSizes; _initTransferFunctions = initTransferFunctions; Initialize(); //Initialize weights RandomizeWeights(); }
public static double EvaluateDerivative(TransferFunction transferFunction, double input) { switch (transferFunction) { case TransferFunction.Sigmoid: return SigmoidDerivative(input); case TransferFunction.Linear: return LinearDerivative(input); case TransferFunction.Gaussian: return GaussianDerivative(input); case TransferFunction.RationalSigmoid: return RationalSigmoidDerivative(input); case TransferFunction.Convolution: return ConvolutionDerivative(input); default: return 0.0; } }
public static double Evaluate(TransferFunction tFunc, double m_transferFunction) { switch (tFunc) { case TransferFunction.Sigmoid: return Sigmoid(m_transferFunction); case TransferFunction.Linear: return Linear(m_transferFunction); case TransferFunction.Gaussian: return Gaussian(m_transferFunction); case TransferFunction.RationalSigmoid: return RationalSigmoid(m_transferFunction); case TransferFunction.None: default: return 0.0; } }
public static float EvaluateDerivative(TransferFunction tFunc, float input) { switch (tFunc) { case TransferFunction.Sigmoid: return sigmoid_derivative(input); case TransferFunction.Linear: return linear_derivative(input); case TransferFunction.Gaussian: return gaussian_derivative(input); case TransferFunction.RationalSigmoid: return rationalsigmoid_derivative(input); case TransferFunction.None: default: return 0.0f; } }
public void CanTrainNetwork() { //XOR data DataPoint _dp1 = new DataPoint(new[] { 1.0, 1.0 }, new[] { 0.0 }); DataPoint _dp2 = new DataPoint(new[] { 1.0, 0.0 }, new[] { 1.0 }); DataPoint _dp3 = new DataPoint(new[] { 0.0, 1.0 }, new[] { 1.0 }); DataPoint _dp4 = new DataPoint(new[] { 0.0, 0.0 }, new[] { 0.0 }); DataPointCollection _dataPointCollection = new DataPointCollection(); _dataPointCollection.Add(_dp1); _dataPointCollection.Add(_dp2); _dataPointCollection.Add(_dp3); _dataPointCollection.Add(_dp4); int[] _layerSizes = new int[3] { 2, 2, 1 }; TransferFunction[] _transferFunctions = new TransferFunction[3] { TransferFunction.None, TransferFunction.Sigmoid, TransferFunction.Linear }; BackPropagationNetwork _bpn = new BackPropagationNetwork(_layerSizes, _transferFunctions); SimpleNetworkTrainer _networkTrainer = new SimpleNetworkTrainer(_bpn, _dataPointCollection); _networkTrainer.TargetError = 0.0001; _networkTrainer.MaxIterations = 1000000; _networkTrainer.NudgeScale = 0.8; _networkTrainer.NudgeWindow = 100; _networkTrainer.TrainNetwork(); Assert.IsTrue(true, "Never Reached Minimum Error"); for (int i = _networkTrainer.ErrorHistory.Count - 100; i < _networkTrainer.ErrorHistory.Count; i++) { Console.WriteLine("{0}: {1:0.00000000}", i, _networkTrainer.ErrorHistory[i]); } }
/// <summary> /// Converts two zeros and two poles into a second-order section. Assumes the final coefficients will be real. /// </summary> /// <param name="zeros"></param> /// <param name="poles"></param> public Sos(ZeroPoleGain zeroPoleGain) { Complex[] zeros = zeroPoleGain.Zeros; Complex[] poles = zeroPoleGain.Poles; //!!Does this really need to be true? if (zeros.Length != poles.Length) throw new Exception("There must be equal numbers of poles and zeros."); int order = zeros.Length; if (order != 1 && order != 2) throw new Exception("There must be either one or two zeros and poles."); //!! Make sure the zeros and poles are real or conjugate pairs this.data = new double[order]; this.zeroPoleGain = zeroPoleGain; this.transferFunction = ConvertZeroPoleToTransferFunction(this.zeroPoleGain); return; }
public BasicNeuralNetworkTrainerWrapper(DataPointCollection dataSet) { DataSet = dataSet; int[] layerSizes = new int[10] { DataSet.DataPointBound, 5, 5, 5, 5, 5, 5, 5, 3, 1 }; TransferFunction[] transferFunctions = new TransferFunction[10] { TransferFunction.None, TransferFunction.RationalSigmoid, TransferFunction.RationalSigmoid, TransferFunction.Sigmoid, TransferFunction.Sigmoid, TransferFunction.Sigmoid, TransferFunction.Sigmoid, TransferFunction.Gaussian, TransferFunction.Gaussian, TransferFunction.Linear }; Network.Initialize(layerSizes, transferFunctions); _network = new BackPropagationNetwork(layerSizes, transferFunctions); _networkTrainer = new SimpleNetworkTrainer(_network, DataSet); }
/// <summary> /// Creates an FIR filter from the transfer function. /// </summary> public FirFilter(TransferFunction transferFunction) { if (transferFunction.A.Length > 0) throw new ArgumentException("An FIR filter cannot have any transfer function coefficients in the denominator."); this.transferFunction = transferFunction; this.order = transferFunction.B.Length - 1; this.data = (Queue<double>)Enumerable.Repeat(0, order); //!! //Check whether this is linear phase double[] b = transferFunction.B; isLinearPhase = true; for (int i = 0; i < b.Length; i++) { if (b[i] != b[b.Length - 1 - i] && b[i] != -b[b.Length - 1 - i]) { isLinearPhase = false; break; } } return; }
public Sos(string matlabCoefs) { data = new double[2]; double[] b = new double[3]; double[] a = new double[3]; char[] delimiters = { ' ' }; string[] nums = matlabCoefs.Split(delimiters, StringSplitOptions.RemoveEmptyEntries); Debug.Assert(nums.Length == 6); b[0] = float.Parse(nums[0]); b[1] = float.Parse(nums[1]); b[2] = float.Parse(nums[2]); a[0] = float.Parse(nums[3]); a[1] = float.Parse(nums[4]); a[2] = float.Parse(nums[5]); this.transferFunction = new TransferFunction(b, a); // Get zero-pole-gain form throw new NotImplementedException(); return; }
private double[][][] m_weight; // Weights for each connection #endregion Fields #region Constructors public NeuralNetwork(int[] layerSizes, TransferFunction[] transferFunctions) { // Validate the input data if (transferFunctions.Length != layerSizes.Length || transferFunctions[0] != TransferFunction.None) throw new ArgumentException("Cannot construct a network with these parameters."); // Initialize network layers m_layerCount = layerSizes.Length - 1; m_inputSize = layerSizes[0]; m_layerSize = new int[m_layerCount]; for (int i = 0; i < m_layerCount; i++) m_layerSize[i] = layerSizes[i + 1]; m_transferFunction = new TransferFunction[m_layerCount]; for (int i = 0; i < m_layerCount; i++) m_transferFunction[i] = transferFunctions[i + 1]; // Start dimensioning arrays m_bias = new double[m_layerCount][]; m_perviousBiasDelta = new double[m_layerCount][]; m_delta = new double[m_layerCount][]; m_layerOutput = new double[m_layerCount][]; m_layerInput = new double[m_layerCount][]; m_weight = new double[m_layerCount][][]; m_previousWeightDelta = new double[m_layerCount][][]; // Fill 2 dimensional arrays for (int l = 0; l < m_layerCount; l++) { m_bias[l] = new double[m_layerSize[l]]; m_perviousBiasDelta[l] = new double[m_layerSize[l]]; m_delta[l] = new double[m_layerSize[l]]; m_layerOutput[l] = new double[m_layerSize[l]]; m_layerInput[l] = new double[m_layerSize[l]]; m_weight[l] = new double[l == 0 ? m_inputSize : m_layerSize[l - 1]][]; m_previousWeightDelta[l] = new double[l == 0 ? m_inputSize : m_layerSize[l - 1]][]; for (int i = 0; i < (l == 0 ? m_inputSize : m_layerSize[l - 1]); i++) { m_weight[l][i] = new double[m_layerSize[l]]; m_previousWeightDelta[l][i] = new double[m_layerSize[l]]; } } // Initialize the weights for (int l = 0; l < m_layerCount; l++) { for (int j = 0; j < m_layerSize[l]; j++) { m_bias[l][j] = Gaussian.GetRandomGaussian(); m_perviousBiasDelta[l][j] = 0.0; m_layerOutput[l][j] = 0.0; m_layerInput[l][j] = 0.0; m_delta[l][j] = 0.0; } for (int i = 0; i < (l == 0 ? m_inputSize : m_layerSize[l - 1]); i++) { for (int j = 0; j < m_layerSize[l]; j++) { m_weight[l][i][j] = Gaussian.GetRandomGaussian(); m_previousWeightDelta[l][i][j] = 0.0; } } } }
public void Initialize(int[] layerSizes, TransferFunction[] layerFunctions) { _network = new BackPropagationNetwork(layerSizes, layerFunctions); }
public void Load(string filePath) { if (filePath == null) throw new ArgumentException("filePath"); if (!File.Exists(filePath)) throw new FileNotFoundException("filePath Not Found", filePath); _networkDefinition = new XmlDocument(); _networkDefinition.Load(filePath); string basePath = String.Empty; string nodePath = String.Empty; // Load from xml if (XPathValue("NeuralNetwork/@Type") != "BackPropagation") throw new ApplicationException("NeuralNetwork definition not found."); basePath = "NeuralNetwork/Parameters/"; NetworkName = XPathValue(basePath + "NetworkName"); InputSize = Convert.ToInt32(XPathValue(basePath + "InputSize")); LayerCount = Convert.ToInt32(XPathValue(basePath + "LayerCount")); LayerSizes = new int[LayerCount]; TransferFunctions = new TransferFunction[LayerCount]; basePath = basePath + "Layers/Layer"; for (int l = 0; l < LayerCount; l++) { LayerSizes[l] = Convert.ToInt32(XPathValue(basePath + "[@Index='" + l.ToString() + "']/@Size")); TransferFunctions[l] = (TransferFunction)Enum.Parse(typeof(TransferFunction), XPathValue(basePath + "[@Index='" + l.ToString() + "']/@Type")); } // Parse weights LayerInput = new double[LayerCount][]; LayerOutput = new double[LayerCount][]; Delta = new double[LayerCount][]; Bias = new double[LayerCount][]; PreviousBiasDelta = new double[LayerCount][]; Weight = new double[LayerCount][][]; PreviousWeightDelta = new double[LayerCount][][]; for (int l = 0; l < LayerCount; l++) { //Fill 2 dimensional array LayerInput[l] = new double[LayerSizes[l]]; LayerOutput[l] = new double[LayerSizes[l]]; Delta[l] = new double[LayerSizes[l]]; Bias[l] = new double[LayerSizes[l]]; PreviousBiasDelta[l] = new double[LayerSizes[l]]; //Fill 3 dimensional array Weight[l] = new double[l == 0 ? InputSize : LayerSizes[l - 1]][]; PreviousWeightDelta[l] = new double[l == 0 ? InputSize : LayerSizes[l - 1]][]; for (int i = 0; i < (l == 0 ? InputSize : LayerSizes[l - 1]); i++) { Weight[l][i] = new double[LayerSizes[l]]; PreviousWeightDelta[l][i] = new double[LayerSizes[l]]; } } //Initialize weights for (int l = 0; l < LayerCount; l++) { basePath = "NeuralNetwork/Weights/Layer[@Index='" + l.ToString() + "']/"; for (int j = 0; j < LayerSizes[l]; j++) { nodePath = "Node[@Index='" + j.ToString() + "']/@Bias"; Bias[l][j] = Convert.ToDouble(XPathValue(basePath + nodePath)); LayerOutput[l][j] = 0.0; LayerInput[l][j] = 0.0; PreviousBiasDelta[l][j] = 0.0; Delta[l][j] = 0.0; } for (int i = 0; i < (l == 0 ? InputSize : LayerSizes[l - 1]); i++) { for (int j = 0; j < LayerSizes[l]; j++) { nodePath = "Node[@Index='" + j.ToString() + "']/Axon[@Index='" + i.ToString() + "']"; Weight[l][i][j] = Convert.ToDouble(XPathValue(basePath + nodePath)); PreviousWeightDelta[l][i][j] = 0.0; } } } // release _networkDefinition = null; }
static ZeroPoleGain ConvertTransferFunctionToZeroPole(TransferFunction transferFunction) { throw new NotImplementedException(); Complex[] zeros = new Complex[2]; Helpers.PolyToRoots(transferFunction.B[0], transferFunction.B[1], transferFunction.B[2], out zeros[0], out zeros[1]); Complex[] poles = new Complex[2]; Helpers.PolyToRoots(transferFunction.A[0], transferFunction.A[1], transferFunction.A[2], out poles[0], out poles[1]); }