/// <summary> /// Assign a constant value to an input parameter of the base macro /// </summary> /// <param name="hlValueAccess">The full or partial macro parameter</param> /// <param name="assignedValue">The constant value to be assigned to the parameter</param> internal void DefineParameter(LanguageValueAccess hlValueAccess, ILanguageValue assignedValue) { //The parameter must be an input parameter if (hlValueAccess.RootSymbolAsParameter.DirectionOut) { throw new InvalidOperationException("Output parameters cannot be assigned initial values"); } //If the value access is of primitive type just assign the value directly var valuePrimitive = assignedValue as ILanguageValuePrimitive; if (valuePrimitive != null) { DataTable.DefineConstantInputParameter(hlValueAccess, valuePrimitive); return; } //If the value access is of compoiste type break it into all primitive components with corresponding //primitive values var assignmentsList = hlValueAccess.ExpandAndAssignAll(assignedValue); foreach (var assignment in assignmentsList) { DataTable.DefineConstantInputParameter(assignment.Item1, assignment.Item2); } }
/// <summary> /// Apply the given value access to the source value to read a partial value /// </summary> /// <param name="sourceValue"></param> /// <param name="valueAccess"></param> /// <returns></returns> public virtual ILanguageValue ReadPartialValue(ILanguageValue sourceValue, LanguageValueAccess valueAccess) { return (valueAccess .PartialAccessSteps .Aggregate(sourceValue, ReadPartialValue)); }
/// <summary> /// Construct the composite value of a structure value access from the table items. /// If no low-level items are found this method returns a default structure sparse value /// </summary> /// <param name="valueAccess"></param> /// <returns></returns> public ValueStructureSparse ReadRhsStructureValue(LanguageValueAccess valueAccess) { var structure = (GMacStructure)valueAccess.ExpressionType; var structValue = ValueStructureSparse.Create(structure); foreach (var dataMember in structure.DataMembers) { ILanguageValue dataMemberValue = null; var childValueAccess = valueAccess.Duplicate().Append(dataMember.ObjectName, dataMember.SymbolType); if (dataMember.SymbolType is TypePrimitive) { dataMemberValue = ReadRHSPrimitiveValue_ExistingOnly(childValueAccess); } else if (dataMember.SymbolType is GMacFrameMultivector) { dataMemberValue = ReadRHSMultivectorValue_ExistingOnly(childValueAccess); } else if (dataMember.SymbolType is GMacStructure) { dataMemberValue = ReadRHSStructureValue_ExistingOnly(childValueAccess); } if (ReferenceEquals(dataMemberValue, null) == false) { structValue[dataMember.ObjectName] = dataMemberValue; } } return(structValue); }
internal static SimpleTreeNode <Expr> ToSimpleExprTree(this ILanguageValue value) { var scalarValue = value as ValuePrimitive <MathematicaScalar>; if (ReferenceEquals(scalarValue, null) == false) { return(ToSimpleExprTree(scalarValue)); } var mvValue = value as GMacValueMultivector; if (ReferenceEquals(mvValue, null) == false) { return(ToSimpleExprTree(mvValue)); } var structValue = value as ValueStructureSparse; if (ReferenceEquals(structValue, null) == false) { return(ToSimpleExprTree(structValue)); } return(null); }
protected override ILanguageValue ReadPartialValue(ILanguageValue sourceValue, ValueAccessStep valueAccessStep) { if (sourceValue.ExpressionType is GMacStructure) { var structureValue = (ValueStructureSparse)sourceValue; return(structureValue[((ValueAccessStepByKey <string>)valueAccessStep).AccessKey]); } if (!(sourceValue.ExpressionType is GMacFrameMultivector)) { throw new InvalidOperationException("Invalid source value type"); } var mvValue = (GMacValueMultivector)sourceValue; var stepByKey = valueAccessStep as ValueAccessStepByKey <int>; if (stepByKey != null) { return(mvValue[stepByKey.AccessKey]); } var stepByKeyList = valueAccessStep as ValueAccessStepByKeyList <int>; if (stepByKeyList != null) { return(mvValue[stepByKeyList.AccessKeyList]); } throw new InvalidOperationException("Invalid access step for a multivector"); }
internal static AstValue ToAstValue(this ILanguageValue expr) { var s2 = expr as ValuePrimitive <MathematicaScalar>; if (ReferenceEquals(s2, null) == false) { return(new AstValueScalar(s2)); } var s3 = expr as GMacValueMultivector; if (ReferenceEquals(s3, null) == false) { return(new AstValueMultivector(s3)); } var s4 = expr as ValueStructureSparse; if (ReferenceEquals(s4, null) == false) { return(new AstValueStructure(s4)); } return(null); }
/// <summary> /// Update the low-level variables related to the given high-level variable using the given RHS value /// </summary> /// <param name="lhsValueAccess">The high-level LHS variable</param> /// <param name="rhsValue">The high-level RHS value</param> private void WriteToLhsVariables(LanguageValueAccess lhsValueAccess, ILanguageValue rhsValue) { //The high-level variable is of primitive type if (lhsValueAccess.ExpressionType is TypePrimitive) { DataTable.WriteLhsPrimitiveValue(lhsValueAccess, (ValuePrimitive <MathematicaScalar>)rhsValue); } //The high-level variable is of composite multivector type else if (lhsValueAccess.ExpressionType is GMacFrameMultivector) { DataTable.WriteLhsMultivectorValue(lhsValueAccess, (GMacValueMultivector)rhsValue); } //The high-level variable is of composite structure type else if (lhsValueAccess.ExpressionType is GMacStructure) { DataTable.WriteLhsStructureValue(lhsValueAccess, (ValueStructureSparse)rhsValue); } //This should never happen else { throw new InvalidOperationException(); } }
protected override void UpdateSymbolValue(LanguageValueAccess valueAccess, ILanguageValue value) { if (GMacCompilerOptions.SimplifyLowLevelRhsValues) { value.Simplify(); } base.UpdateSymbolValue(valueAccess, value); }
/// <summary> /// Process a high-level RHS value into a form suitable for low-leve code generation /// </summary> /// <param name="value"></param> /// <returns></returns> public override ILanguageValue Visit(ILanguageValue value) { //If this is a primitive value convert it into a Mathematica Scalar primitive value var valuePrimitive = value as ILanguageValuePrimitive; return (valuePrimitive == null ? value : valuePrimitive.ToScalarValue()); }
private TreeNode Visit(string lhsName, ILanguageValue rhsValue) { var node = new TreeNode("<ASSIGN> " + lhsName) { Tag = lhsName }; node.Nodes.Add(rhsValue.AcceptVisitor(this)); return(node); }
/// <summary> /// Change a partial value inside the source value using the given value access /// </summary> /// <param name="sourceValue"></param> /// <param name="valueAccess"></param> /// <param name="value"></param> /// <returns></returns> public virtual ILanguageValue WritePartialValue(ILanguageValue sourceValue, LanguageValueAccess valueAccess, ILanguageValue value) { if (valueAccess.IsFullAccess) { throw new InvalidOperationException(); } sourceValue = valueAccess .PartialAccessStepsExceptLast .Aggregate(sourceValue, ReadPartialValue); return(WritePartialValue(sourceValue, valueAccess.LastAccessStep, value)); }
/// <summary> /// Dynamic evaluation extension method /// </summary> /// <param name="value1">The first operand</param> /// <param name="binaryOp">The binaty operation</param> /// <param name="value2">The second operand</param> /// <returns>The value of evaluation the operations on the two operands</returns> public static ILanguageValue AcceptOperation(this ILanguageValue value1, LanguageBasicBinaryDynamicEvaluator binaryOp, ILanguageValue value2) { try { //Polymorphic Visit call return(((dynamic)binaryOp).Evaluate((dynamic)value1, (dynamic)value2)); } catch (RuntimeBinderException excException) { //Do not use the fallback method if (binaryOp.UseExceptions) { throw; } //Use the fallback method return(binaryOp.Fallback(value1, value2, excException)); } }
protected override ILanguageValue WritePartialValue(ILanguageValue sourceValue, ValueAccessStep valueAccessStep, ILanguageValue value) { if (sourceValue.ExpressionType is GMacStructure) { var structureValue = (ValueStructureSparse)sourceValue; structureValue[((ValueAccessStepByKey <string>)valueAccessStep).AccessKey] = value; return(value); } if (!(sourceValue.ExpressionType is GMacFrameMultivector)) { throw new InvalidOperationException("Invalid source value type"); } var mvValue = (GMacValueMultivector)sourceValue; var stepByKey = valueAccessStep as ValueAccessStepByKey <int>; if (stepByKey != null) { mvValue[stepByKey.AccessKey] = (ValuePrimitive <MathematicaScalar>)value; } else { var stepByKeyList = valueAccessStep as ValueAccessStepByKeyList <int>; if (stepByKeyList == null) { throw new InvalidOperationException("Invalid access step for a multivector"); } mvValue[stepByKeyList.AccessKeyList] = (GMacValueMultivector)value; } return(value); }
/// <summary> /// Go through every leaf MathematicaScalar in this value and try to simplify its internal /// expression if possible /// </summary> /// <param name="value"></param> public static void Simplify(this ILanguageValue value) { if (ReferenceEquals(value, null)) { return; } var scalarValue = value as ValuePrimitive <MathematicaScalar>; if (ReferenceEquals(scalarValue, null) == false) { scalarValue.Value.Simplify(); return; } var mvValue = value as GMacValueMultivector; if (ReferenceEquals(mvValue, null) == false) { mvValue.MultivectorCoefficients.Simplify(); return; } var stValue = value as ValueStructureSparse; if (ReferenceEquals(stValue, null)) { return; } var removeMembersList = new List <string>(stValue.Count); foreach (var memberValue in stValue) { Simplify(memberValue.Value); var memberScalarValue = memberValue.Value as ValuePrimitive <MathematicaScalar>; if (ReferenceEquals(memberScalarValue, null) == false) { if (memberScalarValue.Value.IsZero()) { removeMembersList.Add(memberValue.Key); } continue; } var memberMvValue = memberValue.Value as GMacValueMultivector; if (ReferenceEquals(memberMvValue, null) == false) { if (memberMvValue.MultivectorCoefficients.Count == 0) { removeMembersList.Add(memberValue.Key); } continue; } var memberStValue = memberValue.Value as ValueStructureSparse; if (ReferenceEquals(memberStValue, null)) { continue; } if (memberStValue.Count == 0) { removeMembersList.Add(memberValue.Key); } } foreach (var memberName in removeMembersList) { stValue.Remove(memberName); } }
internal GMacConstant(string constantName, LanguageScope parentScope, ILanguageValue rhsValue) : base(constantName, parentScope, RoleNames.Constant, rhsValue.ExpressionType) { AssociatedValue = rhsValue; }
public bool TryGetValue(TK key, out ILanguageValue value) { return(InternalDictionary.TryGetValue(key, out value)); }
public void Add(TK key, ILanguageValue value) { InternalDictionary.Add(key, value); }
/// <summary> /// The fall back method that is called if no matching visit method is found and UseExceptions flag is false /// </summary> /// <param name="value1"></param> /// <param name="value2"></param> /// <param name="excException"></param> /// <returns></returns> public abstract ILanguageValue Fallback(ILanguageValue value1, ILanguageValue value2, RuntimeBinderException excException);
/// <summary> /// Create a child constant /// </summary> /// <param name="constantName"></param> /// <param name="constantValue"></param> /// <returns></returns> internal GMacConstant DefineFrameConstant(string constantName, ILanguageValue constantValue) { return(new GMacConstant(constantName, ChildSymbolScope, constantValue)); }
ExpandAndAssignAll(this LanguageValueAccess valueAccess, ILanguageValue value) { valueAccess = ReduceMultivectorAccess(valueAccess); var accessStack = new Stack <LanguageValueAccess>(); accessStack.Push(valueAccess); var valuesStack = new Stack <ILanguageValue>(); valuesStack.Push(value); while (valuesStack.Count > 0) { var rootValueAccess = accessStack.Pop(); var rootValue = valuesStack.Pop(); var valuePrimitive = rootValue as ILanguageValuePrimitive; if (valuePrimitive != null) { yield return (new Tuple <LanguageValueAccess, ILanguageValuePrimitive>( rootValueAccess, valuePrimitive )); continue; } var valueMultivector = rootValue as GMacValueMultivector; if (valueMultivector != null) { var mvValue = valueMultivector; var scalarType = mvValue.CoefficientType; var s = rootValueAccess.LastAccessStep as ValueAccessStepByKeyList <int>; var partialMvFlag = !ReferenceEquals(s, null); var idsList = partialMvFlag ? s.AccessKeyList : null; foreach (var id in mvValue.SymbolicMultivector.NonZeroBasisBladeIds) { if (!ReferenceEquals(idsList, null) && !idsList.Contains(id)) { continue; } var childValueAccess = partialMvFlag ? rootValueAccess.DuplicateExceptLast().Append(id, scalarType) : rootValueAccess.Duplicate().Append(id, scalarType); yield return (new Tuple <LanguageValueAccess, ILanguageValuePrimitive>( childValueAccess, mvValue[id] )); } continue; } var valueStructureSparse = rootValue as ValueStructureSparse; if (valueStructureSparse == null) { continue; } var structValue = valueStructureSparse; foreach (var pair in structValue) { var dataMemberName = pair.Key; var dataMember = structValue.ValueStructureType.GetDataMember(dataMemberName); var childValueAccess = rootValueAccess .Duplicate() .Append(dataMember.ObjectName, dataMember.SymbolType); var languageValuePrimitive = pair.Value as ILanguageValuePrimitive; if (languageValuePrimitive != null) { yield return (new Tuple <LanguageValueAccess, ILanguageValuePrimitive>( childValueAccess, languageValuePrimitive )); } else { accessStack.Push(childValueAccess); valuesStack.Push(pair.Value); } } } }
public static ValueReference Create(TypeReference valueType, ILanguageValue value) { return(new ValueReference(valueType, value)); }
protected ValueReference(TypeReference valueType, ILanguageValue value) { ValueReferenceType = valueType; Value = value; }
public static ValuePointer Create(TypePointer valueType, ILanguageValue value) { return(new ValuePointer(valueType, value)); }
ExpandAndAssignAll(this SymbolLValue symbol, ILanguageValue value) { return(ExpandAndAssignAll(LanguageValueAccess.Create(symbol), value)); }
/// <summary> /// Read a partial value from the source value using the given value access step /// </summary> /// <param name="sourceValue"></param> /// <param name="valueAccessStep"></param> /// <returns></returns> protected abstract ILanguageValue ReadPartialValue(ILanguageValue sourceValue, ValueAccessStep valueAccessStep);
internal AstValueStructureTerm(GMacStructure structure, string dataMemberName, ILanguageValue dataMemberValue) { AssociatedStructure = structure; DataMemberName = dataMemberName; TermDataMemberValue = dataMemberValue; }
/// <summary> /// Change a partial value inside the source value using the given value access step /// </summary> /// <param name="sourceValue"></param> /// <param name="valueAccessStep"></param> /// <param name="value"></param> /// <returns></returns> protected abstract ILanguageValue WritePartialValue(ILanguageValue sourceValue, ValueAccessStep valueAccessStep, ILanguageValue value);
public override ILanguageValue Fallback(ILanguageValue value1, RuntimeBinderException excException) { throw new NotImplementedException(); }
protected ValuePointer(TypePointer valueType, ILanguageValue value) { ValuePointerType = valueType; Value = value; }
public void SetComponentValue(ValueAccessStep accessStep, ILanguageValue value) { throw new NotImplementedException(); }