private bool CalculateExpression(List <string> array, double L, double U)
{
List <string> stack = new List <string>();
for (int i = 0; i < array.Count; i++)
{
if (!Operator.Contains(array[i]))
{
stack.Add(array[i]);
}
else // Lấy hai giá trị ra khỏi stack và tính toán
{
string valueTwo = stack[stack.Count - 1].Trim(); // get value
string valueOne = stack[stack.Count - 2].Trim();
stack.RemoveAt(stack.Count - 1); // xóa valueTwo
stack.RemoveAt(stack.Count - 1); // xóa valueOne
string value = GetProbInterval(valueOne, valueTwo, array[i].Trim());
if (value == string.Empty)
{
//this.conditionString = string.Empty; //kiem tra lai
return(false);
}
stack.Add(value);
}
}
// Lấy khoảng xác suất của biểu thức chọn sau khi tính toán
var tupleProp = new ElemProb(stack[0].Trim());
return(L <= tupleProp.lowerBound && tupleProp.upperBound <= U); // trả về true nếu khoảng xác biểu thức chọn thỏa mãn xác xuất câu truy vấn
}
private bool ExpressionValue(string Str) //str is a single expression ex:"(patient.bloodtype_= 'b')"
{
// Get Probabilistic Interval
ElemProb probInterval = convertConditionStrToProbInterVal(Str);
// Get Selection Expression
Str = converConditionStringToExpression(Str);
List <string> array = new List <string>();
// reverse to postfix notation
array = SE_PostfixNotation(Str);
return(CalculateExpression(array, probInterval.lowerBound, probInterval.upperBound));
}
private string GetProbInterval(string valueOne, string valueTwo, string operaterStr)
{
ElemProb prop = null;
int indexOne, indexTwo, countValue;
PTuple tuple = this.tuple;
//string typenameOne;
//string typenameTwo;
try
{
// Biểu thức so sánh bằng giữa hai thuộc tính trên cùng một bộ
if (operaterStr.Contains("equal_ig") || operaterStr.Contains("equal_in") || operaterStr.Contains("equal_me"))
{
indexOne = IndexOf(valueOne);
indexTwo = IndexOf(valueTwo);
if (indexOne == -1 || indexTwo == -1)
{
return(string.Empty);
}
if (!Attributes[indexOne].Type.DataType.Equals(Attributes[indexTwo].Type.DataType))
{
//Attribute value does not match the data type !
MessageError = String.Format("Error :{0} and {1} must the same data type", valueOne, valueTwo);
return(string.Empty);
}
var low = 0f;
var up = 0f;
foreach (var valInAttr1 in tuple.valueSet[(valueOne)])
{
foreach (var valInAttr2 in tuple.valueSet[(valueTwo)])
{
if (EQUAL(valInAttr1.Trim(), valInAttr2.Trim(), Attributes[indexOne].Type.DataType))
{
switch (operaterStr)
{
case "equal_in":
low += tuple.Ps.lowerBound * tuple.Ps.upperBound;
up = Math.Min(1, up + tuple.Ps.upperBound * tuple.Ps.upperBound);
break;
case "equal_ig":
low += Math.Min(0, tuple.Ps.lowerBound + tuple.Ps.lowerBound - 1);
up = Math.Min(1, up + Math.Min(tuple.Ps.upperBound, tuple.Ps.upperBound));
break;
case "equal_me":
low = 0;
up = Math.Min(1, up + 0); break;
default: break;
}
}
}
}
}
else
if (SelectCondition.isCompareOperator(operaterStr)) // Biểu thức so sánh giữa một thuộc tính với một giá trị
{
indexOne = this.IndexOf(valueOne); // vị trí của thuộc tính trong ds các thuộc tính //what is THIS !?
if (indexOne == -1)
{
return(string.Empty);
}
if (valueTwo.Contains("'"))
{
int count = valueTwo.Split(new char[] { '\'' }).Length - 1;
if (valueTwo.Substring(0, 1) != "'")
{
MessageError = "Unclosed quotation mark before the character string " + valueTwo;
return(string.Empty);
}
if (valueTwo.Substring(valueTwo.Length - 1, 1) != "'")
{
MessageError = "Unclosed quotation mark after the character string " + valueTwo;
return(string.Empty);
}
if (count != 2)
{
MessageError = "Unclosed quotation mark at the character string " + valueTwo;
return(string.Empty);
}
valueTwo = valueTwo.Remove(0, 1);
valueTwo = valueTwo.Remove(valueTwo.Length - 1, 1);
}
PDataType dataType = new PDataType();
dataType.TypeName = Attributes[indexOne].Type.TypeName;
dataType.DataType = Attributes[indexOne].Type.DataType;
dataType.Domain = Attributes[indexOne].Type.Domain;
dataType.DomainString = Attributes[indexOne].Type.DomainString;
if (!dataType.CheckDataTypeOfVariables(valueTwo))
{
MessageError = String.Format("Conversion failed when converting the varchar value {0} to data type {1}.", valueTwo, Attributes[indexOne].Type.DataType.ToString());
return(string.Empty);
}
countValue = tuple.valueSet[(valueOne)].Count;
prop = new ElemProb(0, 0);
foreach (var value in tuple.valueSet[(valueOne)])
{
if (this.Compare(value.ToString().Trim(), valueTwo.ToString(), operaterStr, Attributes[indexOne].Type.DataType.ToString())) //duyet tung value
{
try
{
prop.lowerBound += (1 / (float)countValue);
prop.upperBound += (1 / (float)countValue);
}
catch (Exception ex)
{
MessageError = ex.Message;
}
//break;
}
}
prop.lowerBound *= tuple.Ps.lowerBound;
prop.upperBound *= tuple.Ps.upperBound;
}
else // Biểu thức kết hợp giữa hai khoảng xác suất
{
var prop1 = new ElemProb(valueOne);
var prop2 = new ElemProb(valueTwo);
switch (operaterStr)
{
case "⊗_ig": prop = new ElemProb(Math.Max(0, prop1.lowerBound + prop2.lowerBound - 1), Math.Min(prop1.upperBound, prop2.upperBound)); break;
case "⊗_in": prop = new ElemProb(prop1.lowerBound * prop2.lowerBound, prop1.upperBound * prop2.upperBound); break;
case "⊗_me": prop = new ElemProb(0, 0); break;
case "⊕_ig": prop = new ElemProb(Math.Max(prop1.lowerBound, prop2.lowerBound), Math.Min(1, prop1.upperBound + prop2.upperBound)); break;
case "⊕_in": prop = new ElemProb(prop1.lowerBound + prop2.lowerBound - (prop1.lowerBound * prop2.lowerBound), prop1.upperBound + prop2.upperBound - (prop1.upperBound * prop2.upperBound)); break;
case "⊕_me": prop = new ElemProb(Math.Min(1, prop1.lowerBound + prop2.lowerBound), Math.Min(1, prop1.upperBound + prop2.upperBound)); break;
default:
MessageError = "Incorrect syntax near 'where'.";
break;
}
}
}
catch (Exception ex)
{
MessageError = "Incorrect syntax near 'where'.";
return(string.Empty);
}
//maxProb = 1 > maxProb ? maxProb : 1; // check maxProb
if (prop is null)
{
return(String.Empty);
}
return(String.Format("[{0},{1}]", prop.lowerBound, prop.upperBound));
}
