public string GetDescriptionForSelectedId(string id)
{
int numeralId = Convert.ToInt32(id);
foreach (Fitting fitting in allFittings)
{
if (numeralId == fitting.id)
{
selectedFitting = fitting;
wasFittingSelected = true;
string resultString = "";
resultString += $"Fitting with ID ({fitting.id})\n";
resultString += $"Fitting comment ({fitting.comment})\n";
resultString += $"Booking ID ({fitting.booking.id})\n";
resultString += $"Booking Creation Date: {fitting.booking.creationDate.ToString()}\n";
resultString += $"Booking Issue Date: {fitting.booking.issueDate.ToString()}\n";
resultString += $"Booking Total Sum: {fitting.booking.bookingSum}\n";
resultString += $"Is Marked: {fitting.booking.isMarked.ToString()}\n";
resultString += $"Model Name: {fitting.booking.model.name}\n";
resultString += $"Fabric Name: {fitting.booking.fabric.name}\n";
resultString += $"Cutter Name: fitting.{fitting.booking.cutter.fullName}\n";
resultString += $"Cutter Number of Orders: {fitting.booking.cutter.numberOfOrders}\n";
return(resultString);
}
}
return($"ERROR: Cannot load Fitting with ID ({id})");
}
public async Task <IActionResult> CreateFitting([FromBody] Fitting fitting)
{
try
{
if (fitting != null)
{
var response = await SchedulerHandler.InsertFitting(fitting);
if (response != null)
{
return(Ok(response));
}
else
{
return(StatusCode(505, new ErrorResponse()
{
Message = "Error occurred while saving fitting to database, please try again."
}));
}
}
return(StatusCode(408, new ErrorResponse()
{
Message = "Bad Request - Fitting data is null"
}));
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
return(StatusCode(505, ex.Message));
}
}
public void UpdateFitting(string fittingName, Fitting fitting)
{
if (_fittings.ContainsKey(fittingName))
{
_fittings[fittingName] = fitting;
}
}
public void LoadFittings(string searchPath)
{
var fittings = new List <Fitting>();
if (Directory.Exists(searchPath))
{
var fileNames = Directory.GetFiles(searchPath);
foreach (var fileName in fileNames)
{
if (fileName.EndsWith(".xml") & !fileName.EndsWith("Blanko.xml"))
{
Debug.WriteLine("Deserialize " + fileName);
try
{
var fitting = Fitting.FromFile(fileName);
fitting.FilePath = fileName;
fittings.Add(fitting);
}
catch (Exception)
{
//Überspringen TODO: dirty
}
}
}
if (fittings.Count > 0)
{
Fittings = fittings;
}
}
}
public static async Task <Fitting> InsertFitting(Fitting fitting)
{
using (var conn = Business.Database.Connection)
{
fitting.createdOn = DateTime.UtcNow;
fitting.fittingId = Guid.NewGuid();
var returnedFitting = await conn.QueryAsync <Fitting>("FittingInsert", new
{
fitting.fittingId,
fitting.userId,
fitting.orderId,
fitting.isVirtual,
fitting.timeRequested,
fitting.dateRequested,
fitting.timeZone,
fitting.createdOn
}, commandType : CommandType.StoredProcedure);
if (returnedFitting.AsList().Count() > 0)
{
return(returnedFitting.AsList()[0]);
}
return(null);
}
}
public static dynamic GetTSObject(Fitting dynObject)
{
if (dynObject is null)
{
return(null);
}
return(dynObject.teklaObject);
}
public Fitting GetFitting(string fittingName)
{
Fitting dummyFitting = new Fitting();
dummyFitting.Name = "Dummy";
return(dummyFitting);
}
public void CurveFit(int length)
{
if (length < 2)
{
throw new Exception("Occured curvefit's data length low error in Calibrator.CurveFit");
}
double[] rawX = new double[length];
double[] rawY = new double[length];
for (int i = 0; i < length; i++)
{
rawX[i] = Points[i].PV;
rawY[i] = Points[i].SV;
}
DiffA = 0;
DiffB = 0;
DiffC = 0;
try
{
switch (length)
{
case 2:
RawA = rawY[0] - rawX[0];
RawB = (rawY[1] - rawY[0]) / (rawX[1] - rawX[0]);
RawC = 0;
break;
default:
if ((IsDoubleArrayAllZero(rawX) == false) &&
(IsDoubleArrayAllZero(rawY) == false))
{
double[] raw = Fitting.LsFit(rawX, rawY, 2);
RawA = raw[0];
RawB = raw[1];
RawC = raw[2];
}
else
{
RawA = 0;
RawB = 1;
RawC = 0;
}
break;
}
Active = true;
}
catch (Exception e)
{
Clear();
Resource.TLog.Log((int)ELogItem.Exception, e.ToString());
throw new Exception("Occured calculation error in Calibrator.CurveFit");
}
}
public void TestEllipseCoeficients()
{
Mat __coords = Mat.Ones(1, 2, MatType.CV_64FC1);
__coords.Set <double>(0, 0, 2);
__coords.Set <double>(0, 1, 3);
Mat __output = Fitting.GenerateEllipseCoeff(__coords);
}
public void TestDataFitting1()
{
Mat __xVector = Mat.Ones(5, 2, MatType.CV_64FC1);
Mat __yVector = Mat.Zeros(5, 1, MatType.CV_64FC1);
Cv2.Randn(__xVector, 1, 1);
Mat __output = Fitting.DataFitting(__xVector, __yVector, Fitting.FittingCategrory.Polynominal, 1);
}
public void SetFitting(Fitting fitting)
{
Application.Current.Dispatcher.Invoke(
() =>
{
_fitting = fitting;
BtnSaveFitting.Visibility = _fitting != null ? Visibility.Visible : Visibility.Hidden ;
});
}
public void CK10_ApplyFitting()
{
// Current Workplane. Reminder how the user had the model before you did stuff.
TransformationPlane CurrentPlane = Model.GetWorkPlaneHandler().GetCurrentTransformationPlane();
Picker Picker = new Picker();
Beam PickedBeam = null;
try
{
PickedBeam = (Beam)Picker.PickObject(Picker.PickObjectEnum.PICK_ONE_PART);
}
catch { PickedBeam = null; }
if (PickedBeam != null)
{
// Change the workplane to the coordinate system of the Beam
var psk = new TransformationPlane(PickedBeam.GetCoordinateSystem());
Model.GetWorkPlaneHandler().SetCurrentTransformationPlane(psk);
// Applyfitting
Fitting BeamFitting = new Fitting();
BeamFitting.Father = PickedBeam;
Plane FittingPlane = new Plane();
FittingPlane.Origin = new T3D.Point(500, 0, 0);
FittingPlane.AxisX = new T3D.Vector(0, 0, 500);
FittingPlane.AxisY = new T3D.Vector(0, -500, 0);
BeamFitting.Plane = FittingPlane;
BeamFitting.Insert();
// Apply Line Cut
CutPlane BeamLineCut = new CutPlane();
BeamLineCut.Father = PickedBeam;
Plane BeamCutPlane = new Plane();
BeamCutPlane.Origin = new T3D.Point(200, 0, 0);
BeamCutPlane.AxisX = new T3D.Vector(0, 0, 500);
// Changing the positive vs. negative value here determines which direction
// the line cut will take away material where as fitting looks at which end
// of beam it is closest to figure out how to cut.
BeamCutPlane.AxisX = new T3D.Vector(0, -500, 0);
BeamLineCut.Plane = BeamCutPlane;
BeamLineCut.Insert();
// SetWorkplane back to what user had before
Model.GetWorkPlaneHandler().SetCurrentTransformationPlane(CurrentPlane);
// Show the plate in the model and the workplane change
Model.CommitChanges();
// Draw Positive Z axis.
GraphicsDrawer Drawer = new GraphicsDrawer();
var red = new Color(1, 0, 0);
Drawer.DrawLineSegment(new T3D.Point(0, 0, 0), new T3D.Point(0, 0, 500), red);
}
Model.GetWorkPlaneHandler().SetCurrentTransformationPlane(new TransformationPlane());
}
private void CuttingBeam(Part beam, Point inputPt, Vector axisX, Vector axisY)
{
Fitting cuttingBeam = new Fitting();
cuttingBeam.Plane = new Plane();
cuttingBeam.Plane.Origin = inputPt;
cuttingBeam.Plane.AxisX = axisX;
cuttingBeam.Plane.AxisY = axisY;
cuttingBeam.Father = beam;
cuttingBeam.Insert();
}
public List <Fitting> GetAllFittings()
{
List <Fitting> fittings = new List <Fitting>();
Fitting dummyFitting = new Fitting();
dummyFitting.Name = "Dummy";
fittings.Add(dummyFitting);
return(fittings);
}
public FittingsVM(Fitting el)
{
if (el == null)
{
IsHaveValues = false;
return;
}
Id = el.Id;
Type = el.Type;
Price = el.Price;
IsHaveValues = true;
}
public void TestPolynominalCoefficients()
{
Mat __coords = Mat.Ones(1, 2, MatType.CV_64FC1);
__coords.Set <double>(0, 0, 2);
__coords.Set <double>(0, 1, 3);
Mat __output = Fitting.GeneratePolynomialCoeff(__coords, 1);
__output = Fitting.GeneratePolynomialCoeff(__coords, 2);
__output = Fitting.GeneratePolynomialCoeff(__coords, 3);
}
private void btnApplyFitting_Click(object sender, EventArgs e)
{
// Current workplane. Remember how the user had the model before you changed things.
TransformationPlane currentPlane = currentModel.GetWorkPlaneHandler().GetCurrentTransformationPlane();
TSMUI.Picker myPicker = new TSMUI.Picker();
Beam currentBeam = null;
try
{
currentBeam = myPicker.PickObject(TSMUI.Picker.PickObjectEnum.PICK_ONE_PART) as Beam;
}
catch
{
currentBeam = null;
}
if (currentBeam != null)
{
// Change the workplane to the coordinate system of the beam.
currentModel.GetWorkPlaneHandler().SetCurrentTransformationPlane(new TransformationPlane(currentBeam.GetCoordinateSystem()));
// Apply fitting
Fitting beamFitting = new Fitting();
beamFitting.Father = currentBeam;
Plane fittingPlane = new Plane();
fittingPlane.Origin = new T3D.Point(500, 0, 0);
fittingPlane.AxisX = new T3D.Vector(0, 0, 500);
fittingPlane.AxisY = new T3D.Vector(0, 500, 0);
beamFitting.Plane = fittingPlane;
beamFitting.Insert();
// Apply cut line
CutPlane beamLineCut = new CutPlane();
beamLineCut.Father = currentBeam;
Plane beamCutPlane = new Plane();
beamCutPlane.Origin = new T3D.Point(2000, 0, 0);
beamCutPlane.AxisX = new T3D.Vector(0, 0, 500);
// Changing positive vs. negative value here determines which direction
// the line cut will take away material where as fittin glooks at which end
// of the beam it is closest to to figure out how to cut
beamCutPlane.AxisY = new T3D.Vector(0, -500, 0);
beamLineCut.Plane = beamCutPlane;
beamLineCut.Insert();
// Setworkplane back to what user had before
currentModel.GetWorkPlaneHandler().SetCurrentTransformationPlane(currentPlane);
// Show the fitting in the model but the user will never see the workplane change
currentModel.CommitChanges();
}
}
public async Task SaveFittingAsync(Fitting fitting)
{
await EnsureTokenIsValid()
.ConfigureAwait(false);
var fittingJson = JsonConvert.SerializeObject(
fitting,
new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
await Crest.Settings.DocumentLoader.AuthenticatedPostRequest(Character.Fittings.Href, BearerToken, fittingJson, DataType.Json);
}
public void Post([FromBody] Fitting fitting)
{
//var combatLogEntry1 = new CombatLogEntry();
//combatLogEntry1.Name = "C1";
//var combatLogEntry2 = new CombatLogEntry();
//combatLogEntry2.Name = "C2";
//fitting.CombatLogEntries.Add(combatLogEntry1);
//fitting.CombatLogEntries.Add(combatLogEntry2);
_db.CreateFitting(fitting);
}
/// <summary>Create A Fitting</summary>
/// <remarks>Requires SSO Authentication, using "write_fittings" scope</remarks>
/// <param name="CharacterID">(Int32) Character ID</param>
/// <param name="Fitting">(Fitting) Fitting</param>
/// <returns>EsiRequest</returns>
public EsiRequest Create(int CharacterID, Fitting Fitting)
{
var Path = $"/characters/{CharacterID.ToString()}/fittings/";
var Data = new
{
name = Fitting.Name,
description = Fitting.Description,
ship_type_id = Fitting.ShipTypeID,
items = Fitting.Items.Select(item => new { type_id = item.TypeID, quantity = item.Quantity, flag = item.Flag }).ToArray()
};
return(new EsiRequest(EasyObject, Path, EsiWebMethod.AuthPost, Data));
}
public async Task CanMakeGetRequests()
{
Fitting fitting = new Fitting
{
ApiBasePath = "https://xkcd.com",
RequestSuffix = "/info.0.json",
ContentType = "application/json",
Method = "GET"
};
FittingResponse <object> response = await fitting.SendRequest <object>();
Assert.IsNotNull(response);
Assert.IsTrue(response.Status.Health == FittingResponseStatusHealth.Good);
}
} // property Recipes
public FittingBase(long itemID)
{
ID = itemID;
if (ID > 0)
{
Fitting itemRecord = ItemGateway.FittingGetByID(itemID);
Name = itemRecord.displayName;
Description = itemRecord.displayDescription;
} // if (ID > 0)
else
{
Name = "n/a";
Description = "n/a";
}
} // constructor
public async Task CanMakePostRequests()
{
Fitting fitting = new Fitting
{
ApiBasePath = "https://localhost:5001",
RequestSuffix = "/api/offers",
ContentType = "application/json",
Method = "POST"
};
FittingResponse <object> response = await fitting.SendRequest <object>();
Assert.IsNotNull(response);
Assert.IsTrue(response.Status.Health == FittingResponseStatusHealth.Good);
}
} // method ItemGetByID
// This method is used by the FittingBase constructor
public static Fitting FittingGetByID(long objectID)
{
string cacheKey = "Fitting_" + objectID;
Fitting returnObject = HttpContext.Current.Cache[cacheKey] as Fitting;
if (returnObject == null)
{
using (RepopdataEntities myEntities = new RepopdataEntities())
{
returnObject = (from item in myEntities.Fittings
where item.fittingID == objectID
select item).FirstOrDefault();
if (returnObject == null) { return null; }
AppCaching.AddToCache(cacheKey, returnObject);
} // using
} // if (returnObject == null)
return returnObject;
} // method FittingGetByID
public static Fitting SetGeometry(this Fitting fittingObj, Point location, List <Point> connectionLocations)
{
if (fittingObj == null || location == null || connectionLocations == null)
{
return(null);
}
if (connectionLocations.Count < 2)
{
Engine.Reflection.Compute.RecordError("A fitting requires at least 2 physical connections, e.g. an elbow fitting has 2, please input at least two Points in connectionLocations.");
return(null);
}
Fitting clone = fittingObj.ShallowClone();
clone.Location = location;
clone.ConnectionsLocation = connectionLocations;
return(clone);
}
public void FullDBHelper()
{
IDBHelper db = new DBHelper_InMemory.DBHelper();
db.Init();
Fitting firstFitting = new Fitting();
string firstFittingName = "First Fitting Name";
firstFitting.Name = firstFittingName;
db.CreateFitting(firstFitting);
var getFirstFitting = db.GetFitting(firstFittingName);
Assert.AreEqual(getFirstFitting.Name.ToUpperInvariant(), firstFittingName.ToUpperInvariant());
var allFittings = db.GetAllFittings();
getFirstFitting = allFittings[0];
Assert.AreEqual(getFirstFitting.Name.ToUpperInvariant(), firstFittingName.ToUpperInvariant());
CombatLogEntry firstCombatLogEntry = new CombatLogEntry();
string firstCombatLogEntryName = "First Combat Log Entry Name";
firstCombatLogEntry.Name = firstCombatLogEntryName;
db.CreateCombatLogEntry(firstFittingName, firstCombatLogEntry);
var getCombatLogEntry = db.GetCombatLogEntry(firstCombatLogEntryName);
Assert.AreEqual(getCombatLogEntry.Name.ToUpperInvariant(), firstCombatLogEntryName.ToUpperInvariant());
CombatLogEntry secondCombatLogEntry = new CombatLogEntry();
string secondCombatLogEntryName = "Second Combat Log Entry Name";
secondCombatLogEntry.Name = secondCombatLogEntryName;
db.CreateCombatLogEntry(firstFittingName, secondCombatLogEntry);
getCombatLogEntry = db.GetCombatLogEntry(secondCombatLogEntryName);
Assert.AreEqual(getCombatLogEntry.Name.ToUpperInvariant(), secondCombatLogEntryName.ToUpperInvariant());
}
public static PriceItem GetLastPriceItem(IUnitOfWork uow, Fitting fitting, Provider provider)
{
PriceItem pricePriceItemAlias = null;
Price pricePriceAlias = null;
var query = uow.Session.QueryOver <PriceItem>(() => pricePriceItemAlias)
.JoinAlias(c => c.Price, () => pricePriceAlias)
.Where(() => pricePriceItemAlias.Fitting.Id == fitting.Id);
if (provider != null)
{
query.Where(() => pricePriceAlias.Provider.Id == provider.Id);
}
return(query
.OrderBy(() => pricePriceAlias.Date).Desc
.Take(1)
.SingleOrDefault());
}
public bool TryFoundFitting()
{
if (!String.IsNullOrWhiteSpace(Code))
{
var foundList = Repository.FittingRepository.GetFittings(WC.UoW, Code, Diameter);
if (foundList.Count == 1)
{
Status = RowStatus.FoundModel;
Fitting = foundList.First();
return(true);
}
else if (foundList.Count > 1)
{
Status = RowStatus.MultiFound;
IsMultiFound = true;
return(true);
}
}
return(false);
}
public void FittingBeamByFace()
{
Beam beam = PickBeam();
GeometricPlane geomPlane = PickFace();
Fitting fitting = new Fitting();
fitting.Father = beam;
CoordinateSystem beamCS = beam.GetCoordinateSystem();
ReperShow(beamCS);
Line lineAlongBeamAxisX = new Line(beamCS.Origin, beamCS.AxisX);
//do u need Z asis
//T3D.Vector axisZ = beamCS.
T3D.Point intersectionPoint = Intersection.LineToPlane(lineAlongBeamAxisX, geomPlane);
PointShow(intersectionPoint, "intersectionPoint");
T3D.Point randomPoint = new T3D.Point(intersectionPoint + new T3D.Point(500, 500, 500));
PointShow(randomPoint, "randomPoint");
randomPoint = Projection.PointToPlane(randomPoint, geomPlane);
PointShow(randomPoint, "Projected randomPoint");
T3D.Vector x = new T3D.Vector(randomPoint - intersectionPoint);
T3D.Vector y = geomPlane.Normal.Cross(x);
CoordinateSystem itersect = new CoordinateSystem(intersectionPoint, x, y);
ReperShow(itersect);
Plane plane = new Plane();
plane.Origin = intersectionPoint;
plane.AxisX = x;
plane.AxisY = y;
x.Normalize(500);
y.Normalize(500);
fitting.Plane = plane;
fitting.Insert();
Model.CommitChanges();
}
private void TryApplyFits(Part beam, List <Tuple <Tuple <Point, Point, Point>, Plane> > fitPlanes)
{
if (null == fitPlanes)
{
return;
}
var centerLine = GetBeamCenterLineSegmentExpanded(beam, 10.0);
if (null == centerLine)
{
return;
}
// check collision
foreach (var fitPlaneDef in fitPlanes)
{
//var pps = fitPlaneDef.Item1;
var plane = fitPlaneDef.Item2;
//var geomPlane = new GeometricPlane(pps.Item1, new Vector(pps.Item3));
var geomPlane = new GeometricPlane(plane.Origin, plane.AxisX, plane.AxisY);
var intersection = Intersection.LineSegmentToPlane(centerLine, geomPlane);
if (null == intersection)
{
Tracer._trace($"Does not intersect with {beam.Profile.ProfileString}");
continue;
}
var operativePart = fitPlaneDef.Item2;
var fitPlane = new Fitting();
fitPlane.Father = beam;
fitPlane.Plane = operativePart;
if (!fitPlane.Insert())
{
Tracer._trace("Insert failed!");
}
Tracer._trace($"Fit solid: {beam.Name}.");
}
}
internal TurretComponent[] GetComponentsMatching(Slot slot, Type filter = null)
{
TurretComponent[] components = new TurretComponent[parts.Length + utilities.Length + weapons.Length];
Array.Copy(parts, components, parts.Length);
Array.Copy(utilities, 0, components, parts.Length, utilities.Length);
Array.Copy(weapons, 0, components, parts.Length + utilities.Length, weapons.Length);
ArrayList filteredComponents = new ArrayList();
for (int i = 0; i < components.Length; i++)
{
TurretComponent component = components[i];
Fitting fitting = component.fitting;
if (!fitting.size.Fits(slot.size))
{
// Make sure the fitting is smaller or equal than the slot
continue;
}
if (!fitting.armament.Fits(slot.armament))
{
// Make sure tha armament type can fit in the slot
continue;
}
if (filter != null && component.GetComponent(filter) == null)
{
// Make sure the object is of the corect type
continue;
}
// else
filteredComponents.Add(component);
}
TurretComponent[] objects = new TurretComponent[filteredComponents.Count];
Array.Copy(filteredComponents.ToArray(), objects, filteredComponents.Count);
return(objects);
}
public static List <Line> Geometry(this Fitting fitting)
{
if (fitting == null)
{
return(null);
}
List <Line> result = new List <Line>();
if (fitting.ConnectionsLocation.Count == 2)
{
result.Add(BH.Engine.Geometry.Create.Line(fitting.ConnectionsLocation[0], fitting.ConnectionsLocation[1]));
}
else
{
foreach (Point point in fitting.ConnectionsLocation)
{
result.Add(BH.Engine.Geometry.Create.Line(fitting.Location, point));
}
}
return(result);
}
/// <summary>
/// Fits the underlying distribution to a given set of observations.
/// </summary>
///
/// <param name="observations">The array of observations to fit the model against. The array
/// elements can be either of type double (for univariate data) or
/// type double[] (for multivariate data).</param>
/// <param name="weights">The weight vector containing the weight for each of the samples.</param>
/// <param name="options">Optional arguments which may be used during fitting, such
/// as regularization constants and additional parameters.</param>
///
public override void Fit(double[][] observations, double[] weights, Fitting.IFittingOptions options)
{
throw new NotSupportedException();
}
/// <summary>
/// Fits the underlying distribution to a given set of observations.
/// </summary>
///
/// <param name="observations">The array of observations to fit the model against. The array
/// elements can be either of type double (for univariate data) or
/// type double[] (for multivariate data).</param>
/// <param name="weights">The weight vector containing the weight for each of the samples.</param>
/// <param name="options">Optional arguments which may be used during fitting, such
/// as regularization constants and additional parameters.</param>
///
/// <remarks>
/// Although both double[] and double[][] arrays are supported,
/// providing a double[] for a multivariate distribution or a
/// double[][] for a univariate distribution may have a negative
/// impact in performance.
/// </remarks>
///
public override void Fit(double[][] observations, double[] weights, Fitting.IFittingOptions options)
{
HiddenMarkovOptions normalOptions = options as HiddenMarkovOptions;
if (options != null && normalOptions == null)
throw new ArgumentException("The specified options' type is invalid.", "options");
Fit(observations, weights, normalOptions);
}
private static bool CreateFittings(Beam targetBeam, double customGap)
{
bool Result = false;
Fitting fitBeam = new Fitting();
fitBeam.Plane = new Plane();
fitBeam.Plane.Origin = new Point(customGap, -160, -500);
fitBeam.Plane.AxisX = new Vector(0.0, 500.0, 0.0);
fitBeam.Plane.AxisY = new Vector(0.0, 0.0, 1200.0);
fitBeam.Father = targetBeam;
if (fitBeam.Insert())
Result = true;
return Result;
}
/// <summary>
/// Fits the underlying distribution to a given set of observations.
/// </summary>
///
/// <param name="observations">The array of observations to fit the model against. The array
/// elements can be either of type double (for univariate data) or
/// type double[] (for multivariate data).</param>
/// <param name="weights">The weight vector containing the weight for each of the samples.</param>
/// <param name="options">Optional arguments which may be used during fitting, such
/// as regularization constants and additional parameters.</param>
///
/// <remarks>
/// Although both double[] and double[][] arrays are supported,
/// providing a double[] for a multivariate distribution or a
/// double[][] for a univariate distribution may have a negative
/// impact in performance.
/// </remarks>
///
public override void Fit(double[] observations, double[] weights, Fitting.IFittingOptions options)
{
if (weights != null)
throw new NotSupportedException();
initialize((double[])observations.Clone(), null);
}
public int Compare(Fitting x, Fitting y)
{
return String.Compare(x.Name, y.Name, true, CultureInfo.CurrentCulture);
}
/// <summary>
/// Fits the underlying distribution to a given set of observations.
/// </summary>
///
/// <param name="observations">The array of observations to fit the model against. The array
/// elements can be either of type double (for univariate data) or
/// type double[] (for multivariate data).</param>
/// <param name="weights">The weight vector containing the weight for each of the samples.</param>
/// <param name="options">Optional arguments which may be used during fitting, such
/// as regularization constants and additional parameters.</param>
///
/// <remarks>
/// Although both double[] and double[][] arrays are supported,
/// providing a double[] for a multivariate distribution or a
/// double[][] for a univariate distribution may have a negative
/// impact in performance.
/// </remarks>
///
public override void Fit(double[] observations, double[] weights, Fitting.IFittingOptions options)
{
if (immutable)
throw new InvalidOperationException("This object can not be modified.");
if (options != null)
throw new ArgumentException("No options may be specified.");
a = observations.Min();
b = observations.Max();
}
/// <summary>
/// Fits the underlying distribution to a given set of observations.
/// </summary>
///
/// <param name="observations">The array of observations to fit the model against. The array
/// elements can be either of type double (for univariate data) or
/// type double[] (for multivariate data).</param>
/// <param name="weights">The weight vector containing the weight for each of the samples.</param>
/// <param name="options">Optional arguments which may be used during fitting, such
/// as regularization constants and additional parameters.</param>
///
/// <remarks>
/// Although both double[] and double[][] arrays are supported,
/// providing a double[] for a multivariate distribution or a
/// double[][] for a univariate distribution may have a negative
/// impact in performance.
/// </remarks>
///
public override void Fit(double[] observations, double[] weights, Fitting.IFittingOptions options)
{
if (weights != null)
throw new ArgumentException("This distribution does not support weighted samples.");
if (options != null)
throw new ArgumentException("This method does not accept fitting options.");
initialize((double[])observations.Clone(), null);
}
/// <summary>
/// Fits the underlying distribution to a given set of observations.
/// </summary>
///
/// <param name="observations">The array of observations to fit the model against. The array
/// elements can be either of type double (for univariate data) or
/// type double[] (for multivariate data).</param>
/// <param name="weights">The weight vector containing the weight for each of the samples.</param>
/// <param name="options">Optional arguments which may be used during fitting, such
/// as regularization constants and additional parameters.</param>
///
/// <remarks>
/// Although both double[] and double[][] arrays are supported,
/// providing a double[] for a multivariate distribution or a
/// double[][] for a univariate distribution may have a negative
/// impact in performance.
/// </remarks>
///
public override void Fit(double[] observations, double[] weights, Fitting.IFittingOptions options)
{
if (options != null)
throw new ArgumentException("No options may be specified.");
if (weights != null)
throw new ArgumentException("This distribution does not support weighted samples.");
a = (int)observations.Min();
b = (int)observations.Max();
}
/// <summary>
/// Fits the underlying distribution to a given set of observations.
/// </summary>
///
/// <param name="observations">The array of observations to fit the model against. The array
/// elements can be either of type double (for univariate data) or
/// type double[] (for multivariate data).</param>
/// <param name="weights">The weight vector containing the weight for each of the samples.</param>
/// <param name="options">Optional arguments which may be used during fitting, such
/// as regularization constants and additional parameters.</param>
///
/// <remarks>
/// Although both double[] and double[][] arrays are supported,
/// providing a double[] for a multivariate distribution or a
/// double[][] for a univariate distribution may have a negative
/// impact in performance.
/// </remarks>
///
public override void Fit(double[] observations, double[] weights, Fitting.IFittingOptions options)
{
if (options != null)
throw new ArgumentException("No options may be specified.");
a = (int)observations.Min();
b = (int)observations.Max();
}
