if so, how does it work? I tried to find information on z3 about differential equations but I didn't find anything.
I think dReal (http://dreal.github.io/) is the only solver that provides support for ODEs, though I’m not an expert on this.
Also, see this paper for further details: https://arxiv.org/pdf/1310.8278.pdf
Related
dear experts of GEKKO,
Since the problem I'm going to solve has no closed math form and the solution falls in discrete integer space like, the gradient-free method should work. Thus, as far as you know, do you know if GEKKO support any gradient-free method with the related example for now?
Thank you
Gekko itself could support any solution method but there is currently no linked solver that takes that solution approach. Currently all are Nonlinear Programming (NLP) or Mixed Integer Nonlinear Programming (MINLP) solvers that use derivatives from Gekko automatic differentiation.
There is a list of derivative-free optimizers. Perhaps there is another Python package that could better handle your problem. There is also additional information in the Design Optimization Course and the online Design Optimization Book (Chap 5 and 6) on gradient-free methods such as Simulated Annealing and Genetic Algorithms.
I want to solve this system in mathematica and i have applied various functions such as Solve, NSolve, etc. but none of them worked. could you help me how could i find my answer?
I understand that doing minimization in integer programming is a very complex problem. But what makes this problem so difficult?
If I were to (attempt) to write an algorithm to solve it, what would I need to take into account? I'm only familiar with the branch-and-bound technique for solving it and I'm wondering what sort of roadblocks I will face when attempting to apply this technique programatically.
I'm wondering what sort of roadblocks I will face when attempting to apply this technique programatically.
None in particular (assuming a fairly straightforward implementation without a lot of tricks). The algorithms aren’t complicated – they are complex, that’s a fundamental difference.
Techniques such as branch and bound or branch and cut try to prune the search tree and thus speed up the running time. But the whole problem tree is nevertheless exponentially large, hence the problem.
Like the other said, those problem are very hard and there are no simple solution nor simple algorithm that apply to all classes of problems.
The "classic" way of solving those problem is to do a branch-and-bound and apply the simplex algorithm at each node, as you say in your question. However, I would not recommand implementing this yourself if you are not an expert.
As for a lot of numerical methods, it is very hard to get it right (good parameter values, good optimisations), and a lot have been done (see CPLEX, COIN_OR, etc).
It's not that you can't do it: the branch-and-bound part is pretty straigtforward, but without all the tricks your program will be really slow.
Also, you will need a simplex implementation and this is not something you want to do yourself: you will have to use a third-part lib anyway.
Most likely, wether
if your data set is not that big (try it !), and you are not interested in solving it really fast: use something like COIN-OR or lp_solve with the default method, it will work;
if your data set is really big (and/or you need to find a solution quickly each time), you need to work with an expert in this field.
My main point is that only experienced people will know which algorithm will perform better on your problem, wich form of the model will be the easiest to solve, which method to apply and what kind of optimisations you can try.
If you are interested in those problems, I would recommend this book for an introduction to the math behind all this (with a lot of examples). It is incredibly expansive, so you may want to go to a library instead of buying it: Nemhauser and Wolsey.
Integer programming is NP-hard. That's why it is so difficult.
There is a tutorial that you might be interested.
The first thing you do before you solve any mathematical optimization problem is you categorize it. Except special cases, most of the time, integer programming problems will be np-hard. So instead of using an "algorithm", you will use a "heuristic". The final solution you will find will not be a guaranteed optimum, but it will be a pretty good solution for real life problems.
Your main roadblock will your programming skills. Heuristic programming requires a good level of programming understanding. So instead of programming your own heuristic you are better of using well known package (eg, COIN-OR, free). This way you can focus on your problem instead of the heuristic.
I am trying to get a grasp on the efficiency of neural networks over other artificial intelligence algorithms for use in intrusion detection systems. Most of the literature I’m reading isn’t giving a good comparison of neural networks compared to other IDS's.
Do they work better (detect more true attacks and less false positives)? Are they more or less efficient?
Another question is how new is NN in IDS environments? Are they used widely, is it old news?
It seems like you're asking the problem:
Will this algorithm help me, reliably, detect when an "intrusion" has happened.
Looking at some of the criticism of Neural Networks, it seems that NNs could be over-trained (which is possible for any AI algorithm); this could be overcome by using k-fold cross validation. NNs are also difficult because it is difficult to explain why the NN gave the result that it did.
Is this a research problem that you are working on?
Initially, I'd look at Naive Bayes to solve this problem because 1) it is easy to implement and 2) serves as a good base-line. Also, look at Decision Trees as a solution to your problem.
After implementing NB and DT, implement the NN and see if NN does better.
You could also try an ensemble technique and see if that gives you better results.
There is a Java-based package called Weka which implements many of the algorithms I've discussed and could be valuable to you.
I am also new in NN. I think you can use Encog Neural Network Library to implement NN Algorithms. It is available in both Java and C#.
What are the fast solvers for FEM equations? I would prefer open source implementation, but if there is a commercial implementation, then I won't mind paying for it.
Code Aster is an open source FE code. code aster
The pre- and post-processing is usually done with Salome - both originate from EDF.
How about FEAP. It has full source code available when you purchase it. It is pretty big project, maybe its too much for your needs, but check it out.
FEAP is a general purpose finite
element analysis program which is
designed for research and educational
use. Source code of the full program
is available for compilation using
Windows (Compaq or Intel compiler),
LINUX or UNIX operating systems, and
Mac OS X based Apple systems.
It has also a Personal Edition called FEAPpv available for free, including source code. Differences between those versions are listed in this pdf.
"brad"? do you mean "broad"?
you don't say if your problem is linear or non-linear. that'll make a very big difference.
the solver depends on the type of equation and the size of your problem. for elliptical pdes you can choose standard linear algebra techniques like lu decomposition, iterative methods like successive over relaxation, or wavefront solvers that minimize memory consumption.
some people like solving non-linear steady-state problems as if they were dynamics problems. the idea is to create "fake" mass and damping matricies and use explicit time integration to converge to steady state.
lots of choices. standard linear algebra is a good starting point.
language? java?
Oops, that's kind of a brad question.
Solving differential equations usually starts with analyzing equation itself. Some equations are notoriously difficult to solve efficiently, e.g. indifinite boundary problems.
So if you have something else than an elliptic problem, you'll might better prepare for hard times ahead.
Next important and crutial part is transfering the contiouus problem into a discrete mesh. Typically the accuracy of your results will vary with different ways to generate this mesh. You'll need some sound experience here.
So I'd say there is nothing like the fast slover for FEM equations. Anyway, while Wikipedia gives a short overview of the topic, you might perhaps also have a look a the german Wikipedia page. It lists well-known FEM implementations.
OpenFoam and Elmer are two open source solvers. Not sure about Elmer, but I think OpenFoam might uses the control volume approach.
I used OpenFOAM for fluid dynamics research. You can do parallel processing with it with MPI. And if you have a Cray T3E it will be fast!
It's open source :D
http://www.opencfd.co.uk/openfoam/features.html#features
Please have look for Deal.II open source library:
http://www.dealii.org/
They provide also VirtualBox image which comes pre-installed libs.