# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Fuzzy comparisons and aggregations."""
import logging
import math
from firmware_constants import MF
DEFAULT_MEMBERSHIP_FUNCTION = {
'<=': MF.Z_FUNCTION,
'<': MF.Z_FUNCTION,
'>=': MF.S_FUNCTION,
'>': MF.S_FUNCTION,
'==': MF.SINGLETON_FUNCTION,
'~=': MF.PI_FUNCTION,
}
"""Define possible score aggregators: average() and product().
A score aggregator collects all scores from every tests, and calculate
a final score.
"""
def average(data):
"""The average of the elements in data."""
number = len(data)
return math.fsum(data) / number if number > 0 else None
def product(data):
"""The product of the elements in data."""
return math.exp(math.fsum([math.log(d) for d in data]))
"""Classes of various fuzzy member functions are defined below."""
class FuzzyMemberFunctions(object):
"""The base class of membership functions."""
def __init__(self, para):
"""Example of parameter: (0.1, 0.3)."""
self.para_values = map(float, para)
class FuzzySingletonMemberFunction(FuzzyMemberFunctions):
"""A class provides fuzzy Singleton Membership Function.
Singleton Membership Function:
parameters: (left, middle, right)
grade(x) = 0.0, when x <= left
0.0 to 1.0, when left <= x <= middle
1.0, when x == middle
1.0 to 0.0, when middle <= x <= right
0.0, when x >= right
E.g., FuzzySingletonMemberFunction((1, 1, 1))
Usage: when we want the x == 1 in the ideal condition.
grade = 1.0, when x == 1
0.0, when x != 1
Note: - When x is near 'middle', the grade would be pretty close to 1.
- When x becomes near 'left' or 'right', its grade may drop
faster and would approach 0.
- A cosine function is used to implement this behavior.
"""
def __init__(self, para):
super(FuzzySingletonMemberFunction, self).__init__(para)
self.left, self.middle, self.right = self.para_values
self.width_right = self.right - self.middle
self.width_left = self.middle - self.left
def grade(self, x):
"""The grading method of the fuzzy membership function."""
if x == self.middle:
return 1
elif x <= self.left or x >= self.right:
return 0
elif x > self.middle:
return (0.5 + 0.5 * math.cos((x - self.middle) / self.width_right *
math.pi))
elif x < self.middle:
return (0.5 + 0.5 * math.cos((x - self.middle) / self.width_left *
math.pi))
class FuzzySMemberFunction(FuzzyMemberFunctions):
"""A class provides fuzzy S Membership Function.
S Membership Function:
parameters: (left, right)
grade(x) = 1 for x >= right
0 for x <= left
E.g., FuzzySMemberFunction((0.1, 0.3))
Usage: when we want the x >= 0.3 in the ideal condition.
grade = 1.0, when x >= 0.3
between 0.0 and 1.0, when 0.1 <= x <= 0.3
0.0, when x <= 0.1
Note: - When x is less than but near 'right' value, the grade would be
pretty close to 1.
- When x becomes near 'left' value, its grade may drop faster
and would approach 0.
- A cosine function is used to implement this behavior.
"""
def __init__(self, para):
super(FuzzySMemberFunction, self).__init__(para)
self.left, self.right = self.para_values
self.width = self.right - self.left
def grade(self, x):
"""The grading method of the fuzzy membership function."""
if x >= self.right:
return 1
elif x <= self.left:
return 0
else:
return 0.5 + 0.5 * math.cos((x - self.right) / self.width * math.pi)
class FuzzyZMemberFunction(FuzzyMemberFunctions):
"""A class provides fuzzy Z Membership Function.
Z Membership Function:
parameters: (left, right)
grade(x) = 1 for x <= left
0 for x >= right
E.g., FuzzyZMemberFunction((0.1, 0.3))
Usage: when we want the x <= 0.1 in the ideal condition.
grade = 1.0, when x <= 0.1
between 0.0 and 1.0, when 0.1 <= x <= 0.3
0.0, when x >= 0.3
Note: - When x is greater than but near 'left' value, the grade would be
pretty close to 1.
- When x becomes near 'right' value, its grade may drop faster
and would approach 0.
- A cosine function is used to implement this behavior.
"""
def __init__(self, para):
super(FuzzyZMemberFunction, self).__init__(para)
self.left, self.right = self.para_values
self.width = self.right - self.left
def grade(self, x):
"""The grading method of the fuzzy membership function."""
if x <= self.left:
return 1
elif x >= self.right:
return 0
else:
return 0.5 + 0.5 * math.cos((x - self.left) / self.width * math.pi)
# Mapping from membership functions to the fuzzy member function classes.
MF_DICT = {
# TODO(josephsih): PI, TRAPEZ, and TRIANGLE functions are to be implemented.
# MF.PI_FUNCTION: FuzzyPiMemberFunction,
MF.SINGLETON_FUNCTION: FuzzySingletonMemberFunction,
MF.S_FUNCTION: FuzzySMemberFunction,
# MF.TRAPEZ_FUNCTION: FuzzyTrapezMemberFunction,
# MF.TRIANGLE_FUNCTION: FuzzyTriangleMemberFunction
MF.Z_FUNCTION: FuzzyZMemberFunction,
}
class FuzzyCriteria:
"""A class to parse criteria string and build the criteria object."""
def __init__(self, criteria_str, mf=None):
self.criteria_str = criteria_str
self.mf_name = mf
self.mf = None
self.default_mf_name = None
self.value_range = None
self._parse_criteria_and_exit_on_failure()
self._create_mf()
def _parse_criteria(self, criteria_str):
"""Parse the criteria string.
Example:
Ex 1. '<= 0.05, ~ +0.07':
. The ideal input value should be <= 0.05. If so, it gets
the grade 1.0
. The allowable upper bound is 0.05 + 0.07 = 0.12. Anything
greater than or equal to 0.12 would get a grade 0.0
. Any input value falling between 0.05 and 0.12 would get a
score between 0.0 and 1.0 depending on which membership
function is used.
"""
criteria_list = criteria_str.split(',')
tolerable_delta = []
op_value = None
for c in criteria_list:
op, value = c.split()
# TODO(josephsih): should support and '~=' later.
if op in ['<=', '<', '>=', '>', '==']:
primary_op = op
self.default_mf_name = DEFAULT_MEMBERSHIP_FUNCTION[op]
op_value = float(value)
elif op == '~':
tolerable_delta.append(float(value))
else:
return False
# Syntax error in criteria string
if op_value is None:
return False
# Calculate the allowable range of values
range_max = range_min = op_value
for delta in tolerable_delta:
if delta >= 0:
range_max = op_value + delta
else:
range_min = op_value + delta
if primary_op in ['<=', '<', '>=', '>']:
self.value_range = (range_min, range_max)
elif primary_op == '==':
self.value_range = (range_min, op_value, range_max)
else:
self.value_range = None
return True
def _parse_criteria_and_exit_on_failure(self):
"""Call _parse_critera and exit on failure."""
if not self._parse_criteria(self.criteria_str):
logging.error('Parsing criteria string error.')
exit(1)
def _create_mf(self):
"""Parse the criteria and create its membership function object."""
# If a membership function is specified in the test_conf, use it.
# Otherwise, use the default one.
mf_name = self.mf_name if self.mf_name else self.default_mf_name
mf_class = MF_DICT[mf_name]
self.mf = mf_class(self.value_range)
def get_criteria_value_range(self):
"""Parse the criteria and return its op value."""
return self.value_range