Examples of Analysis of Branch and Bound Method

I am solving a graph problem, which can be formulated as an integer programme. Based on computer experiments, it seems that the branch and bound method works well. I would like to analyse the running time, and wonder whether there have been other problems where branch and bound method was used and the theoretical bounds on the running time has been established?

On another note, if anyone knows any examples of problems where the range of possible values that a variable in a linear programme can take, I’d also be interested in.

Python vs Java for Neural Network

I’m trying to work on a side project for fun and although my primary field of expertise is finance and econ, I have some background in python and java. I wanted to create a simple neural network program that predicts the future value of stocks based on several variables (historical data, breaking news, etc) and I was wondering if my time is better spent honing my skills in Java or Python for the above program.

Thanks in advance!

Does the callback concept of programming has any basis in computer science?

Although I seriously code with computer languages in general since 2010 and as an amateur programmer with programming languages in particular since 2015 (primarily Bash and JavaScript imperative scripts) and codes I wrote are scattered through my Stack Exchange accounts, as in my Code Review SE account,
I think I still misunderstand what a Callback is;
I feel that the term itself might be misleading, as I understand that callback functions doesn’t “call back” anything, but rather “called back” as a reaction to a condition (event).
I understand the alternative term Callafter as significantly controversial between programmers, so I stay with “Callback” or its semantic siblings;
Any Stack Exchange session I read about “Callback” contained answers that I either recognized as contradicting or controversial by other programmers commenting in comments.

My question

Because the particular examples I read of this concept in Bash and JavaScript are not remembered to me as clear, I ask:

Does the callback concept of programming has any basis in computer science?

That is to ask; is there, as part of a computer science theory, some logical forumla that can simulate all possible “callback functions” (similarly to as a Turing machine can simulate all possible functions of a computer) that might help understanding the purpose of this concept?

Pseudocode for sum, product and difference given implicit functions A and B

I have no idea how to do this. All I know is that I have two implicit functions, and I need to write the sum, product and difference of them in pseudocode. I tried to write it for sum and difference but I don’t really know what I’m doing. Any help is appreciated.

click here for functions


How does a TLB lookup compare all keys simultaneously?

I am reading OS Concepts dinosaur book which says, “Each entry in the TLB consists of two parts: a key (or tag) and a value. When the associative memory is presented with an item, the item is compared with all keys simultaneously.”

I checked How does a TLB and data cache work? but it does not say anything about the implementation that allows this parallel checking of the keys.

I read something about a parallel hash table here: http://www.cs.cmu.edu/afs/cs/academic/class/15210-s12/www/lectures/lecture27.pdf

Is this the basic idea? The insertion of a key outputs a frame number and this could either be a hit or miss?

Is it possible to setup email servers to encrypt communication in transit?

I understand that generally email communication is insecure by default and would like to know if its possible to setup email servers so that the emails get encrypted when sent between hosts.

I want to know if there is actually a way to include personal information in emails and keep it secure in a Business to Business Scenario (B2B). This usually involves a scenario where and email is generally generated or typed that gives instructions on who to contact or follow up with. It is intended for a human to read and not intended to be processed by a machine

I’d also appreciate any relevant explanation particularly details of commonly known approaches so that i can investigate further. Even if its at the level of a pattern and common strengths and weaknesses.

AlienVault Alert – What is this event saying?

Title: ALA4747 - AV Policy violation, Tor anonymity network usage on ( -> Extra info:  Source IPs:  Source Ports: 64689  Dest. IPs:  Dest. Ports: 53  Ticket details  Description:  Event Type: AlienVault NIDS    Event Description: AlienVault NIDS: "ET POLICY DNS Query for TOR Hidden Domain .onion Accessible Via TOR"    Ocurrences: 2 First Ocurrence: 2019-12-17 17:56:50    Last Ocurrence: 2019-12-17 17:56:50 Number of different sources: 2 Number of different destinations: 2 Source: Dest:   Description:  Event Type: directive_alert Event Description: directive_event: AV Policy violation, Tor anonymity network usage on SRC_IP  Occurrences: 2  First Occurrence: 2019-12-17 17:58:45  Last Occurrence: 2019-12-17 17:58:45   Number of different sources: 2  Number of different destinations: 2   Source:   Dest:  

Why doesn’t Dijkstra’s use a shortest-path first search?

When using BFS search on an unweighted graph to find the single-source shortest paths, no relaxation step is required because a breadth-first search guarantees that when we first make it to a node, we have found the shortest path to it.

However, Dijkstra has no such guarantee, because the neighbours of each node are checked in no specific order. Therefore, we need a relaxation step to update the shortest path of each node if we later find a shorter path.

Instead of choosing a random neighbour, why not always follow the neighbour with the shortest path? I think that would guarantee we have always found the shortest path and no relaxation step is required. I implemented this in Python and it seems to work. Am I missing something?

from heapq import heappop, heappush  def shortest_path_lengths(graph, source):     dist = {}     q = [(0, source)]     while q:         cur_dist, v1 = heappop(q)         if v1 in dist:             continue         dist[v1] = cur_dist         for v2, v1_to_v2_dist in graph[v1].items():             if v2 not in dist:  # check it hasn't been visited already                 heappush(q, (cur_dist + v1_to_v2_dist, v2))     return dist   graph = {     'a': {'b': 3, 'c': 5},     'b': {'c': 1},     'c': {'d': 4},     'd': {}, } print(shortest_path_lengths(graph, 'a')) 

Decision tree: how to decide the next node?

data set

I have to decide for which value of “Klasse”

How do i do it?

I know that I have to decide on maximum information gain

So first off I’ve calculated the entropy of “Klasse”

That is E(Klasse)= -(3/11*log(3/11)+3/11*log(3/11)+5/11*log(5/11)) = 1.067

So how do I proceed from that?

I now need to find the first decision node, yes?

And how do I proceed if I’ve found a decision node ?