to class function
161155
@Override
   public void setParameter(double value,int index){
        Compound component = substance.getVapor().getComponent();
        Alpha alpha = substance.getVapor().getAlpha();
        alpha.setParameter(value, component, index);
   }
183304
def transpose_func(classes, table):
    
    transposed_table = table
    for i, item1 in enumerate(classes):
        for j, item2 in enumerate(classes):
            if i > j:
                temp = transposed_table[item1][item2]
                transposed_table[item1][item2] = transposed_table[item2][item1]
                transposed_table[item2][item1] = temp
    return transposed_table
850348
function hasElClass(element, classToCheck) {
  throwIfWhitespace(classToCheck);
  if (element.classList) {
    return element.classList.contains(classToCheck);
  }
  return classRegExp(classToCheck).test(element.className);
}
599783
function(from, to) {
        var classes = ($(from).attr('class') || '').replace(this.options.filterClasses, '').trim();

        if (classes) {
            $(to).addClass(classes);
        }
    }
348595
function Class(name,options) {

  this.name = name || "";
  this.mixins = [];
  this.methods = {};
  this.properties = {};

  if (lib.type.isObject(options)) {
    var keys = Object.keys(options);
    var length = keys.length;
    for (var i = 0; i < length; i++) {
      var key = keys[i];
      var value = options[key];
      if (key === "constructor") {
        this.addConstructor(value);
      } else if (key === "inherits") {
        this.inherit(value);
      } else if (key === "mixins") {
        this.mixin(value);
      } else if (lib.type.isFunction(value) && lib.inherits.superOf(value,Property)) {
        this.addProperty(key,value);
      } else {
        this.addMethod(key,value);
      }
    }
  }

}
226217
function isClass(clazz) {
    return isFunction(clazz) && (clazz.prototype && clazz === clazz.prototype.constructor);
  }
208942
def function_classifier=(function_classifier)
      if function_classifier
        if function_classifier.is_a?(String)
          @function_classifier = function_classifier.strip.chars.select do |char|
            char.to_i.between?(1, 7) || char.upcase.to_s == "B"
          end.map do |char|
            if char.to_i.between?(1, 7)
              char.to_i
            else
              char.upcase.to_sym
            end
          end
        elsif function_classifier.is_a?(Array)
          @function_classifier = function_classifier.flatten
        end
      end
    end
1149275
function handleClassesAndId(str) {
	return str.replace(/(.*?)([\.|#].[^|]*)(.*)/, function (fullStr, tag, classAndIds, end) {
		if (classAndIds[0] === '|') {
			return fullStr;
		}
		const clsIdArr = classAndIds.split(/(\..[^\.|#]*)/).filter(Boolean);
		const returnArr = [];
		let i = clsIdArr.length;
		while (i--) {
			returnArr.push(`|${attrType[clsIdArr[i][0]]}=${clsIdArr[i].substr(1)}`);
		}

		return tag + returnArr.join('') + end;
	});
}
661440
function classToPlantObject(str){
	if ( str == null ) {
		return {};
	}
	if ( isPlainObject(str) ) {
		return str;
	}

	let ary = str.split(/\s/);
	let objCls = {};
	ary.forEach(v => v.trim() && (objCls[v]=1));
	return objCls;
}
1242123
function toFn (value) {
  if (typeof value === 'function') return value

  var str = Array.isArray(value) ? value : String(value)
  var obj = Object.create(null)

  for (var i = 0; i < str.length; i++) {
    obj[str[i]] = true
  }

  return function (char) {
    return obj[char]
  }
}
398497
function classId(func) {
	var result = func['__id__'];
	if (result == null) {
		result = nonenum(func, '__id__', currentId++);
	}
	return result;
}
716868
function getClassOf(value) {
    return value == null
      ? capitalize(value)
      : toString.call(value).slice(8, -1);
  }
814259
def _in_class(self, node):
        """"""
        # Move left one indentation level and check if that callable is a class
        indent = self._get_indent(node)
        for indent_dict in reversed(self._indent_stack):  # pragma: no branch
            if (indent_dict["level"] < indent) or (indent_dict["type"] == "module"):
                return indent_dict["type"] == "class"
1104280
function (domObject, toCheck) {
            var
                classNames,
                len,
                idx;
            if ("string" === typeof toCheck) {
                toCheck = [toCheck];
            }
            _gpfAssert(toCheck instanceof Array, "Expected array");
            classNames = domObject.className.split(" ");
            len = toCheck.length;
            for (idx = 0; idx < len; ++idx) {
                if (undefined !== gpf.test(classNames, toCheck[idx])) {
                    return true;
                }
            }
            return false;
        }
1131201
function classCase(input) {
    return input.toUpperCase().replace(/[\-\s](.)/g, function(match, group1) {
        return group1.toUpperCase();
    });
}
828537
function getClasses(element) {
    const className = element.className;
    const classes = {};
    if (className !== null && className.length > 0) {
        className.split(' ').forEach((className) => {
            if (className.trim().length) {
                classes[className.trim()] = true;
            }
        });
    }
    return classes;
}
85701
def to_function(var_instance, lineno=None):
        
        assert isinstance(var_instance, SymbolVAR)
        from symbols import FUNCTION
        var_instance.__class__ = FUNCTION
        var_instance.class_ = CLASS.function
        var_instance.reset(lineno=lineno)
        return var_instance