static void RMain(string[] args)
{
REngine.SetEnvironmentVariables();
// There are several options to initialize the engine, but by default the following suffice:
using (REngine engine = REngine.GetInstance())
{
// .NET Framework array to R vector.
NumericVector group1 = engine.CreateNumericVector(new double[] { 30.02, 29.99, 30.11, 29.97, 30.01, 29.99 });
engine.SetSymbol("group1", group1);
// Direct parsing from R script.
NumericVector group2 = engine.Evaluate("group2 <- c(29.89, 29.93, 29.72, 29.98, 30.02, 29.98)").AsNumeric();
// Test difference of mean and get the P-value.
GenericVector testResult = engine.Evaluate("t.test(group1, group2)").AsList();
double p = testResult["p.value"].AsNumeric().First();
Console.WriteLine("Group1: [{0}]", string.Join(", ", group1));
Console.WriteLine("Group2: [{0}]", string.Join(", ", group2));
Console.WriteLine("P-value = {0:0.000}", p);
// you should always dispose of the REngine properly.
// After disposing of the engine, you cannot reinitialize nor reuse it
// engine.Dispose();
} // End Using engine
} // End Sub RMain
static void Main(string[] args)
{
// Set the folder in which R.dll locates.
var envPath = Environment.GetEnvironmentVariable("PATH");
var rBinPath = @"C:\Program Files (x86)\R\R-2.11.1\bin";
//var rBinPath = @"C:\Program Files\R\R-2.11.1-x64\bin"; // Doesn't work ("DLL was not found.")
Environment.SetEnvironmentVariable("PATH", envPath + Path.PathSeparator + rBinPath);
using (REngine engine = REngine.CreateInstance("RDotNet"))
{
// Initializes settings.
engine.Initialize();
// .NET Framework array to R vector.
NumericVector group1 = engine.CreateNumericVector(new double[] { 30.02, 29.99, 30.11, 29.97, 30.01, 29.99 });
engine.SetSymbol("group1", group1);
// Direct parsing from R script.
NumericVector group2 = engine.Evaluate("group2 <- c(29.89, 29.93, 29.72, 29.98, 30.02, 29.98)").AsNumeric();
// Test difference of mean and get the P-value.
GenericVector testResult = engine.Evaluate("t.test(group1, group2)").AsList();
double p = testResult["p.value"].AsNumeric().First();
Console.WriteLine("Group1: [{0}]", string.Join(", ", group1));
Console.WriteLine("Group2: [{0}]", string.Join(", ", group2));
Console.WriteLine("P-value = {0:0.000}", p);
}
}
internal Dictionary <string, object> GetReturnObject(GenericVector gv)
{
Dictionary <string, object> res = new Dictionary <string, object>();
for (int i = 0; i < gv.Length; i++)
{
switch (gv[i].Type)
{
case RDotNet.Internals.SymbolicExpressionType.CharacterVector:
res.Add(gv.Names[i], gv[i].AsCharacter().ToArray());
break;
case RDotNet.Internals.SymbolicExpressionType.List:
res.Add(gv.Names[i], ToMatrix(gv[0].AsDataFrame()));
break;
case RDotNet.Internals.SymbolicExpressionType.NumericVector:
res.Add(gv.Names[i], gv[i].AsNumeric().ToArray());
break;
case RDotNet.Internals.SymbolicExpressionType.IntegerVector:
res.Add(gv.Names[i], gv[i].AsInteger().ToArray());
break;
}
}
return(res);
}
static void Main(string[] args)
{
REngine.SetEnvironmentVariables(@"c:\Program Files\Microsoft\R Client\R_SERVER\bin\x64\", @"c:\Program Files\Microsoft\R Client\R_SERVER\"); // <-- May be omitted; the next line would call it.
REngine engine = REngine.GetInstance();
// A somewhat contrived but customary Hello World:
//CharacterVector charVec = engine.CreateCharacterVector(new[] { "Hello, R world!, .NET speaking" });
//engine.SetSymbol("greetings", charVec);
//engine.Evaluate("str(greetings)"); // print out in the console
//string[] a = engine.Evaluate("'Hi there .NET, from the R engine'").AsCharacter().ToArray();
//Console.WriteLine("R answered: '{0}'", a[0]);
//Console.WriteLine("Press any key to exit the program");
//Console.ReadKey();
// .NET Framework array to R vector.
NumericVector group1 = engine.CreateNumericVector(new double[] { 30.02, 29.99, 30.11, 29.97, 30.01, 29.99 });
engine.SetSymbol("group1", group1);
// Direct parsing from R script.
NumericVector group2 = engine.Evaluate("group2 <- c(29.89, 29.93, 29.72, 29.98, 30.02, 29.98)").AsNumeric();
// Test difference of mean and get the P-value.
GenericVector testResult = engine.Evaluate("t.test(group1, group2)").AsList();
double p = testResult["p.value"].AsNumeric().First();
Console.WriteLine("Group1: [{0}]", string.Join(", ", group1));
Console.WriteLine("Group2: [{0}]", string.Join(", ", group2));
Console.WriteLine("P-value = {0:0.000}", p);
Console.ReadKey();
engine.Dispose();
}
private int GetNearestCluster(GenericVector v)
{
return(_centroids
.OrderBy(centroid => GenericVector.Distance(centroid.Value, v))
.Select(centroid => centroid.Key)
.First());
}
/// <summary>
/// Run PCA in R engine
/// </summary>
static void PCAR()
{
const string directoryPath = @"C:\Users\Káťa\Desktop\Diplomka\mesh\meshes";
var matrix = loadFacesR(directoryPath);
REngine.SetEnvironmentVariables();
REngine engine = REngine.GetInstance();
NumericMatrix group1 = engine.CreateNumericMatrix(matrix);
engine.SetSymbol("group1", group1);
GenericVector testResult = engine.Evaluate("pr.out=prcomp(group1, scale=TRUE)").AsList();
var eigenVec = testResult["x"].AsNumericMatrix();
engine.Evaluate("pr.out$sdev");
engine.Evaluate("pr.var = pr.out$sdev ^ 2");
engine.Evaluate("pr.var");
engine.Evaluate("pve = pr.var / sum(pr.var)");
engine.Evaluate("pve");
engine.Evaluate("plot(cumsum(pve), xlab='Principal Component', ylab='Cumulative Proportion of Variance Explained', ylim=c(0,1),type='b')");
saveVector(eigenVec);
// var eigenVec = testResult["pr.out&x"].AsNumericMatrix();
Console.ReadLine();
}
/// <summary>
/// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
/// </summary>
public override void Initialize()
{
SetStartDate(2013, 10, 07); //Set Start Date
SetEndDate(2013, 10, 11); //Set End Date
SetCash(100000); //Set Strategy Cash
// Find more symbols here: http://quantconnect.com/data
AddEquity("SPY", Resolution.Second);
REngine engine = REngine.GetInstance();
engine.Evaluate("print('This is from R command.')");
// .NET Framework array to R vector.
NumericVector group1 = engine.CreateNumericVector(new double[] { 30.02, 29.99, 30.11, 29.97, 30.01, 29.99 });
engine.SetSymbol("group1", group1);
// Direct parsing from R script.
NumericVector group2 = engine.Evaluate("group2 <- c(29.89, 29.93, 29.72, 29.98, 30.02, 29.98)").AsNumeric();
// Test difference of mean and get the P-value.
GenericVector testResult = engine.Evaluate("t.test(group1, group2)").AsList();
double p = testResult["p.value"].AsNumeric().First();
// you should always dispose of the REngine properly.
// After disposing of the engine, you cannot reinitialize nor reuse it
engine.Dispose();
}
/// <summary>
/// Fits the series to model.
/// </summary>
/// <param name="JSONdataWithWeather">The jso ndata with weather.</param>
/// <param name="modelName">Name of the model.</param>
/// <param name="fittedDataName">Name of the fitted data.</param>
/// <param name="weatherColumns">The weather columns.</param>
/// <returns></returns>
public List <Consuption> fitSeriesToModel(string JSONdataWithWeather, string modelName, string fittedDataName, WeatherColumns weatherColumns)
{
string evaluate;
const string fittingDataName = "dataName";
evaluate = string.Format("{0} <-fromJSON(\'{1}\')", fittingDataName, JSONdataWithWeather);
var sourceData = rEngine.Evaluate(evaluate);
CreateWeatherMatrix(fittingDataName, weatherColumns);
evaluate = string.Format("{0} <- forecast::Arima({1}$Amount,xreg = {2},model={3})", fittedDataName, fittingDataName, WEATHERMATRIX, modelName);
//evaluate = string.Format("{0} <- forecast::Arima({1}$Amount,xreg = {2})", fittedDataName, fittingDataName, WEATHERMATRIX, modelName);
var result = rEngine.Evaluate(evaluate);
GenericVector resultList = result.AsList();
var fittedValuesList = resultList["residuals"].AsNumeric().ToList();
var sourceDates = rEngine.Evaluate("sourceDates <- " + fittingDataName + "$IDDate").AsList();
var sourceAmounts =
rEngine.Evaluate("sourceDates <- " + fittingDataName + "$Amount").AsList();
List <Consuption> retList = new List <Consuption>();
for (int i = 0; i < fittedValuesList.Count; i++)
{
Consuption c = new Consuption();
c.Amount = (float)fittedValuesList[i] + (float)sourceAmounts.AsNumeric().ElementAt(i);
c.IDDate = sourceDates.AsInteger().ElementAt(i);
retList.Add(c);
}
return(retList);
//List<double> returnList = result.AsList();
}
private void HiSquare(List <int> activeVariables1, List <int> activeVariables2)
{
Header();
wrange.Text = "Hi-square:";
wrange.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphLeft;
worddoc.Paragraphs.Add();
wrange = worddoc.Paragraphs[iter++].Range;
wrange.Font.Size = 14;
wrange.Font.Bold = 0;
wrange.Text = "";
latexText += "\n\\section{Hi-square}" +
"\n\\begin{frame}\\frametitle{Хи-квадрат}" +
"\n\\begin{itemize}\n\\item";
for (int k = 0; k < activeVariables1.Count(); k++)
{
wrange.Text += "\n" + (k + 1) + ". Рассматривается зависимость \"" + nameVars[activeVariables1[k]] + "\" от:";
for (int l = 0; l < activeVariables2.Count(); l++)
{
GenericVector XSZ = engine.Evaluate("Xsquared <- chisq.test(table(dataset$" + nameVars[activeVariables2[l]] + ",dataset$" + nameVars[activeVariables1[k]] + "))").AsList();
double xsSZ = XSZ["statistic"].AsNumeric()[0];
double pxSZ = engine.Evaluate("Xsquared$p.value").AsNumeric()[0];
wrange.Text += "\n\t" + (l + 1) + ") \"" + nameVars[activeVariables2[l]] + "\": X-squared = " + Math.Round(xsSZ, 2).ToString()
+ "; p-value = " + Math.Round(pxSZ, 3).ToString() + ";";
}
}
wrange.Font.Bold = 0;
for (int st = iter; iter++ <= st + activeVariables1.Count() * activeVariables2.Count(); worddoc.Paragraphs.Add())
{
;
}
Conclusion();
latexText += "\n\\end{itemize}" +
"\n\\end{frame}";
}
//
// GET: /Home/
public ActionResult Index()
{
REngine.SetEnvironmentVariables();
REngine engine = REngine.GetInstance();
engine.Initialize();
NumericVector group1 = engine.CreateNumericVector(new double[] { 30.02, 29.99, 30.11, 29.97, 30.01, 29.99 });
engine.SetSymbol("group1", group1);
// Direct parsing from R script.
NumericVector group2 = engine.Evaluate("group2 <- c(29.89, 29.93, 29.72, 29.98, 30.02, 29.98)").AsNumeric();
// Test difference of mean and get the P-value.
GenericVector testResult = engine.Evaluate("t.test(group1, group2)").AsList();
double p = testResult["p.value"].AsNumeric().First();
Console.WriteLine("Group1: [{0}]", string.Join(", ", group1));
Console.WriteLine("Group2: [{0}]", string.Join(", ", group2));
Console.WriteLine("P-value = {0:0.000}", p);
// you should always dispose of the REngine properly.
// After disposing of the engine, you cannot reinitialize nor reuse it
engine.Dispose();
return(View());
}
public IEnumerable <VmResourceForecast> RunAlgorythms(IEnumerable <VmResourceTrace> traces)
{
var timer = new Stopwatch();
var windowsCount = traces.First().Series.Count() - Params.MinTraceWindow + 1;
var splitedTraces = traces.GroupBy(t => t.Series.Count(v => v > 0) >= 2).ToDictionary(p => p.Key ? 1 : 0, p => p.ToArray());
var zeroResult = Enumerable.Range(0, windowsCount).Select(i => new ForecastResult(i, Enumerable.Repeat <float>(0, Params.PrognoseDepth).ToArray()));
var zeroSeriesResult = splitedTraces[0]
.Select(s => new VmResourceForecast(s.VmId, s.Resource, new Dictionary <string, IEnumerable <ForecastResult> >()
{
{ "ARIMA", zeroResult },
{ "SES", zeroResult },
{ "CROST", zeroResult },
{ "HOLT", zeroResult },
{ "DHOLT", zeroResult }
}));
var inputList = new GenericVector(R, splitedTraces[1].Select(ConvertToRList));
R.SetSymbol(InputListName, inputList);
timer.Start();
var result = R.Evaluate($"foreach(i = {InputListName}) %dopar% {ProccessTraceFunction}(i, {Params.MinTraceWindow}, {windowsCount})");
timer.Stop();
Debug.WriteLine($"{traces.Count()} with {windowsCount} windows evaluated in {timer.ElapsedMilliseconds}ms");
return(result.AsList().Select(r => ReadRList(r.AsList())).Concat(zeroSeriesResult));
}
private void TTest(List <int> activeVariables1, List <int> activeVariables2)
{
Header();
wrange.Text = "T-TEST:";
wrange.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphLeft;
worddoc.Paragraphs.Add();
wrange = worddoc.Paragraphs[iter++].Range;
wrange.Font.Size = 14;
wrange.Font.Bold = 0;
latexText += "\n\\section{T-test}" +
"\n\\begin{frame}\\frametitle{Т-тест}" +
"\n\\begin{itemize}\n\\item";
for (int k = 0; k < activeVariables1.Count(); k++)
{
wrange.Text += "\n" + (k + 1) + ". Проведем t-test для \"" + nameVars[activeVariables1[k]] + "\" и:";
for (int l = 0; l < activeVariables2.Count(); l++)
{
GenericVector testResAge = engine.Evaluate("ttest <- t.test(dataset$" + nameVars[activeVariables2[l]] + " ~ dataset$" + nameVars[activeVariables1[k]] + ")").AsList();
double tAge = testResAge["statistic"].AsNumeric()[0];
double pAge = engine.Evaluate("ttest$p.value").AsNumeric()[0];
wrange.Text += "\n\t" + (l + 1) + ") \"" + nameVars[activeVariables2[l]] + "\": t-value = " + Math.Round(tAge, 2).ToString()
+ "; p-value = " + Math.Round(pAge, 3).ToString() + ";";
}
}
wrange.Font.Bold = 0;
for (int st = iter; iter++ <= st + activeVariables1.Count() * activeVariables2.Count(); worddoc.Paragraphs.Add())
{
;
}
Conclusion();
latexText += "\n\\end{itemize}" +
"\n\\end{frame}";
}
private void MannWitny(List <int> activeVariables1, List <int> activeVariables2)
{
Header();
wrange.Text = "Mann-Witny:";
wrange.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphLeft;
worddoc.Paragraphs.Add();
wrange = worddoc.Paragraphs[iter++].Range;
wrange.Font.Size = 14;
latexText += "\n\\section{MannWitny}" +
"\n\\begin{frame}\\frametitle{Тест Манна-Уитни}" +
"\n\\begin{itemize}\n\\item";
for (int k = 0; k < activeVariables1.Count(); k++)
{
wrange.Text += "\n" + (k + 1) + ". Рассматривается зависимость \"" + nameVars[activeVariables1[k]] + "\" от:";
for (int l = 0; l < activeVariables2.Count(); l++)
{
GenericVector MWtAge = engine.Evaluate("mannWetney <- wilcox.test(dataset$" + nameVars[activeVariables2[l]] + " ~ dataset$" + nameVars[activeVariables1[k]] + ", paired = FALSE)").AsList();
double wAge = MWtAge["statistic"].AsNumeric()[0];
double pwAge = engine.Evaluate("mannWetney$p.value").AsNumeric()[0];
wrange.Text += "\n\t" + (l + 1) + ") \"" + nameVars[activeVariables2[l]] + "\": W = " + Math.Round(wAge, 2).ToString()
+ "; p-value = " + Math.Round(pwAge, 3).ToString() + ";";
}
}
wrange.Font.Bold = 0;
for (int st = iter; iter++ <= st + activeVariables1.Count() * activeVariables2.Count(); worddoc.Paragraphs.Add())
{
;
}
Conclusion();
latexText += "\n\\end{itemize}" +
"\n\\end{frame}";
}
public static void TestRenderFrames()
{
RenderBuffer <float> buffer = new RenderBuffer <float>(CRenderSettings.RenderWidth, CRenderSettings.RenderHeight, 3);
CharRenderBuffer <float> charBuffer = new CharRenderBuffer <float>(buffer);
float framerate = 25f;
float time = 10f;
int totalFrame = (int)(framerate * time);
int frameInterval = (int)(1000f / framerate);
GenericVector <float> white = new GenericVector <float>(3)
{
1, 1, 1
};
GenericVector <float> black = new GenericVector <float>(3)
{
0, 0, 0
};
int lastU = 0;
int step = totalFrame / buffer.Width + 1;
for (int i = 0; i < totalFrame; i++)
{
if (i / step > lastU)
{
buffer.WritePixel(lastU, 0, black);
buffer.WritePixel(++lastU, 0, white);
}
Thread.Sleep(frameInterval);
CRenderer.Render(charBuffer);
}
}
static void Main(string[] args)
{
REngine.SetEnvironmentVariables();
REngine engine = REngine.GetInstance();
// REngine requires explicit initialization.
// You can set some parameters.
engine.Initialize();
// .NET Framework array to R vector.
NumericVector group1 = engine.CreateNumericVector(new double[] { 30.02, 29.99, 30.11, 29.97, 30.01, 29.99 });
engine.SetSymbol("group1", group1);
// Direct parsing from R script.
NumericVector group2 = engine.Evaluate("group2 <- c(29.89, 29.93, 29.72, 29.98, 30.02, 29.98)").AsNumeric();
// Test difference of mean and get the P-value.
GenericVector testResult = engine.Evaluate("t.test(group1, group2)").AsList();
double p = testResult["p.value"].AsNumeric().First();
Console.WriteLine("Group1: [{0}]", string.Join(", ", group1));
Console.WriteLine("Group2: [{0}]", string.Join(", ", group2));
Console.WriteLine("P-value = {0:0.000}", p);
// you should always dispose of the REngine properly.
// After disposing of the engine, you cannot reinitialize nor reuse it
engine.Dispose();
}
public void test_NextItem_P(int numofItems, ModelNames.Models paramModel, ModelNames.CriterionTypes paramCriterion)
{
resultFlag = true;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Polytomous Items
CharacterVector modelName = engineObj.CreateCharacterVector(new string[] { paramModel.EnumToString() });
engineObj.SetSymbol("modelName", modelName);
DataFrame PolyItems = engineObj.Evaluate("PolyItems <- genPolyMatrix(" + numofItems + ", 5, model = modelName, same.nrCat = TRUE)").AsDataFrame();
engineObj.SetSymbol("PolyItems", PolyItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
Console.WriteLine("*******************************************");
Console.WriteLine("Polytomous Items, Model : " + paramModel.EnumToString());
Console.WriteLine("*******************************************");
CATItems itemBank = new CATItems(PolyItems[0].Length, paramModel.EnumToString(), 5);
Tuple <CATItems.ColumnNames, int>[] cols = itemBank.GetKeys();
for (int i = 0; i < cols.Length; i++)
{
itemBank.SetItemParamter(cols[i], PolyItems[i].Select(y => (double)y).ToArray());
}
// Call "NextItem" function from R
GenericVector r_NextItem = engineObj.Evaluate("r_NextItem <- nextItem(PolyItems, model = modelName, theta = 0, criterion = \"" + paramCriterion.ToString() + "\")").AsList();
// Selected item
NumericVector item = r_NextItem[0].AsNumeric();
DataFrame par = r_NextItem[1].AsDataFrame();
// Value of "info"
NumericVector thStart = r_NextItem[2].AsNumeric();
// Criterion
CharacterVector startSelect = r_NextItem[3].AsCharacter();
// Call "NextItem" function from CS
NextItemModel cs_NextItem = CatRLib.NextItem(itemBank, model: paramModel.EnumToString(), theta: 0, criterion: (int)paramCriterion);
//Test passed for "MFI"
if (item[0] != cs_NextItem.item)
{
resultFlag = false;
}
Assert.IsTrue(resultFlag);
}
private IEnumerable <ForecastResult> ParseForecastResult(GenericVector list) =>
list.Select(exp => exp.AsList())
.Select(r => {
var offset = r["offset"].AsInteger()[0];
var r_reslult = r["result"].AsNumeric();
float[] result = double.IsNaN(r_reslult[0]) ? null : r_reslult.Select(f => (float)f).ToArray();
return(new ForecastResult(offset, result));
}).Where(x => x.Result != null);
public static GenericVector <float> Lerp(float value, GenericVector <float> from, GenericVector <float> to)
{
for (int i = 0; i < from.Length; i++)
{
from[i] = Lerp(value, from[i], to[i]);
}
return(from);
}
//---------------------------------------------------------------------
public void Deserialize(Stream Stream_in)
{
BinaryFormatter formatter = new BinaryFormatter();
GenericVector <T> vector = (GenericVector <T>)formatter.Deserialize(Stream_in);
this.CopyFromArray(vector.ToArray());
return;
}
public ListConverter(GenericVector sexp, IDataConverter converter)
{
var array = sexp.ToArray();
_length = sexp.Length;
_intersectedItemType = null;
_converters = new IConverter[_length];
for (var i = 0; i < _length; i++)
{
_converters[i] = converter.GetConverter(array[i].DangerousGetHandle().ToInt64());
if (_converters[i] == null)
{
throw new InvalidDataException("Unable to get convert for data at index: " + i + " in List");
}
var itemTypes = _converters[i].GetClrTypes();
_intersectedItemType = _intersectedItemType == null
? itemTypes
: _intersectedItemType.Intersect(itemTypes);
}
if (_intersectedItemType == null)
{
_intersectedItemType = new[] { typeof(object) }
}
;
var fullTypes = new List <Type>();
_names = sexp.Names;
if (_names != null)
{
fullTypes.AddRange(keyTypes.GetDictionaryTypes(_intersectedItemType));
if (_names.Length != _length)
{
var swap = new string[_length];
for (var i = 0; i < _length; i++)
{
swap[i] = i < _names.Length
? _names[i]
: "Column " + (i + 1);
}
_names = swap;
}
}
fullTypes.AddRange(_intersectedItemType.GetListOrArrayTypes());
var count = fullTypes.Count;
_types = fullTypes[0].GetFullHierarchy();
for (var i = 1; i < count; i++)
{
_types = _types.Union(fullTypes[i].GetFullHierarchy());
}
}
public RenderBuffer <float> Draw(RenderEntity[] entities, ICamera camera)
{
_renderTarget.Clear();
_matrixWorldToView = camera.WorldToView;
TApp appdata = new TApp();
TV2F[][] vertexV2FData = new TV2F[entities.Length][];
IPrimitive[][] primitives = new IPrimitive[entities.Length][];
Vector2[][] screenCoords = new Vector2[entities.Length][];
for (int i = 0; i < entities.Length; i++)
{
RenderEntity instanceCopy = entities[i].GetInstanceToApply();
_matrixObjectToWorld = instanceCopy.Transform.LocalToWorld;
_matrixObjectToView = _matrixWorldToView * _matrixObjectToWorld;
Vector3[] vertices = instanceCopy.Model.Vertices;
vertexV2FData[i] = new TV2F[vertices.Length];
screenCoords[i] = new Vector2[vertices.Length];
primitives[i] = instanceCopy.Model.Primitives;
for (int j = 0; j < vertices.Length; j++)
{
appdata.AssignAppdata(ref instanceCopy.Model, j);
TV2F v2f = Vertex(ref appdata);
vertexV2FData[i][j] = v2f;
screenCoords[i][j] = ViewToScreen(v2f.Vertex_VOut);
}
}
//Octree is so annoying
//Clipping();
Vector2Int[][][] rasterization = Rasterize(screenCoords, vertexV2FData, primitives);
GenericVector <float> whiteColor = new GenericVector <float>(3)
{
1, 1, 1
};
//Model
for (int i = 0; i < rasterization.Length; i++)
{
//Primitive
for (int j = 0; j < rasterization[i].Length; j++)
{
//PixelPos
for (int k = 0; k < rasterization[i][j].Length; k++)
{
_renderTarget.WritePixel(rasterization[i][j][k].X, rasterization[i][j][k].Y, whiteColor);
}
}
}
return(_renderTarget);
}
private GenericVector ConvertToRList(VmResourceTrace trace)
{
var list = new GenericVector(R, 3);
list.SetNames("vmId", "resourceId", "series");
list["vmId"] = new IntegerVector(R, new int[] { trace.VmId });
list["resourceId"] = new IntegerVector(R, new int[] { (int)trace.Resource });
list["series"] = new NumericVector(R, trace.Series.Select(f => (double)(f)));
return(list);
}
public static GenericVector ToGenericVector(this Dictionary <int, int> dictionary)
{
var newGenericVector = new GenericVector();
foreach (var keyValue in dictionary)
{
newGenericVector.Add(keyValue.Value);
}
return(newGenericVector);
}
//STATIC GENERICVECTOR METHODS
public static float DotProduct(GenericVector vectorA, GenericVector vectorB)
{
if (vectorA.Size != vectorB.Size)
{
throw new Exception("GenericVector a size of dotProduct not equal to GenericVector b size");
}
var aTimesBpoints = vectorA.Points.Select((t, i) => t * vectorB.Points[i]).ToList();
return(aTimesBpoints.Sum());
}
public static float GetAngle(GenericVector a, GenericVector b)
{
var x = DotProduct(a, b) / (a.VectorLength() * b.VectorLength());
if (x > 1 || x < -1)
{
return(0);
}
return((float)Math.Acos(x));
}
//---------------------------------------------------------------------
public void CopyFromByteArray(byte[] Bytes_in)
{
using (MemoryStream buffer = new MemoryStream(Bytes_in))
{
BinaryFormatter formatter = new BinaryFormatter();
GenericVector <T> vector = (GenericVector <T>)formatter.Deserialize(buffer);
this.CopyFromArray(vector.ToArray());
buffer.Close();
}
return;
}
private GenericVector[] GetPolynomialPoints()
{
var polyPoints = new GenericVector[_data.Length];
for (var i = 0; i < _data.Length; i++)
{
polyPoints[i] = new GenericVector(_data[i].X, ComputePolynomialPointY(_data[i].X));
}
return(polyPoints);
}
public void TestGenericVector()
{
var a = new GenericVector(4, 4);
var b = new GenericVector(6, 6);
Assert.Equal(GenericVector.Distance(a, b), Math.Sqrt(8.0));
var c = GenericVector.Sum(a, new GenericVector(6, 6));
var d = GenericVector.Sum(b, new GenericVector(4, 4));
Assert.Equal(GenericVector.Distance(c, d), 0);
}
private VmResourceForecast ReadRList(GenericVector row)
{
var forecasts = new[] { "arima", "ses", "crost", "holt", "dholt" }
.ToDictionary(x => x, method => ParseForecastResult(row[method].AsList()))
.Where(p => p.Value.Any())
.ToDictionary(p => p.Key.ToUpper(), p => p.Value);
return(new VmResourceForecast(
row["vmId"].AsInteger()[0],
(Resource)row["resourceId"].AsInteger()[0],
forecasts));
}
public void Sum(GenericVector vectorToSum)
{
if (Size != vectorToSum.Size)
{
throw new Exception("GenericVector size of vectorToSum not equal to instance vector size");
}
for (var i = 0; i < Points.Count; i++)
{
Points[i] = Points[i] + vectorToSum.Points[i];
}
}
/// <summary>
/// Executes the function. Match the function arguments by name.
/// </summary>
/// <param name="argNames">The names of the arguments. These can be empty strings for unnamed function arguments</param>
/// <param name="args">The arguments passed to the function</param>
/// <returns></returns>
protected SymbolicExpression InvokeViaPairlist(string[] argNames, SymbolicExpression[] args)
{
var names = new CharacterVector(Engine, argNames);
var arguments = new GenericVector(Engine, args);
arguments.SetNames(names);
var argPairList = arguments.ToPairlist();
//IntPtr newEnvironment = Engine.GetFunction<Rf_allocSExp>()(SymbolicExpressionType.Environment);
//IntPtr result = Engine.GetFunction<Rf_applyClosure>()(Body.DangerousGetHandle(), handle,
// argPairList.DangerousGetHandle(),
// Environment.DangerousGetHandle(), newEnvironment);
return createCallAndEvaluate(argPairList.DangerousGetHandle());
}
/// <summary>
/// Creates a new object dealing with the dynamic and binding logic for R lists
/// </summary>
/// <param name="parameter">The expression representing this new ListDynamicMeta in the binding process</param>
/// <param name="list">The runtime value of the GenericVector, that this new ListDynamicMeta represents</param>
public ListDynamicMeta(System.Linq.Expressions.Expression parameter, GenericVector list)
: base(parameter, list)
{ }
private static void ReproWorkitem43(REngine engine)
{
Random r = new Random(0);
int N = 500;
int n1 = 207;
int n2 = 623;
var arGroup1Intensities = new double[N][];
var arGroup2Intensities = new double[N][];
for (int i = 0; i < N; i++)
{
arGroup1Intensities[i] = new double[n1];
arGroup2Intensities[i] = new double[n2];
for (int j = 0; j < n1; j++)
arGroup1Intensities[i][j] = r.NextDouble();
for (int j = 0; j < n2; j++)
arGroup2Intensities[i][j] = r.NextDouble();
}
var res = new GenericVector[N];
NumericVector vGroup1, vGroup2;
for (int i = 0; i < N; i++)
{
vGroup1 = engine.CreateNumericVector(arGroup1Intensities[i]);
Console.WriteLine(vGroup1.Length);
if (i % 10 == 4)
{
engine.ForceGarbageCollection();
engine.ForceGarbageCollection();
}
vGroup2 = engine.CreateNumericVector(arGroup2Intensities[i]);
Console.WriteLine(vGroup2.Length);
engine.SetSymbol("group1", vGroup1);
engine.SetSymbol("group2", vGroup2);
GenericVector testResult = engine.Evaluate("t.test(group1, group2)").AsList();
res[i] = testResult;
}
}
