This may be more appropriate for math overflow, but nevertheless:
Given a 3D structure (for example, a molecule), what is a good approach/algorithm to find symmetry (rotational/reflection/inversion/etc.)?
I came up with brute force naïve algorithm, but it seems there should be better approach.
I am not so much interested in genetic algorithms as I would like best symmetry rather then almost the best symmetry
there is this here: http://pubs.acs.org/doi/abs/10.1021/ci990322q from my field. would be good to know what mathematicians/computer science people came up with as well.
A link to website/paper would be great. Thanks
This paper should get you started:
http://graphics.stanford.edu/~niloy/research/approx_symmetry/paper_docs/approx_symmetry_sig_06.pdf
See this website for Symmetry Detection and Structure Discovery research. The papers at the bottom include the one that #Xavier Ho mentions.
Related
I'm learning to find a way to search similar images recently.
There is some popular algorithms in features matching area.For example, Perceptual Hash Algorithm, SIFI and SURF in openCV. I'm wondering that which one is the most accurate.Or is using multiple algorithms a good idea?
Or is there some nice conclusions about the popular algorithms.
Thanks in advance.
There are a lot of algorithms for check similarities, actually matching features.
I searched some algorithms to find the features which are SURF, SIFT, BRISK, LBP, Harris MSER, A-KAZE, FAST and so on.
In many applications, the SIFT is selected to check feature matching. However, I think that you should evaluate the performances algorithm. To find right algorithm for your application.
If you can't evluate the algorithms, I think that using multiple algorithms is better to you.
If you want to check the features, I recommend this link to understand feature extractors, descriptors, matching.
https://kr.mathworks.com/help/vision/local-feature-extraction.html
Thank you.
I'm searching for relative (after 2000) new papers about TSP.
All the papers I have found were quite hard and needed high level
mathematical skills. I'm looking for papers that are simple to read
for someone who has simple college mathematic knowledge and good
programming knowledge in Java and C (I didn't find any current paper
implementing TSP with these languages).
Any hints will be highly appreciated.
(edit)
What Im trying to say is that im searching for papers that dont need to understand
difficult formulas. For instance some papers describe algorithms, or the philosophy
of solution. It isnt necessary to implement that algorithm, just describe the techniques.
Maybe using some simple geometry ...
I found some papers based on Lin-Kernighan methods, which seemed ok ...
I'm somewhat familiar with the TSP literature, and I doubt there's anything matching your criteria; the simpler, less mathematical algorithms were pioneered long before your cutoff.
David S. Johnson and coauthors have some articles that I like: http://www2.research.att.com/~dsj/papers.html , in particular #1 and #3 under Traveling Salesman Problem.
If you want simple, here is one page that describes using space filling curves to find a good solution (not optimal obviously). Of course, a webpage is not a paper. Nor do I know if the ideas presented there were created after 2000. If this is more of what you are looking for, perhaps you should edit your question, or provide an example.
http://www2.isye.gatech.edu/~jjb/mow/mow.html
Here's what you can do:
1) Study chapter 11-Guided Local Search and Chapter 12- Iterated Local Search from Handbook of Metaheuristics(2010), each of these has a section describing how GLS and ILS are designed for TSP. Both ILS and GLS are interesting and quite easy to implement.
2) Check this paper: "Guided local search and its application to the traveling salesman problem"
3) Find the Ruby code for these algorithms here , and rewrite it in Java
Me and some of my friends at college were assigned a practical task of developing a net application for optimization of cutting rectangular parts from some kind of material. Something like apps in this list, but more simplistic. Basically, I'm interested if there is any source code for this kind of optimization algorithms available on the internet. I'm planning to develop the app using Adobe Flex framework. The programming part will be done in Actionscript 3, ofc. However, I doubt that there are any optimization samples for this language. There may be some for Java, C++, C#, Ruby or Python and other more popular languages, though(then I'd just have to rewrite it in AS). So, if anyone knows any free libs or algorithm code samples that would suit me, I'd like to hear your suggestions. :)
This sounds just like the stock cutting problem which is extermely hard! The best solutions use linear programming (typically based on the simplex method) with column generation (which, even after years on a constraint solving research project I feel unequipped to give a half decent explanation). In short, you won't want to try this approach in Actionscript; consequently, with whatever you do implement, you shouldn't expect great results on anything other than small problems.
The best advice I can offer, then, is to see if you can cut the source rectangle into strips (each of the width of the largest rectangles you need), then subdivide the remainder of each strip after the "head" rectangle has been removed.
I'd recommend using branch-and-bound as your optimisation strategy. BnB works by doing an exhaustive tree search that keeps track of the best solution seen so far. When you find a solution, update the bound, and backtrack looking for the next solution. Whenever you know your search takes you to a branch that you know cannot lead to a better solution than the best you have found, you can backtrack early at that point.
Since these search trees will be very large, you will probably want to place a time limit on the search and just return your best effort.
Hope this helps.
I had trouble finding examples when I wanted to do the same for the woodwoorking company I work for. The problem itself is NP-hard so you need to use an approximation algorithm like a first fit or best fit algorithm.
Do a search for 2d bin-packing algorithms. The one I found, you sort the panels biggest to smallest, then add the to the sheets in in order, putting in the first bin it will fit. Sorry don't have the code with with me and its in vb.net anyway.
In industry, there is often a problem where you need to calculate the most efficient use of material, be it fabric, wood, metal etc. So the starting point is X amount of shapes of given dimensions, made out of polygons and/or curved lines, and target is another polygon of given dimensions.
I assume many of the current CAM suites implement this, but having no experience using them or of their internals, what kind of computational algorithm is used to find the most efficient use of space? Can someone point me to a book or other reference that discusses this topic?
After Andrew in his answer pointed me to the right direction and named the problem for me, I decided to dump my research results here in a separate answer.
This is indeed a packing problem, and to be more precise, it is a nesting problem. The problem is mathematically NP-hard, and thus the algorithms currently in use are heuristic approaches. There does not seem to be any solutions that would solve the problem in linear time, except for trivial problem sets. Solving complex problems takes from minutes to hours with current hardware, if you want to achieve a solution with good material utilization. There are tens of commercial software solutions that offer nesting of shapes, but I was not able to locate any open source solutions, so there are no real examples where one could see the algorithms actually implemented.
Excellent description of the nesting and strip nesting problem with historical solutions can be found in a paper written by Benny Kjær Nielsen of University of Copenhagen (Nielsen).
General approach seems to be to mix and use multiple known algorithms in order to find the best nesting solution. These algorithms include (Guided / Iterated) Local Search, Fast Neighborhood Search that is based on No-Fit Polygon, and Jostling Heuristics. I found a great paper on this subject with pictures of how the algorithms work. It also had benchmarks of the different software implementations so far. This paper was presented at the International Symposium on Scheduling 2006 by S. Umetani et al (Umetani).
A relatively new and possibly the best approach to date is based on Hybrid Genetic Algorithm (HGA), a hybrid consisting of simulated annealing and genetic algorithm that has been described by Wu Qingming et al of Wuhan University (Quanming). They have implemented this by using Visual Studio, SQL database and genetic algorithm optimization toolbox (GAOT) in MatLab.
You are referring to a well known computer science domain of packing, for which there are a variety of problems defined and research done, for both 2-dimnensional space as well as 3-dimensional space.
There is considerable material on the net available for the defined problems, but to find it you knid of have to know the name of the problem to search for.
Some packages might well adopt a heuristic appraoch (which I suspect they will) and some might go to the lengths of calculating all the possibilities to get the absolute right answer.
http://en.wikipedia.org/wiki/Packing_problem
I just read about the breadth-first search algorithm in the Introduction to Algorithms book and I hand simulated the algorithm on paper. What I would like to do now is to implement it in code for extra practice.
I was thinking about implementing all the data structures from scratch (the adjacency list, the "color", "distance", and "parent" arrays) but then I remembered that there are currently graph libraries out there like the Boost graph library and some other graph APIs in Python.
I also tried looking for some BFS-related problems on UVA and Sphere Judge Online but I can't tell which problems would require a BFS solution.
My question is what would be the most painless way to practice these graph algorithms (not just limited to BFS, but will also come in useful when I want to implement DFS, Dijkstra, Floyd-Warshall, etc). Sites with practice problems are welcomed.
I personally think that the best way to understand those would be implementing the graph representation yourself from scratch.
On the one hand, that would show you actual implementation caveats from which you learn why or why not a particular algorithm might be interesting / good / efficient / whatever. On the other hand, I think that understanding graphs and their real life use, including its implications (recursion, performance/scalability, applications, alternatives, ...), is made easier through the bottom-up approach.
But maybe that's just me. The above is very personal taste.
I found your question interesting, I googled a bit and I found JGraphEd.
It does not cover all graph algorithms but it looks like a good tool for experimentation.
I agree with balpha. The best way to really learn and understand algorithms is to do the implementation. Just pick an algorithm and implement it. When you reach a point where you get stuck or are unsure, look at a number of existing examples. You will then be able to compare your own thinking with that of others from a position of understanding instead of simply accepting what is offered.
Once you have learned what you want to, the best way to solidify your understanding is to try teach it to or describe it to somebody else. You might have some people willing to listen to you, or at the very least you could write a blog entry for people new to the algorithm you have just studied.
But if you are looking for "painless", then maybe you should stay clear of algorithms altogether ;-)
This site could help you
Here you have description of every problem on acm problemset. You can see category of each problem, and hint to solve it. Just browse for graph related problems. Good advice is to use those hints only if you tried to solve problem yourself and failed.
Visualization of some shortest path algorithms on real data, where the explored area is displayed in yellow:
(bidirectional) Dijkstra
A*