protected void BddlAddPartition_SelectionChanged(object sender, EventArgs e)
{
if (Counts.Count > 0)
{
hdnPartitionType.Value = (( ButtonDropDownList )sender).SelectedValue;
ScriptManager.RegisterStartupScript(upEditControls, upEditControls.GetType(), "PartitionWarning", "Rock.dialogs.confirm('Making changes to partition settings can affect existing counts! Are you sure you want to proceed?', function(result) {if(result) {$(\"#" + btnAddPartition.ClientID + "\")[0].click();}});", true);
return;
}
var partition = new PartitionSettings()
{
PartitionType = (( ButtonDropDownList )sender).SelectedValue, Guid = Guid.NewGuid(), SignupSettings = Settings
};
if (partition.PartitionType == "Role")
{
partition.AttributeKey = "GroupTypeRole";
}
else if (partition.PartitionType == "Campus")
{
partition.AttributeKey = "Campus";
}
Settings.Partitions.Add(partition);
SaveViewState();
rptPartions.DataSource = Settings.Partitions;
rptPartions.DataBind();
}
public void Init(PartitionSettings partitionSettings, int centerIndex)
{
var data = partitionSettings.CentersSettings.CenterDatas[centerIndex];
TextInfo.text = $"№{centerIndex + 1}\n(X; Y) = ({data.Position[0]:0.00}; {data.Position[1]:0.00})\nA = {data.A}\nW = {data.W}";
gameObject.SetActive(true);
_centerInfoBlock.SetActive(false);
}
private List <GridValueInterpolator> GetMuGrids(PartitionSettings settings)
{
//var muMatrices = new FuzzyPartitionFixedCentersAlgorithm(_settings).BuildPartition();
//var interpolators = muMatrices.Select(m => new GridValueInterpolator(settings.SpaceSettings, new MatrixGridValueGetter(m))).ToList();
//return interpolators;
var partitionTexture = _partitionFixedCentersComputer.Run();
var muGridValueInterpolators = _muConverter.GetGridValueInterpolators(partitionTexture, settings);
return(muGridValueInterpolators);
}
public static CenterData GetDefaultCenterData(PartitionSettings settings)
{
var data = new CenterData
{
IsFixed = false,
Position = (settings.SpaceSettings.MaxCorner + settings.SpaceSettings.MinCorner) / 2,
A = 0,
W = 1
};
return(data);
}
private double CalculateTargetFunctionalValue(PartitionSettings partitionSettings, RenderTexture muRenderTexture)
{
if (!_calculateTargetFunctionalValue)
{
return(double.MinValue);
}
var muGridGetters = _textureToGridConverter.GetGridValueInterpolators(muRenderTexture, partitionSettings);
var targetFunctionalValue = new TargetFunctionalCalculator(partitionSettings).CalculateFunctionalValue(muGridGetters);
Logger.Info($"Target functional value = {targetFunctionalValue}");
return(targetFunctionalValue);
}
private double CalculateDualFunctionalValue(PartitionSettings partitionSettings, RenderTexture psiGridTexture)
{
if (!_calculateDualFunctionalValue)
{
return(double.MinValue);
}
var psiGridValueGetter = _textureToGridConverter.GetGridValueInterpolator(psiGridTexture, partitionSettings);
var dualFunctionalValue = new DualFunctionalCalculator(partitionSettings, psiGridValueGetter).CalculateFunctionalValue();
Logger.Info($"Dual functional value = {dualFunctionalValue}");
return(dualFunctionalValue);
}
public FuzzyPartitionPlacingCentersAlgorithm(PartitionSettings partitionSettings, List <Vector <double> > zeroCenters, List <GridValueInterpolator> zeroMuGrids)
{
PerformedIterationCount = 0;
_settings = partitionSettings;
_rAlgorithmSolvers = new List <RAlgorithmSolverBForm>();
_previousTaus.AddRange(Enumerable.Repeat(default(Vector <double>), _settings.CentersSettings.CentersCount));
for (var centerIndex = 0; centerIndex < _settings.CentersSettings.CentersCount; centerIndex++)
{
var zeroCenter = zeroCenters[centerIndex];
var gradientCalculator = new GradientCalculator(_settings);
var gradientVector = gradientCalculator.CalculateGradientForCenter(zeroCenter, zeroMuGrids[centerIndex]);
var rAlgorithm = new RAlgorithmSolverBForm(zeroCenter, _ => gradientVector, _settings.RAlgorithmSettings.SpaceStretchFactor);
_rAlgorithmSolvers.Add(rAlgorithm);
}
}
public PartitionResult CreateFuzzyPartitionWithFixedCenters(PartitionSettings partitionSettings, RenderingSettings renderingSettings)
{
_partitionFixedCentersComputer.Init(partitionSettings);
var muRenderTexture = _partitionFixedCentersComputer.Run(out var psiGridTexture);
var result = new PartitionResult
{
TargetFunctionalValue = CalculateTargetFunctionalValue(partitionSettings, muRenderTexture),
DualFunctionalValue = CalculateDualFunctionalValue(partitionSettings, psiGridTexture),
WorkFinished = true
};
_partitionImageShower.RenderingSettings = renderingSettings;
_partitionImageShower.CreatePartitionAndShow(partitionSettings, muRenderTexture);
return(result);
}
public void Init(PartitionSettings settings)
{
_settings = settings;
_timer = new Stopwatch();
_timer.Start();
_partitionFixedCentersComputer.Init(_settings);
var zeroTaus = GetZeroIterationCentersPositions(settings);
SetCentersPositions(zeroTaus);
var muGrids = GetMuGrids(settings);
PlacingAlgorithm = new FuzzyPartitionPlacingCentersAlgorithm(_settings, zeroTaus, muGrids);
_timer.Stop();
}
public PartitionResult CreateFuzzyPartitionWithCentersPlacing(PartitionSettings partitionSettings, RenderingSettings renderingSettings)
{
_partitionPlacingCentersComputer.Init(partitionSettings);
var centersPositions = _partitionPlacingCentersComputer.Run(out var iterationsCount);
for (var i = 0; i < centersPositions.Count; i++)
{
partitionSettings.CentersSettings.CenterDatas[i].Position = centersPositions[i];
}
var result = CreateFuzzyPartitionWithFixedCenters(partitionSettings, renderingSettings);
result.CentersPositions = centersPositions.ToArray();
result.WorkFinished = true;
result.PerformedIterationsCount = iterationsCount;
return(result);
}
public PartitionSettings GetPartitionSettings()
{
if (_centersCount > _centerPositions.Length)
{
throw new Exception($"Centers count ({_centersCount}) is bigger then center positions count ({_centerPositions.Length}).");
}
if (_centersCount > _centerDatas.Length)
{
throw new Exception($"Centers count ({_centersCount}) is bigger then center datas count ({_centerDatas.Length}).");
}
var settings = new PartitionSettings
{
IsCenterPlacingTask = _isCentersPlacingTask,
SpaceSettings = new SpaceSettings
{
MinCorner = _minCorner.ToVector(),
MaxCorner = _maxCorner.ToVector(),
GridSize = new List <int> {
_gridSize.x, _gridSize.y
},
DensityType = _densityType,
MetricsType = _metricsType
},
CentersSettings = new CentersSettings
{
CentersCount = _centersCount,
CenterDatas = _centerDatas
.Take(_centersCount)
.Select((v, i) =>
{
v.Position = _centerPositions[i].ToVector();
return(v);
}).ToList()
},
RAlgorithmSettings = _rAlgorithmSettings,
FuzzyPartitionFixedCentersSettings = _fuzzyPartitionFixedCentersSettings,
FuzzyPartitionPlacingCentersSettings = _fuzzyPartitionPlacingCentersSettings
};
return(settings);
}
private List <Vector <double> > GetZeroIterationCentersPositions(PartitionSettings settings)
{
var zeroTaus = new List <Vector <double> >();
var p1 = settings.SpaceSettings.MinCorner;
var p2 = VectorUtils.CreateVector(p1[0], settings.SpaceSettings.MaxCorner[1]);
for (var i = 0; i < settings.CentersSettings.CentersCount; i++)
{
//var zeroTau = settings.SpaceSettings.MinCorner.Clone();
//
var zeroTau = p1 + ((i + 1) / (settings.CentersSettings.CentersCount + 1d)) * (p2 - p1);
//zeroTau += VectorUtils.CreateVector(Random.value - 0.5f, Random.value - 0.5f);
//var zeroTau = VectorUtils.CreateVector(_zeroTau[0], _zeroTau[1]);
zeroTaus.Add(zeroTau);
}
//zeroTaus = _zeroTausManual.Select(v => VectorUtils.CreateVector(v.x, v.y)).ToList();
return(zeroTaus);
}
protected void btnAddPartition_Click(object sender, EventArgs e)
{
var partition = new PartitionSettings()
{
PartitionType = hdnPartitionType.Value, Guid = Guid.NewGuid(), SignupSettings = Settings
};
if (partition.PartitionType == "Role")
{
partition.AttributeKey = "GroupTypeRole";
}
else if (partition.PartitionType == "Campus")
{
partition.AttributeKey = "Campus";
}
Settings.Partitions.Add(partition);
SaveViewState();
rptPartions.DataSource = Settings.Partitions;
rptPartions.DataBind();
}
public void Init(PartitionSettings partitionSettings)
{
_partitionSettings = partitionSettings;
foreach (var centerInfo in _centerInfos)
{
centerInfo.Hide();
}
while (_centerInfos.Count < partitionSettings.CentersSettings.CentersCount)
{
_centerInfos.Add(Instantiate(_centerInfoPrefab, transform, true));
}
for (var index = 0; index < partitionSettings.CentersSettings.CentersCount; index++)
{
var centerInfo = _centerInfos[index];
centerInfo.Init(partitionSettings, index);
}
SetCenterInfoPositions();
}
public void Init(PartitionSettings partitionSettings, RenderingSettings renderingSettings, Color[] centersColors)
{
_settings = partitionSettings;
_renderingSettings = renderingSettings;
_centersColors = centersColors;
_partitionDrawingKernel = _partitionDrawingShader.FindKernel(PartitionDrawingKernel);
_partitionRenderTexture = new RenderTexture(_settings.SpaceSettings.GridSize[0], _settings.SpaceSettings.GridSize[1], 0)
{
format = RenderTextureFormat.ARGB32,
enableRandomWrite = true
};
_partitionRenderTexture.Create();
CheckAndReleaseBuffer();
_colorsComputeBuffer = new ComputeBuffer(centersColors.Length, sizeof(float) * 4, ComputeBufferType.Default);
_colorsComputeBuffer.SetData(_centersColors);
_partitionDrawingShader.SetInt("CentersCount", _settings.CentersSettings.CentersCount);
_partitionDrawingShader.SetBuffer(_partitionDrawingKernel, "CentersColors", _colorsComputeBuffer);
_partitionDrawingShader.SetTexture(_partitionDrawingKernel, "Result", _partitionRenderTexture);
}
public AlgorithmSettingsViewModel()
{
Settings = DefaultSettingsKeeper.GetPartitionSettings();
CreatePartitionCommand = new RelayCommand(_ =>
{
if (_partitionCreationWindow == null || !_partitionCreationWindow.IsLoaded)
{
_partitionCreationWindow = new PartitionCreationWindow(Settings);
_partitionCreationWindow.Show();
}
else
{
_partitionCreationWindow.Activate();
var vm = (PartitionCreationViewModel)_partitionCreationWindow.DataContext;
vm.RunPartitionCreation();
}
},
obj =>
{
var valid = true; //Utils.IsValid();
if (!valid)
{
MessageBox.Show("Введені некоректні дані! Щоб продовжити, введіть коректні дані.", "Некоректні дані",
MessageBoxButton.OK, MessageBoxImage.Error);
}
return(true);
});
OnClosing = new RelayCommand(_ =>
{
_partitionCreationWindow?.Close();
});
}
protected List <IDictionary <string, object> > GetTree(PartitionSettings partition, ICollection <ConnectionRequest> connectionRequests = null, String concatGuid = null, GroupTypeRoleService groupTypeRoleService = null, ScheduleService scheduleService = null, string ParentIdentifier = "signup", string parentUrl = "", string groupId = "", string roleId = "")
{
if (groupTypeRoleService == null || scheduleService == null)
{
RockContext context = new RockContext();
groupTypeRoleService = new GroupTypeRoleService(context);
scheduleService = new ScheduleService(context);
}
var partitionList = new List <IDictionary <string, object> >();
if (partition.PartitionValue == null)
{
return(null);
}
var values = partition.PartitionValue.Trim(',').Split(',');
if (partition.PartitionType == "DefinedType")
{
// Use every Defined Value
values = DefinedTypeCache.Read(partition.PartitionValue.AsGuid()).DefinedValues.Select(dv => dv.Guid.ToString()).ToArray();
}
foreach (var value in values)
{
if (partition.PartitionType == "Role")
{
roleId = value;
}
if (partition.GroupMap != null && partition.GroupMap.ContainsKey(value))
{
groupId = partition.GroupMap[value];
}
string url = parentUrl + (parentUrl.Contains("?") ? "&" : "?") + partition.AttributeKey + "=" + value;
IDictionary <string, object> inner = new Dictionary <string, object>();
inner.Add("ParentIdentifier", ParentIdentifier);
inner.Add("PartitionType", partition.PartitionType);
inner.Add("Url", url);
inner.Add("ParameterName", partition.AttributeKey);
inner.Add("Value", value);
inner.Add("RoleGuid", roleId);
inner.Add("GroupId", groupId);
var newConcatGuid = concatGuid == null ? value : concatGuid + "," + value;
int?count = Counts.Where(kvp => kvp.Key.Contains(newConcatGuid)).Any(kvp => String.IsNullOrWhiteSpace(kvp.Value))?null:(int?)(Counts.Where(kvp => kvp.Key.Contains(newConcatGuid)).Select(kvp => kvp.Value.AsInteger()).Sum());
inner.Add("Limit", count);
ICollection <ConnectionRequest> subRequests = null;
switch (partition.PartitionType)
{
case "DefinedType":
inner["Entity"] = DefinedValueCache.Read(value.AsGuid());
if (connectionRequests != null)
{
subRequests = connectionRequests.Where(cr => cr.AssignedGroupMemberAttributeValues != null && cr.AssignedGroupMemberAttributeValues.Contains(value)).ToList();
inner.Add("TotalFilled", this.connectionRequests.Where(cr => cr.AssignedGroupMemberAttributeValues != null && cr.AssignedGroupMemberAttributeValues.Contains(value) && cr.ConnectionState != ConnectionState.Inactive).Count());
}
break;
case "Schedule":
inner["Entity"] = scheduleService.Get(value.AsGuid());
if (connectionRequests != null)
{
subRequests = connectionRequests.Where(cr => cr.AssignedGroupMemberAttributeValues != null && cr.AssignedGroupMemberAttributeValues.Contains(value)).ToList();
inner.Add("TotalFilled", this.connectionRequests.Where(cr => cr.AssignedGroupMemberAttributeValues != null && cr.AssignedGroupMemberAttributeValues.Contains(value) && cr.ConnectionState != ConnectionState.Inactive).Count());
}
break;
case "Campus":
var campus = CampusCache.Read(value.AsGuid());
inner["Entity"] = campus;
if (connectionRequests != null && campus != null)
{
subRequests = connectionRequests.Where(cr => cr.CampusId == campus.Id).ToList();
inner.Add("TotalFilled", this.connectionRequests.Where(cr => cr.CampusId == campus.Id && cr.ConnectionState != ConnectionState.Inactive).Count());
}
break;
case "Role":
var role = groupTypeRoleService.Get(value.AsGuid());
inner["Entity"] = role;
if (connectionRequests != null)
{
subRequests = connectionRequests.Where(cr => cr.AssignedGroupMemberRoleId == role.Id).ToList();
inner.Add("TotalFilled", this.connectionRequests.Where(cr => cr.AssignedGroupMemberRoleId == role.Id && cr.ConnectionState != ConnectionState.Inactive).Count());
}
break;
}
inner.Add("Filled", subRequests != null?subRequests.Where(sr => sr.ConnectionState != ConnectionState.Inactive).Count():0);
if (partition.NextPartition != null)
{
inner.Add("Partitions", GetTree(partition.NextPartition, subRequests, newConcatGuid, groupTypeRoleService, scheduleService, ParentIdentifier + "_" + value, url, groupId, roleId));
}
partitionList.Add(inner);
}
return(partitionList);
}
public DualFunctionalCalculator(PartitionSettings partitionSettings, GridValueInterpolator psiGridValueGetter)
{
_settings = partitionSettings;
_psiGridValueGetter = psiGridValueGetter;
}
public GradientCalculator(PartitionSettings settings)
{
Settings = settings;
}
public PartitionCreationWindow()
{
_partitionSettings = DefaultSettingsKeeper.GetPartitionSettings();
}
public void Grid3x3PlacingPartitionTest()
{
var f = "Logs.txt";
if (File.Exists(f))
{
File.Delete(f);
}
Trace.Listeners.Add(new TextWriterTraceListener(f));
var settings = new PartitionSettings
{
IsCenterPlacingTask = false,
SpaceSettings = new SpaceSettings
{
MinCorner = VectorUtils.CreateVector(0, 0),
MaxCorner = VectorUtils.CreateVector(10, 10),
GridSize = new List <int> {
8, 8
},
DensityType = DensityType.Everywhere1,
MetricsType = MetricsType.Euclidean,
CustomDensityFunction = null,
CustomDistanceFunction = null
},
CentersSettings = new CentersSettings
{
CentersCount = 2,
CenterDatas = new List <CenterData>
{
new CenterData
{
A = 0,
W = 1,
Position = VectorUtils.CreateVector(2, 5),
IsFixed = true
},
new CenterData
{
A = 0,
W = 1,
Position = VectorUtils.CreateVector(8, 5),
IsFixed = true
},
}
},
FuzzyPartitionFixedCentersSettings = new FuzzyPartitionFixedCentersSettings
{
GradientEpsilon = 0.01,
GradientStep = 0.1,
MaxIterationsCount = 400
},
FuzzyPartitionPlacingCentersSettings = new FuzzyPartitionPlacingCentersSettings
{
CentersDeltaEpsilon = 0.1,
GaussLegendreIntegralOrder = 32
},
RAlgorithmSettings = new RAlgorithmSettings
{
SpaceStretchFactor = 2,
H0 = 1,
MaxIterationsCount = 30
}
};
var zeroTaus = new List <Vector <double> >
{
//VectorUtils.CreateVector(2, 5),
//VectorUtils.CreateVector(8, 5)
VectorUtils.CreateVector(1, 1),
VectorUtils.CreateVector(10, 10)
};
var calculator = new FuzzyPartitionFixedCentersAlgorithm(settings);
var partition = calculator.BuildPartition();
var muValueGetters = partition.Select(v => new GridValueInterpolator(settings.SpaceSettings, new MatrixGridValueGetter(v))).ToList();
var placingAlgorithm = new FuzzyPartitionPlacingCentersAlgorithm(settings, zeroTaus, muValueGetters);
while (true)
{
placingAlgorithm.DoIteration(muValueGetters);
var centers = placingAlgorithm.GetCenters();
var targetFunctionalCalculator = new TargetFunctionalCalculator(settings);
var targetFunctionalValue = targetFunctionalCalculator.CalculateFunctionalValue(muValueGetters);
Trace.WriteLine($"Target functional value = {targetFunctionalValue}\n");
for (int i = 0; i < settings.CentersSettings.CentersCount; i++)
{
settings.CentersSettings.CenterDatas[i].Position = centers[i].Clone();
Trace.WriteLine($"Center #{i + 1}: {centers[i][0]:0.00} {centers[i][1]:0.00}");
}
calculator = new FuzzyPartitionFixedCentersAlgorithm(settings);
partition = calculator.BuildPartition();
if (placingAlgorithm.IsStopConditionSatisfied())
{
break;
}
}
var list = placingAlgorithm.GetCenters();
for (var index = 0; index < list.Count; index++)
{
var center = list[index];
Trace.WriteLine($"Center #{index + 1}: {center[0]:0.00} {center[1]:0.00}");
}
Trace.Flush();
var vec = VectorUtils.CreateVector(44, 4, 4, 4, 4);
var x = 4;
}
public GridValueTextureCalculator GetGridValueTextureCalculator(RenderTexture renderTexture2d, PartitionSettings partitionSettings)
{
var gridSizeX = partitionSettings.SpaceSettings.GridSize[0];
var textureArray = GetTextureNativeArray(renderTexture2d);
var calculator = new GridValueTextureCalculator(textureArray, gridSizeX);
return(calculator);
}
public PartitionCreationWindow(PartitionSettings partitionSettings)
{
_partitionSettings = partitionSettings;
InitializeComponent();
}
public TargetFunctionalCalculator(PartitionSettings partitionSettings)
{
Settings = partitionSettings;
}
public static GridValueInterpolator ToGridValueInterpolator(this Matrix <double> matrix, PartitionSettings partitionSettings)
{
return(new GridValueInterpolator(partitionSettings.SpaceSettings, new MatrixGridValueGetter(matrix)));
}
public GridValueInterpolator GetGridValueInterpolator(RenderTexture renderTexture2d, PartitionSettings partitionSettings)
{
var calculator = GetGridValueTextureCalculator(renderTexture2d, partitionSettings);
var interpolator = new GridValueInterpolator(partitionSettings.SpaceSettings, calculator);
return(interpolator);
}
public List <GridValueInterpolator> GetGridValueInterpolators(RenderTexture gridsRenderTexture, PartitionSettings partitionSettings)
{
var gridValueGetters = GetGridCellsGetters(gridsRenderTexture, partitionSettings);
var interpolators = gridValueGetters.Select(v => new GridValueInterpolator(partitionSettings.SpaceSettings, v)).ToList();
return(interpolators);
}
public List <IGridCellValueGetter> GetGridCellsGetters(RenderTexture gridsRenderTexture, PartitionSettings partitionSettings)
{
var list = new List <IGridCellValueGetter>();
for (var centerIndex = 0; centerIndex < partitionSettings.CentersSettings.CentersCount; centerIndex++)
{
var data = GetTextureNativeArray(gridsRenderTexture, centerIndex);
Assert.AreEqual(data.Length, partitionSettings.SpaceSettings.GridSize[0] * partitionSettings.SpaceSettings.GridSize[1]);
var valueTextureGetter = new GridValueTextureCalculator(data, partitionSettings.SpaceSettings.GridSize[0]);
list.Add(valueTextureGetter);
}
return(list);
}
public void MuGridsFixedPartition8x8Test()
{
const string f = "Logs.txt";
if (File.Exists(f))
{
File.Delete(f);
}
Trace.Listeners.Add(new TextWriterTraceListener(f));
var settings = new PartitionSettings
{
SpaceSettings = new SpaceSettings
{
MinCorner = VectorUtils.CreateVector(0, 0),
MaxCorner = VectorUtils.CreateVector(10, 10),
GridSize = new List <int> {
80, 80
},
DensityType = DensityType.Everywhere1,
MetricsType = MetricsType.Euclidean,
CustomDensityFunction = null,
CustomDistanceFunction = null
},
CentersSettings = new CentersSettings
{
CentersCount = 2,
CenterDatas = new List <CenterData>
{
new CenterData
{
A = 0,
W = 1,
Position = VectorUtils.CreateVector(1, 1),
IsFixed = true
},
new CenterData
{
A = 0,
W = 1,
//Position = VectorUtils.CreateVector(2, 4),
Position = VectorUtils.CreateVector(9, 1),
IsFixed = true
},
}
},
FuzzyPartitionFixedCentersSettings = new FuzzyPartitionFixedCentersSettings
{
GradientEpsilon = 0.001,
GradientStep = 10,
MaxIterationsCount = 400
},
FuzzyPartitionPlacingCentersSettings = new FuzzyPartitionPlacingCentersSettings
{
GaussLegendreIntegralOrder = 4
}
};
var calculator = new FuzzyPartitionFixedCentersAlgorithm(settings);
var partition = calculator.BuildPartition(out var psiGrid);
Trace.WriteLine($"PerformedIterationsCount = {calculator.PerformedIterationsCount}");
var muValueGetters = partition.Select(v => new GridValueInterpolator(settings.SpaceSettings, new MatrixGridValueGetter(v))).ToList();
var targetFunctionalCalculator = new TargetFunctionalCalculator(settings);
var targetFunctionalValue = targetFunctionalCalculator.CalculateFunctionalValue(muValueGetters);
Trace.WriteLine($"Target functional value = {targetFunctionalValue}\n");
var dualFunctionalCalculator = new DualFunctionalCalculator(settings, psiGrid.ToGridValueInterpolator(settings));
var dualFunctionalValue = dualFunctionalCalculator.CalculateFunctionalValue();
Trace.WriteLine($"Dual functional value = {dualFunctionalValue}\n");
Trace.WriteLine("Center #1 Mu matrix:");
MatrixUtils.WriteMatrix(partition[0], WriteLine, 3);
Trace.WriteLine("Center #2 Mu matrix:");
MatrixUtils.WriteMatrix(partition[1], WriteLine, 3);
var sum = partition.Aggregate((a, b) => a + b);
Trace.WriteLine("Sum mu matrix:");
MatrixUtils.WriteMatrix(sum, WriteLine, 3);
Trace.Flush();
Assert.AreEqual(targetFunctionalValue, dualFunctionalValue, 1d);
var q = 5;
}
public FuzzyPartitionFixedCentersAlgorithm(PartitionSettings partitionSettings)
{
_settings = partitionSettings;
}
