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]);
}
