def combine_landmarks_sort(self, add_landmark_path): origin_landmarks = { elem.split('_landmarks.txt')[0]: elem for elem in os.listdir(self.input_path) if elem.endswith('.txt') } add_landmarks = { elem.split('_noface')[0]: elem for elem in os.listdir(add_landmark_path) if elem.endswith('.txt') } utility.create_dir(self.output_path) for key in add_landmarks.keys(): if key not in origin_landmarks.keys(): print("{} is not exists in original list".format(key)) continue add_landmark_file_path = "{}/{}".format(add_landmark_path, add_landmarks[key]) origin_landmarks_file_path = "{}/{}".format( self.input_path, origin_landmarks[key]) origin_data = utility.read_file(origin_landmarks_file_path) add_data = utility.read_file(add_landmark_file_path) origin_data += add_data origin_data = sorted(origin_data) #print(key, add_landmarks[key], origin_landmarks[key]) dst_combine_landmark_path = '{}/{}_add_landmarks.txt'.format( self.output_path, key) utility.write_into_file(origin_data, dst_combine_landmark_path)
def read(self): wb_text = utility.read_file(self.wbFile, self.entryNo) info_text = utility.read_file(self.infoFile, self.entryNo) if info_text is not None and wb_text is not None: return "[%s]" % info_text[0], "%s" % wb_text[0] return "No information on this line", None
def wb(self): if not self.hasSearch: result = utility.read_file(self.filename, self.entryNo) if result is not None: line = result[0] index = result[1] count = result[2] else: return "Not enough stupid things have been said yet.", None else: result = utility.read_file(self.filename, self.entryNo, self.search) if result is not None: line = result[0] index = result[1] count = result[2] keyindex = result[3] keycount = result[4] else: return "Not enough stupid things have been said yet.", None # No occurrences of 'param_key' could be found if index == -1: return line, None if self.hasSearch: return "[%d/%d][%d/%d]" % (index, count, keyindex, keycount), "%s" % line return "[%d/%d]" % (index, count), "%s" % line
def parse_dell_asset_multiple(dell_asset_multiple_path): # Parse multiple dell asset object in a single path da_L = [] lines = read_file(dell_asset_multiple_path, isYML=False, isURL=False, lines=True) if lines is not None: i = 0 while i < len(lines): while i < len(lines) and (lines[i] == "" or lines[i].find( DellAsset.header) == 0): i += 1 if i < len(lines): da = DellAsset(dellasset_str=','.join(lines[i].split( ',')[0:DellAsset.header_num])) warranty_L = [] while i < len(lines) and lines[i] != "" and lines[i].find( DellAsset.header) < 0: new_w = Warranty(warranty_str=','.join(lines[i].split( ',')[DellAsset.header_num:])) warranty_L.append(new_w) i += 1 da.set_warranty_L(warranty_L) da_L.append(da) return da_L
def search_existing_dell_asset(svctags, update_translation=True): result = [] possible_file_count = 0 for s in svctags: if s == svc_placeholder: possible_file_count += 1 possible_file_count = 36**possible_file_count pattern = compile_svc_pattern(svctags) if pattern is not None: existing_dell_asset_svctags = list_file_name_in_dir( existing_dell_asset_dir) target_dell_asset_S = set([]) target_count = 0 for svc in existing_dell_asset_svctags: if pattern.match(svc): target_dell_asset_S.add(svc) target_count += 1 if target_count == possible_file_count: break result = DellAsset.parse_dell_asset_file_batch(existing_dell_asset_dir, target_dell_asset_S, logger=None) if update_translation: config = read_file(parent_path + file_config_name, isYML=True, isURL=False) result = update_dell_warranty_translation( config[config_translation_url], result, existing_dell_asset_dir)[0] return result
def clean_list_certain_class_number_label(self, select_num): dst_path = self.input_folder_path.replace( '.txt', '_GE_{}_label.txt'.format(select_num)) f = open(dst_path, 'w') data = utility.read_file(self.input_folder_path) list_container = [] class_num = 0 for index, elem in enumerate(data): if len(list_container) == 0: list_container.append(elem.split(' ')[0]) else: current_prefix, current_name = utility.get_basename_parent_path( elem.split(' ')[0]) last_prefix, last_name = utility.get_basename_parent_path( list_container[-1]) #print(current_prefix, last_prefix) if current_prefix == last_prefix: list_container.append(elem.split(' ')[0]) else: if len(list_container) >= select_num: for line in list_container: f.write('{} {}\n'.format(line, class_num)) class_num += 1 list_container = [] list_container.append(elem.split(' ')[0]) utility.show_process_percentage(index, len(data) - 1, 1000)
def create_pair_list(self, image_list_path, imageid_prefix='id', imagelife_prefix='life'): data = utility.read_file(image_list_path) list_id = [] list_life = [] for line in data: if line.find(imageid_prefix) >= 0: list_id.append(line) elif line.find(imagelife_prefix) >= 0: list_life.append(line) else: print 'no {} or {} exist in {}'.format(imageid_prefix, imagelife_prefix, line) dst_image_pair_list = image_list_path.replace('.txt', 'pair.txt') f = open(dst_image_pair_list, 'w') for index, life_elem in enumerate(list_life): for id_elem in list_id: id_name = id_elem.split('/')[-1].split('_')[0] life_name = life_elem.split('/')[-1].split('_')[0] if id_name == life_name: label = 1 else: label = 0 f.write('{} {} {}\n'.format(life_elem, id_elem, label)) utility.show_process_percentage(index, len(list_life) - 1, 500) f.close()
def collect_all_points(filename, decisions, objectives): indeps = [] deps = [] # print repeat t_indep, t_dep = read_file(filename, decisions, objectives) indeps += t_indep deps += t_dep return indeps, deps
def wb_global(server_filename): result = utility.read_file(server_filename) if result is not None: line = result[0] index = result[1] count = result[2] return "[%d/%d]" % (index, count), "%s" % line
def update_search_history(search_history_path, new_search_svctags_S): existing_search_dict = read_file(search_history_path, isYML=True, isURL=False) new_search_dict = {} current_date = get_current_datetime(is_format=False, is_date=True) for svc in new_search_svctags_S: if svc is not None and svc != "": new_search_dict[svc] = current_date existing_search_dict.update(new_search_dict) return save_object_to_path(existing_search_dict, search_history_path, isYML=True)
def main(argv): ''' :param Processes arguments from command line: :return: ''' parser = argparse.ArgumentParser(description="Find items to buy with a gift card") parser.add_argument('filename', type=str, help='name of file containing items and prices') parser.add_argument('target', type=int, help='amount available in gift card') args = parser.parse_args() bonus(utility.read_file(args.filename),args.target)
def __init__(self, data_folder = ""): if data_folder == "": data_folder = self.DATA_FOLDER for key in self.CATEGORY: file_path = os.path.join(data_folder, "%s.txt" % key) self.classifier[key] = set() if os.path.isfile(file_path): self.classifier[key] = utility.read_file(file_path)
def collect_all_points(subdir, decisions, objectives): indeps = [] deps = [] repeats = [subdir + f for f in os.listdir(subdir) if ".DS_Store" not in f] for repeat in repeats: # print repeat t_indep, t_dep = read_file(repeat, decisions, objectives) indeps += t_indep deps += t_dep return indeps, deps
def create_fakeface_label_from_landmark(self, landmark_path): label_path = landmark_path.replace('.txt', '_label.txt') f = open(label_path, 'w') data = utility.read_file(landmark_path) for index, elem in enumerate(data): image_path = elem.split(' ')[0] label = image_path.split('/')[0].split('_')[0] f.write('{} {}\n'.format(image_path, label)) utility.show_process_percentage(index, len(data) - 1, 500) f.close()
def parse_dell_asset_file(dell_asset_path): lines = read_file(dell_asset_path, isYML=False, isURL=False, lines=True) if lines is not None and len(lines) > 1: da = DellAsset(dellasset_str=','.join(lines[1].split(',')[0:DellAsset.header_num])) warranty_L = [] for i in xrange(1, len(lines)): if lines[i] != "": warranty_L.append(Warranty(warranty_str=','.join(lines[i].split(',')[DellAsset.header_num:]))) da.set_warranty_L(warranty_L) return da else: return None
def update_search_history(search_history_path, new_search_svctags_S): existing_search_dict = read_file(search_history_path, isYML=True, isURL=False) new_search_dict = {} current_date = get_current_datetime(is_format=False, is_date=True) for svc in new_search_svctags_S: if svc is not None and svc != "": new_search_dict[svc] = current_date existing_search_dict.update(new_search_dict) return save_object_to_path(existing_search_dict, search_history_path, isYML=True)
def read_program(status_path, traces_path, instrument_path): statuses = read_file(status_path).split('\n') traces = read_file(traces_path).split('\n') if len(statuses) == 0: print 'status length 0' if len(traces) == 0: print 'traces length 0' if len(statuses) != len(traces): print 'length of traces and status are different' testcases = list([]) for i in xrange(0, len(statuses)): status = True if 0 == statuses[i].split(':')[1] else False trace = traces[i].split(':')[1] testcase = TestCase(trace, status) testcases.append(testcase) instrument = read_file(instrument_path).split('\n') if len(instrument) < 2: print 'can not read instrument info' fault_line = instrument[0].split(':')[1].split(',') fault = [int(e) for e in fault_line] total = int(instrument[1].split(':')[1]) return Program(testcases, fault, total)
def excuse_cmd(server, startIndex = None, subjectIndex = None, problemIndex = None): fileStart = utility.getFile(server, config.ExcuseFiles[0]) fileSubject = utility.getFile(server, config.ExcuseFiles[1]) fileProblem = utility.getFile(server, config.ExcuseFiles[2]) if startIndex == "0": startIndex = None if subjectIndex == "0": subjectIndex = None if problemIndex == "0": problemIndex = None try: start, startIndex, startTotal = utility.read_file(fileStart, startIndex) subject, subjectIndex, subjectTotal = utility.read_file(fileSubject, subjectIndex) problem, problemIndex, problemTotal = utility.read_file(fileProblem, problemIndex) except ValueError: return "Not all files exist" except TypeError: return "Not all files exist" return "[%d/%d/%d] %s %s %s." %(startIndex, subjectIndex, problemIndex, start, subject, problem)
def selected_certain_part_from_landmark_file(self, select_item, find=True): f = open(self.output_path, 'w') data = utility.read_file(self.input_path) for index, line in enumerate(data): if find: if line.find(select_item) >= 0: f.write('{}\n'.format(line)) else: if line.find(select_item) < 0: f.write('{}\n'.format(line)) utility.show_process_percentage(index, len(data) - 1, 500)
def filter_search_history_expired(svc_S, search_history_path, day_offset): expired_S = set([]) existing_search_dict = read_file(search_history_path, isYML=True, isURL=False) current_date = get_current_datetime() for svctag, search_date in existing_search_dict.items(): pattern = compile_svc_pattern(svctag) for svc in svc_S: if pattern.match(svc) and diff_two_datetime( current_date, search_date, days=True).days < day_offset: svc_S.remove(svc) else: expired_S.add(svc) return expired_S
def select_face_recognition_result(self, possbility): dst_result_path = self.input_path.replace( '.txt', '_correct_possi{}_select.txt'.format(possbility)) f = open(dst_result_path, 'w') data = utility.read_file(self.input_path) for index, elem in enumerate(data): true_result = float(elem.split(' ')[2]) true_label = elem.split(' ')[1] prefict_label = elem.split(' ')[3] if true_label == prefict_label and true_result >= possbility: if not elem.endswith('\n'): elem += '\n' f.write(elem) utility.show_process_percentage(index, len(data) - 1, 1000)
def extract_dict(traces_path): traces = read_file(traces_path).split('\n') comb1 = set() comb2 = set() comb3 = set() for line in traces: if line is not '': all = line.split(":")[1].split(",") all = [int(e) for e in all if cast_to_int(e)] comb1 |= get_comb1(all) comb2 |= get_comb2(all) comb3 |= get_comb3(all) print "1", comb1 print "2", comb2 print "3", comb3 return comb1, comb2, comb3
def prepare_data(): corpus_languages = ['english', 'spanish', 'french', 'portuguese'] language = [] texts = [] for corpus_language in corpus_languages: text = read_file( 'identification_langue/corpus_entrainement/{}-training.txt'.format( corpus_language)) tokenizer = nltk.data.load( 'tokenizers/punkt/{}.pickle'.format(corpus_language)) sentences = tokenizer.tokenize(text.strip()) texts.extend(sentences) language.extend([corpus_language] * len(sentences)) return texts, language
def parse_dell_asset_file(dell_asset_path): lines = read_file(dell_asset_path, isYML=False, isURL=False, lines=True) if lines is not None and len(lines) > 1: da = DellAsset(dellasset_str=','.join(lines[1].split(',') [0:DellAsset.header_num])) warranty_L = [] for i in xrange(1, len(lines)): if lines[i] != "": warranty_L.append( Warranty(warranty_str=','.join(lines[i].split( ',')[DellAsset.header_num:]))) da.set_warranty_L(warranty_L) return da else: return None
def translate_dell_warranty(yml_url_path, dell_asset_L, logger=None): tran_dict = read_file(yml_url_path, isYML=True, isURL=True) tran_dict = filter_NA_translation(tran_dict) if logger is not None: logger.info("Read translation from " + yml_url_path) NA_dict = {} for dell_asset in dell_asset_L: for w in dell_asset.get_warranty(): if w is not None and w.service_en is not None: if w.service_ch == service_ch_placeholder: if w.service_en in tran_dict: w.set_service_ch(tran_dict[w.service_en]) dell_asset.is_translation_updated = True else: NA_dict[w.service_en] = dell_asset.svctag else: if logger is not None: logger.warn("Warranty service name not valid for %s and \n%s" % (dell_asset.svctag, w)) return dell_asset_L, NA_dict
def parse_dell_asset_multiple(dell_asset_multiple_path): # Parse multiple dell asset object in a single path da_L = [] lines = read_file(dell_asset_multiple_path, isYML=False, isURL=False, lines=True) if lines is not None: i = 0 while i < len(lines): while i < len(lines) and (lines[i] == "" or lines[i].find(DellAsset.header) == 0): i += 1 if i < len(lines): da = DellAsset(dellasset_str=','.join(lines[i].split(',')[0:DellAsset.header_num])) warranty_L = [] while i < len(lines) and lines[i] != "" and lines[i].find(DellAsset.header) < 0: new_w = Warranty(warranty_str=','.join(lines[i].split(',')[DellAsset.header_num:])) warranty_L.append(new_w) i += 1 da.set_warranty_L(warranty_L) da_L.append(da) return da_L
def create_patch_label_from_list(self, crop_list): data = utility.read_file(crop_list) dst_path = crop_list.replace('.txt', '_label.txt') f = open(dst_path, 'w') common_prefix = os.path.abspath(os.path.join(data[0], "..")) counter = 0 for index, elem in enumerate(data): elem_prefix = os.path.abspath(os.path.join(elem, "..")) if elem_prefix != common_prefix: common_prefix = elem_prefix counter += 1 f.write('{} {}\n'.format(elem, counter)) sys.stdout.write('{}/{}\r'.format(index, len(data) - 1)) sys.stdout.flush() f.close()
def word2vec(filepath, query): global model modelfile = filepath + '.model' if not os.path.exists(modelfile): sentences = [] for transactions in utility.read_file(filepath, '\t'): sentences.append(transactions) model = gensim.models.Word2Vec(sentences, min_count = 5) model.save(modelfile) else: if model is None: model = gensim.models.Word2Vec.load(modelfile) print '-------------------------' print 'raw word: ' + query for word, sim in model.most_similar(positive=[query]): print word, sim
def readData(self): # Chemins des fichiers # Les noms sont choisis de façon standard, on adapte le dossier self.adj_name = Generateur.dossier + "/adjectif.txt" self.article_name = Generateur.dossier + "/article.txt" self.verbe_name = Generateur.dossier + "/verbe.txt" self.nom_name = Generateur.dossier + "/nom.txt" self.adv_name = Generateur.dossier + "/adverbe.txt" self.prep_name = Generateur.dossier + "/preposition.txt" # Chargement des listes des mots à partir des fichiers self.preps = utility.read_file(self.prep_name) self.advs = utility.read_file(self.adv_name) self.adjs = utility.read_file(self.adj_name) self.articles = utility.read_file(self.article_name) self.noms = utility.read_file(self.nom_name) self.verbes = utility.read_file(self.verbe_name)
def clean_unregular_landmark_items(self, landmark_path, rest=False): if not rest: clean_path = landmark_path.replace('.txt', '_clean.txt') else: clean_path = landmark_path.replace('.txt', '_unregular.txt') f = open(clean_path, 'w') data = utility.read_file(landmark_path) for index, elem in enumerate(data): elem_num = len(elem.split(' ')) if elem.find('\n') < 0: elem += '\n' if not rest: #landmark elem should be 11 if elem_num == 12: f.write(elem) else: if elem_num != 12: f.write(elem) utility.show_process_percentage(index, len(data) - 1, 500) f.close()
def search_existing_dell_asset(svctags, update_translation=True): result = [] possible_file_count = 0 for s in svctags: if s == svc_placeholder: possible_file_count += 1 possible_file_count = 36 ** possible_file_count pattern = compile_svc_pattern(svctags) if pattern is not None: existing_dell_asset_svctags = list_file_name_in_dir(existing_dell_asset_dir) target_dell_asset_S = set([]) target_count = 0 for svc in existing_dell_asset_svctags: if pattern.match(svc): target_dell_asset_S.add(svc) target_count += 1 if target_count == possible_file_count: break result = DellAsset.parse_dell_asset_file_batch(existing_dell_asset_dir, target_dell_asset_S, logger=None) if update_translation: config = read_file(parent_path + file_config_name, isYML=True, isURL=False) result = update_dell_warranty_translation(config[config_translation_url] , result, existing_dell_asset_dir)[0] return result
def generate(traces_path, comb1_path, comb2_path, comb3_path): comb1, comb2, comb3 = extract_dict(traces_path) traces = read_file(traces_path).split('\n') ret1 = [] ret2 = [] ret3 = [] ret1.append("combination " + " ".join(comb1)) ret2.append("combination " + " ".join(comb2)) ret3.append("combination " + " ".join(comb3)) for line in traces: if line is not '': dict1, dict2, dict3 = extract_feature(comb1, comb2, comb3, line) line1 = line.split(":")[0] + " " + convert_to_line(comb1, dict1) line2 = line.split(":")[0] + " " + convert_to_line(comb2, dict2) line3 = line.split(":")[0] + " " + convert_to_line(comb3, dict3) ret1.append(line1) ret2.append(line2) ret3.append(line3) text1 = "\n".join(ret1) text2 = "\n".join(ret2) text3 = "\n".join(ret3) write_file(text1, comb1_path) write_file(text2, comb2_path) write_file(text3, comb3_path)
aggregated_indexes = [] for i, chunk in enumerate(chunks): ret_indexes = non_dominated_sort(chunk) for ret_index in ret_indexes: aggregated_indexes.append( int(len(dependents) / size) * i + ret_index) aggregated_pfs = [dependents[i] for i in aggregated_indexes] aggregated_indexes_2 = non_dominated_sort(aggregated_pfs) ret_indexes = [aggregated_indexes[i] for i in aggregated_indexes_2] return ret_indexes if __name__ == "__main__": data = read_file("./Data/Sac1_2.csv") dependents = [d.objectives for d in data] import time for size in xrange(1, 20): time_holder = [] for _ in xrange(10): print ". ", sys.stdout.flush() star = time.time() pf_indexes = non_dominated_sort_fast(dependents, [False, True], size) pf = [dependents[i] for i in pf_indexes] pf = sorted(pf, key=lambda x: x[0]) time_holder.append(time.time() - star) print size, sum(time_holder) / len(time_holder)
def run_main(files, repeat_no, stop, start_size): initial_time = time.time() all_data = {} initial_sample_size = start_size for file in files: all_data[file] = {} all_data[file]['evals'] = [] all_data[file]['gen_dist'] = [] all_data[file]['igd'] = [] print file data = read_file('../Data/' + file + '.csv') # Creating Objective Dict objectives_dict = {} for d in data: key = ",".join(map(str, d.decisions)) objectives_dict[key] = d.objectives number_of_objectives = len(data[0].objectives) number_of_directions = 10 directions = [get_random_numbers(number_of_objectives) for _ in xrange(number_of_directions)] shuffle(data) training_indep = [d.decisions for d in data[:initial_sample_size]] testing_indep = [d.decisions for d in data[initial_sample_size:]] while True: print ". ", sys.stdout.flush() def get_objective_score(independent): key = ",".join(map(str, independent)) return objectives_dict[key] training_dep = [get_objective_score(r) for r in training_indep] next_point_indexes = get_next_points(file, training_indep, training_dep, testing_indep, directions) # print "Points Sampled: ", next_point_indexes next_point_indexes = sorted(next_point_indexes, reverse=True) for next_point_index in next_point_indexes: temp = testing_indep[next_point_index] del testing_indep[next_point_index] training_indep.append(temp) # print len(training_indep), len(testing_indep), len(data) assert(len(training_indep) + len(testing_indep) == len(data)), "Something is wrong" if len(training_indep) > stop: break print print "Size of the frontier = ", len(training_indep), " Evals: ", len(training_indep), # Calculate the True ND training_dependent = [get_objective_score(r) for r in training_indep] approx_dependent_index = non_dominated_sort(training_dependent, lessismore[file], [r[0] for r in ranges[file]], [r[1] for r in ranges[file]]) approx_dependent = sorted([training_dependent[i] for i in approx_dependent_index], key=lambda x: x[0]) all_data[file]['evals'].append(len(training_indep)) actual_dependent = [d.objectives for d in data] true_pf_indexes = non_dominated_sort(actual_dependent, lessismore[file], [r[0] for r in ranges[file]], [r[1] for r in ranges[file]]) true_pf = sorted([actual_dependent[i] for i in true_pf_indexes], key=lambda x: x[0]) print "Length of True PF: " , len(true_pf), print "Length of the Actual PF: ", len(training_dependent), all_data[file]['gen_dist'].append(generational_distance(true_pf, approx_dependent, ranges[file])) all_data[file]['igd'].append(inverted_generational_distance(true_pf, approx_dependent, ranges[file])) print " GD: ", all_data[file]['gen_dist'][-1], print " IGD: ", all_data[file]['igd'][-1] all_data[file]['time'] = time.time() - initial_time import pickle pickle.dump(all_data, open('PickleLocker_FlashB_'+str(start_size)+'_'+str(stop)+'/' + file + '_' + str(repeat_no) + '.p', 'w'))
import sys, traceback, socket required_arg_list = ['--parent_path=', '--svctag=', '--v='] subject_temp = "%s 时间%s 标签%s" if __name__ == "__main__": arguments = parse_cmd_args(sys.argv, required_arg_list) parent_path = arguments['parent_path'] svctag = arguments['svctag'] verbose = True if 'v' in arguments else False logger = Logger(verbose) start_time = get_current_datetime() logger.info("Prepare arguments for a job on %s in machine: %s " % (start_time, socket.gethostname())) log_output_path = "%slog/dellasset_%s.txt" % (parent_path, svctag) config = read_file(parent_path + file_config_name, isYML=True, isURL=False) if not config: logger.error("Config %s parsed as None; job quits" % (parent_path + file_config_name)) sys.exit(-1) svc_L = svctag.split(svc_delimitor) history_valid_svctag_path = parent_path + "valid_svctags.txt" dell_asset_path = existing_dell_asset_dir search_history_path = parent_path + "search_history.yml" dell_asset_output_path = parent_path + "output_%s.xlsx" % svctag api_url = config['dell_api_url'] api_key_L = config["dell_api_key"].values() transl_url = config[config_translation_url] dell_support_url = config['dell_support_url'] output_dell_asset_L = [] api_dell_asset_L = [] NA_dict = {}
lessismore['./Data/wc-6d-c1.csv'] = [False, True] lessismore['./Data/wc-c1-3d-c1.csv'] = [False, True] lessismore['./Data/wc-c3-3d-c1.csv'] = [False, True] all_data = {} for file in files: all_data[file] = {} all_data[file]['evals'] = [] all_data[file]['gen_dist'] = [] all_data[file]['igd'] = [] print file for _ in xrange(40): print ". ", sys.stdout.flush() data = read_file(file) splits = split_data(data, 40, 2, 58) temp = mmre_based_approach(splits[0], splits[1]) predicted_dependent = build_model(temp, splits[2]) actual_dependent = [d.objectives for d in splits[2]] true_pf_indexes = non_dominated_sort(actual_dependent, lessismore[file]) predicted_pf_indexes = non_dominated_sort(predicted_dependent, lessismore[file]) # Actual Dependent values of the predicted_pf predicted_actual = [ actual_dependent[i] for i in predicted_pf_indexes ]
def __init__(self, path, outputPath): self.outputPath = outputPath self.texte = utility.read_file(path) self.constructionDic()