public void AddLabel(int offset, Label label, bool overwrite)
{
// adding null label removes it
if (label == null)
{
if (Labels.ContainsKey(offset))
{
Labels.Remove(offset);
}
return;
}
if (overwrite)
{
if (Labels.ContainsKey(offset))
{
Labels.Remove(offset);
}
}
if (!Labels.ContainsKey(offset))
{
label.CleanUp();
Labels.Add(offset, label);
}
}
public void MarkLabel(string label)
{
if (Labels.ContainsKey(label))
{
throw new Exception($"Label [{label}] already defined.");
}
Labels[label] = _program.Count;
}
public string GetLabel(string name)
{
if (Labels.ContainsKey(name))
{
return(Labels[name]);
}
return(name);
}
private void HoistingExecuteStatement(LabelStatement statement)
{
if (Labels.ContainsKey(statement.Label))
{
throw new RuntimeException(statement.LinePragma,
string.Format(ExceptionResource.LabelAlreadyExists, statement.Label));
}
Labels.Add(statement.Label, statement);
HoistingExecuteStatement(statement.Statement);
}
public void AddLabel(string name, int position)
{
if (!Labels.ContainsKey(name))
{
Labels.Add(name, position);
}
else
{
throw new Exception("Лабелата веќе постои.");
}
}
public Label GetLabel(uint pos)
{
if (Labels.ContainsKey(pos))
{
Labels[pos].UsageCount++;
return(Labels[pos]);
}
var label = new Label {
OpLocation = (int)pos, UsageCount = 1
};
Labels.Add(pos, label);
return(label);
}
public override LeadRectD GetInvalidateRect(AnnContainerMapper mapper, IAnnObjectRenderer renderer)
{
LeadRectD invalidateRect = base.GetInvalidateRect(mapper, renderer);
// Add angle label to the invalidate rect
IAnnLabelRenderer labelRenderer = renderer.LabelRenderer;
if (labelRenderer != null && labelRenderer.RenderingEngine != null && Labels.ContainsKey("CobbAngle"))
{
AnnLabel label = Labels["CobbAngle"];
LeadRectD lablebounds = labelRenderer.GetBounds(mapper, label, FixedStateOperations);
invalidateRect = LeadRectD.UnionRects(lablebounds, invalidateRect);
}
return(invalidateRect);
}
/// <summary>
/// Emits a label into the code stream.
/// </summary>
/// <param name="label">The label name to emit.</param>
public void Label(int label)
{
/*
* Labels are used to resolve branches inside a procedure. Branches outside
* of procedures are handled differently, t.b.d.
*
* So we store the current instruction offset with the label info to be able to
* resolve jumps to this location.
*
*/
Debug.Assert(!Labels.ContainsKey(label));
// Add this label to the label list, so we can resolve the jump later on
Labels.Add(label, (int)CodeStream.Position);
}
/// <summary>
/// Updates the percentage probability of each label at this state.
/// </summary>
/// <param name="correctLabel"></param>
public void AdjustLabels(FeatureValuePair correctLabel)
{
//Check impurity. If it is very high, reset the labels.
if (GiniImpurity > 0.99)
{
foreach (var l in Labels.ToList())
{
Labels[l.Key] = 0;
LabelsCount[l.Key] = 0;
}
}
//Reduce label counts occasionally (to prevent going to infinity)
if (LabelsCount.Sum(p => p.Value) > 10000)
{
foreach (FeatureValuePair label in Labels.Select(p => p.Key))
{
LabelsCount[label] /= 10;
}
}
//Add missing label
if (!Labels.ContainsKey(correctLabel))
{
Labels.Add(correctLabel, 0.0);
LabelsCount.Add(correctLabel, 0);
}
//Increase experiences of label
LabelsCount[correctLabel]++;
//Recalculate percentages and gini impurity
double sumCount = LabelsCount.Sum(p => p.Value);
double sumGini = 0;
foreach (var l in Labels.ToList())
{
double labelPercent = LabelsCount[l.Key] / (sumCount); // 0.0 to 1.0
Labels[l.Key] = labelPercent;
sumGini += Math.Pow(labelPercent, 2.0);
}
double maxGini = 1.00000001 - (1.0 / Labels.Count); // 0.000001 prevents division by zero.
GiniImpurity = (1 - sumGini) / maxGini;
}
public int GetLabel(string label)
{
if (Labels.ContainsKey(label))
{
return(Labels[label]);
}
else
{
if (!ForwardRefs.ContainsKey(label))
{
ForwardRefs[label] = new List <int> ();
}
ForwardRefs[label].Add(_program.Count);
return(int.MaxValue);
}
}
public void AddStatement(Statement statement, ParserState state)
{
if (statement.HasLabel && Labels.ContainsKey(statement.Label))
{
throw new CompilationException("Statement with same label '" + statement.Label + "' already exists", state);
}
if (statement.HasLabel && Constants.ContainsKey(statement.Label))
{
throw new CompilationException("Constant with same label '" + statement.Label + "' already exists", state);
}
Statements.Add(statement);
if (statement.HasLabel)
{
Labels[statement.Label] = Statements.Count - 1;
}
}
/// <summary>
/// Executes the statements and returns the result.
/// </summary>
/// <param name="statements">The statements to be executed.</param>
/// <returns>The execution result of <paramref name="statements"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="statements"/> is <see langword="null"/>, or contains <see langword="null"/>.</exception>
/// <exception cref="RuntimeException">An exception occurred during the execution of the statements.</exception>
public ExecuteResult ExecuteStatements(StatementCollection statements)
{
if (statements == null || statements.Contains(null))
{
throw new ArgumentNullException();
}
if (Labels == null)
{
Labels = new Dictionary <string, LabelStatement>();
}
HoistingExecuteStatements(statements);
ExecuteResult flow;
for (int i = 0; i < statements.Count; i++)
{
CancellationToken.ThrowIfCancellationRequested();
flow = ExecuteStatement(statements[i]);
label:
if (flow.FlowControl == FlowControl.Goto)
{
var go = (string)flow.Data;
if (Labels.ContainsKey(go))
{
i = statements.IndexOf(Labels[go]);
flow = ExecuteStatement(Labels[go]);
goto label;
}
else
{
return(flow);
}
}
else if (flow.FlowControl == FlowControl.Break ||
flow.FlowControl == FlowControl.Return ||
flow.FlowControl == FlowControl.Continue)
{
return(flow);
}
}
Labels.Clear();
return(ExecuteResult.Next);
}
private LabelMetadata LookupLabel(string Name)
{
if (!Labels.ContainsKey(Name))
{
// Create the label if it does not exist yet.
// Remember, labels can be referenced before they are declared
var Add = new LabelMetadata();
Add.Label = Generator.DefineLabel();
Add.Name = Name;
Add.Resolved = false;
Labels.Add(Name, Add);
return(Add);
}
else
{
return(Labels[Name]);
}
}
public void VerifyForwardRefs()
{
foreach (var fwd in ForwardRefs.Keys)
{
if (!Labels.ContainsKey(fwd))
{
throw new Exception($"Label [{fwd}] was never defined");
}
var address = Labels[fwd];
var bytes = Utils.GetBytes(address);
foreach (var target in ForwardRefs[fwd])
{
for (int i = 0; i < bytes.Length; i++)
{
_program[i + target] = bytes[i];
}
}
}
}
public bool IsLabel(string s)
{
return(Labels.ContainsKey(s));
}
public bool IsLabelDecalared(string name)
{
return(Labels.ContainsKey(name));
}
public static bool SelectLanguage(Language language)
{
try
{
var languageName = Db.Context.Labels.FirstOrDefault(p => p.LanguageID == language.ID && p.TermID == id_languageName);
CurrentLanguage = new Language
{
ID = language.ID,
LanguageNameID = languageName?.ID ?? Default_ID_Language_Name,
Label = languageName.Value ?? UnknownLabel
};
UnknownLabel = Db.Context.Labels.FirstOrDefault(p => p.LanguageID == language.ID && p.TermID == id_unknownLabel)?.Value ?? "unknown_label";
Labels.Clear();
var terms = Db.Context.Terms.ToDictionary(p => p.ID, p => p.Value);
foreach (var label in Db.Context.Labels.Where(p => p.LanguageID == language.ID))
{
var term = terms.FirstOrDefault(p => p.Key == label.TermID).Value;
if (!Labels.ContainsKey(term))
{
Labels.Add(term, label.Value);
}
}
ModeLabels.Clear();
foreach (var mode in Db.Context.Modes)
{
if (!ModeLabels.ContainsKey(mode.ID))
{
ModeLabels.Add(mode.ID, Labels[terms[mode.LabelID]]);
}
}
NumberLabels.Clear();
foreach (var number in Db.Context.Numbers)
{
if (!NumberLabels.ContainsKey(number.ID))
{
NumberLabels.Add(number.ID, Labels[terms[number.LabelID]]);
}
}
PersonLabels.Clear();
foreach (var person in Db.Context.Persons)
{
if (!PersonLabels.ContainsKey(person.ID))
{
PersonLabels.Add(person.ID, Labels[terms[person.LabelID]]);
}
}
GenderLabels.Clear();
foreach (var gender in Db.Context.Genders)
{
if (!GenderLabels.ContainsKey(gender.ID))
{
GenderLabels.Add(gender.ID, Labels[terms[gender.LabelID]]);
}
}
}
catch (Exception ex)
{
return(false);
}
OnLanguageChanged?.Invoke(null, EventArgs.Empty);
return(true);
}
internal override void Process(IChart chart)
{
Data = new List <MultiDimensionalPoint>();
var tags = new List <object>();
var min = double.MaxValue;
var max = double.MinValue;
foreach (var obj in SourceCollection)
{
var point = new MultiDimensionalPoint(Dimension);
for (int i = 0; i < Dimension; i++)
{
point[i] = m_Mappings[i](obj);
}
if (m_TagMapping != null)
{
tags.Add(m_TagMapping(obj));
}
else
{
tags.Add(null);
}
Data.Add(point);
}
if (m_OpacityDimension.HasValue)
{
foreach (var multiDimensionalPoint in Data)
{
if (multiDimensionalPoint[m_OpacityDimension.Value] < min)
{
min = multiDimensionalPoint[m_OpacityDimension.Value];
}
if (multiDimensionalPoint[m_OpacityDimension.Value] > max)
{
max = multiDimensionalPoint[m_OpacityDimension.Value];
}
}
}
var chartDataProvider = new ParallelCoordinatesChartDataProvider();
if (chart.AutoGenerateAxes)
{
var labels = new string[Dimension + 1];
for (int i = 0; i < Dimension; i++)
{
labels[i] = "Axis " + i;
if (Labels.ContainsKey(i))
{
labels[i] = Labels[i];
}
}
labels[Dimension] = HelperAxisLabel;
chartDataProvider.AttachAxes(chart, Dimension, labels);
}
if (m_OpacityDimension.HasValue)
{
int i = 0;
foreach (var multiDimensionalPoint in Data)
{
ChartLine line = chartDataProvider.AttachDataSet(chart, multiDimensionalPoint, Dimension, tags[i]);
line.Opacity = m_MinimumOpacity + (1.0 - m_MinimumOpacity) *
((multiDimensionalPoint[m_OpacityDimension.Value] - min) / (max - min));
i++;
}
}
else
{
chartDataProvider.AttachDataSets(chart, Data, Dimension, tags.ToArray());
}
}