Quick Qu: Expand_nodes method
Hi all,
I'm trying to code for expand all and collapse all a tree on a dynpro. Collapsing is fine, but I'm getting a 'MESSAGE_TYPE_X' runtime error when I call the expand_nodes method.
I'm using button on a Gui status called 'EXPANDA', and incoporated the following code in the PAI.
WHEN 'EXPANDA'.
* Expand All Trees
CLEAR g_node_key_table.
LOOP AT it_node_table INTO wa_node_area.
APPEND wa_node_area-node_key TO g_node_key_table.
ENDLOOP.
CALL METHOD g_tree->expand_nodes
EXPORTING
node_key_table = g_node_key_table.
G_TREE has a type ref to CL_GUI_LIST_TREE.
In the past, this error message has meant that I don't have the table with the node list correct - and in this instance, a significant number of the nodes are flagged as hidden.
Therefore, my first question is - should the list of nodes being passed in be the complete node list (including hidden nodes), or only those nodes that are not hidden, as these will be the only ones that I want to expand.
Or am I missing something else?
Cheers,
Stephen
Resolved internally. The trick is to only pass through the parent nodes - the methods did not know how to deal with the children, as they were not expandable.
Similar Messages
-
Determining which method to call from an array of Objects
Hi All,
Lets suppose I have an interface, a string method name, and an array of Objects indicating the parameters which should be passed to the method.
What Im trying to work out is a way to quickly determine which method should be invoked.
I can see that Class has getDeclaredMethod(String, Class[]), but that wont help me as I dont know the formal class types (the method may take X, but I might get passed Y which extends X in the array of objects).
Does anyone know of a quick way I can determine this?
All I can think of at the moment is going thru each method of the class one by one, and seeing if the arg is assignable, then, after getting all my matched methods, determining if there are any more 'specific' matches.
Any ideas?
Much appreciated,
Daveyou might want to take a look at the dynamic proxy apiCheers for the suggestion, but Im actually already using the dynamic proxy API.
What I have is a MockObjectValidator which allows mock objects to be configuered with expected calls, exceptions to throw etc etc.
I thought developers on my project would get tired using an interface like this:
myValidator.setExpectedCall("someMethod", new Class[] { typeA, typeB }, new Object[] { valueA, valueB} );
I.e, I wanted to cut out having to pass the class array, so they could just use:
myValidator.setExpectedCall("someMethod", new Object[] { valueA, valueB} );
The problem there is that I then need to pick the best Method from the class given the object arguments.
When the mock object is in use, its no problem as the InvocationHandler interface provides the Method. The problem I have is selecting what method a user is talking about from an array of Objects.
Ive written a simple one now, it just does primitive type class -> wrapper substitution, and then finds ** A ** match. If there is more than one match (ie, all params are assignable to a class' method params), I dont let that method be used.
Shortly I'll update it to actually make the correct selection in those cases.
cheers
Dave -
Jdev CPU profiler doesn't show inherint method timing - Any way to get it
Hi,
CPU profiler both in HOTSPOT and Callstack doesn't give method's inherint timings . it only shows parent + descendant timing (inclusive timing) . This doesn't help me to quickly find which method inherintly is expensive (ie timing withouts its child included ) .Is there a way to get the timing of a method without including its child method timing ..
Regards,
IndraneelDepending on what version of JDeveloper 11 you are running, exclusive time in a method is called "CPU Exclusive" or "CPU Shallow" in the CPU profiler column headings. The column is there; there is data in the column for some methods (Click on the 'CPU Exclusive/Shallow' column to sort by those values). So it's hard to understand how the profiler does not report it.
Perhaps your issue is that the profiler doesn't report it accurately? -
How can we remove items from the VF04 list?
We have a long list of items in VF04 that, for various reasons (some process related, some due to errors), are not to be billed. We have looked at applying filters to the list but there is nothing really suitable to hide these individual documents e.g. we could filter out some dates where none of the items on that date are to be billed but other dates have a mix of items we want to bill and others we don't.
I have done a search of this forum but didn't find a previous topic with a quick and simple method to remove items from the list .
Is there a method, other than billing them or sorting each issue individually, to permanently remove individual documents from the VF04 list?
Thanks in advance for any help.
DavidHi,
David,
Download a list of Pending delivers doc form VF04.
Paste the list in T.Code : VL09 (Delivery reversal) and reverse the delivery.
Then go to T.Code: VL06G Select the list of deliveries that has been reversed, select/delete all un- wanted deliveries.
This way you can remove all unwanted pending deliveries forn Billing due list (VF04).
Thanks & Regards,
R.Janakiraman -
Overclocking the i7, a beginners guide
To give credit where credit is due: This was not written by myself. I have only edited parts of it.
I found this on the internet, but it was such a great article, that I wanted to draw your attention to it. Credits go to Chad. Thanks for all the effort you put into this.
What is overclocking?
Overclocking is a process of making various components in a computer to go faster than their stock speeds. So if you buy a processor (lets say an i7-920 2.66 GHz) and make it go faster (lets say 3.6 GHz), that can be deemed as overclocking.
HALT! Do not proceed any further until you have read this:
Dell, Gateway, eMachine, etc... do not overclock very well, so proceed at your own risk. You break it, it is your fault.
A little bit more of some explanation:
This guide is intended to explain how to overclock and its uses. It was made for those who have computers (moreover, motherboards and other components) that support overclocking. If you bought a brand of computer like Dell, Sony, Gateway, HP, eMachine, or any other crappy PC (not saying all of them are) that comes for a store like Walmart, Best Buy, or Circuit City, then this guide does not pertain to you. Even though it is possible to overclock these systems with software, it is not recommended nor advised. This guide is meant for anyone who has a motherboard made by ASUS, GIGABYTE, Abit, DFI, (sometimes Intel), or any other well known brand known for their boards and overclocking abilities. But be forewarned, not all boards made by these companies are made to overclock. Check and see if yours does before going any farther than this final line.
Note: There are ways to bypass hardware overclocking via software, but it is not recommended and can make your PC unstable, even rendering it unable to stay stable till the system is returned to normal. Overclocking software is made for boards that supports overclocking so that changes can be made without having to restart.
Further notes:
-Motherboards not designed for overclocking will not go as far in overclocking, become unstable sooner, and heat far quicker.
-Computers with boards that do not support overclocking do not have adequate cooling.
Why would you want to overclock if it could be damaging?
Simple, to get more out of what you payed for. Overclocking is similar to going and upgrade a car's engine by boring out its piston chambers and adding better fuel injection, air intake, transmission, etc..., but there is always a risk in doing so. But it all boils down to one thing: performance. It is hard to fry your system if you are careful and know what you are getting yourself into. If you are careful about what you do, then it is rather hard to do any kind of permanent damage to your system by pushing it to its sheer limits.
As with any kind of performance enhancement, there is a level of risk involved. The first and foremost danger is heat. Heat will degrade and damage your components beyond repair if left unchecked and will most definitely lower your system's life span. When you overclock, you are making your computer do more work than it is used to, thus it is going to generate more heat, so having a good cooling system is essential. If you do not have sufficient cooling, then your system could and will overheat. Overheat by itself cannot kill your computer though, the only way for that to happen is to repeatedly overheat it time and time again past the recommended temperatures. YOU SHOULD ALWAYS TRY TO STAY AT OR BELOW YOUR CPU's MAX RATED TEMPERATURE! If you go above this, you can risk harming your CPU. Do so at your own risk. Run your CPU at 5-10C above its max temp for short periods only and ONLY for benchmarking purposes only. DO NOT DO IT FOR LONG TERM!
And as luck would have it, you do not have to be overly worried about your system overheat as there will be signs before you system becomes a fried potato. Random crashes are probably the most common sign. Overheat is easily prevented by the use of thermal sensors which can tell you how hot your system is getting. If you see temperatures that you think is too high, then either run at a lower speed, or get better cooling, which I will cover later on.
The other danger of overclocking is voltage. Too much, and you can significantly shorten your components' lifespan. A small boost will not do much, but if you plan on a rather hefty overclock, you may want to be aware that it will decrease the lifespan of your computer's components. But this is usually not an issue since most people who will overclock do not use their components for more than 4-5 years and there is a good chance your components will not fail before 4-5 years regardless of the voltages running through it. Most processors are designed to last in upwards of ten years. So most of the time, loosing a few of those years is worth the performance gained for overclocking.
Disclaimer for my own protection:
WARNING!!! READ THIS DAMN WARNING!!! I DO NOT WANT TO HEAR YOU WHINE YOU BROKE YOUR COMPUTER SO READ THIS WARNING!!!!!!
Overclocking can really mess things up, and it wares down your hardware and its life-expectancy. In other words, the more you overclock, the shorter your computer will live (like how an F1 car's engine must be replaced after every other race). If you attempt to overclock, then I am not responsible for any damage or destroyed hardware when using this guide. Follow at your own risk.
Overclocking
This guide is meant for beginners and not for people looking to squeeze out every last bit from their processor. That’s when things become extremely motherboard specific. The goal of this guide is to try to make overclocking the core i7 an easy and enjoyable experience. Overclocking your core i7 is a must; if you don’t you’re a chump. This guide will focus more on core i7 920s, but ideas will probably carry over into EE and higher end chips with locked multipliers.
Recommended hardware:
1. A good cooler (Do not use stock if you plan to go past around 3.5. You will run your processor way too hot) (Noctua, ThermalRight Ultra Extreme or Megahalem are my preferred ones but read around.
2. DDR3 1600+ - You can get away with 1333 but with ram being as cheap as it is, why not.
3. Pretty much any x58 board (although some are better than others, read some reviews).
4. A good PSU with an EPS(8 pin) plug.
5. Paper, Pencil, and Patience – Write things down so you can remember your successes and failures. There is not much to play with in terms of the i7, but keeping track of what you tried can eliminate any frustrating experiences and also allow you to go back to a known stable settings.
Recommended software for stability testing:
1. Prime95.
http://www.mersenne.org/freesoft/
2. Memtest86+ http://www.memtest.org/
3. Realtemp http://www.techpowerup.com/realtemp/
4. CPUZ - http://www.cpuid.com
Many people have personal favorites but the above are what I use.
Not all I7s are created equal:
1. So you read on a thread that someone hit 4 ghz on a C0 stepping processor with only 1.28 vcore and you’re wondering if yours will do the same. It’s doubtful, but who knows. It may take you up to 1.4 volts at least with a C0. That’s life; if you're unhappy, sell it and buy a D0.
2. Not all i7s have the same quality IMC (Integrated Memory Controller). Some are more temperamental than others and will refuse to run your ram at its rated speed without a huge raise of qpi/uncore (VTT). This is not common and often it can be a sign of the quality of the ram.
3. For the most part, D0's overclock higher and at lower voltages than C0 chips, due to refinements in the fabrication process. Late C0 chips benefitted from the same refinements, and random other batches hit 4.0 ghz at really low volts. I have been told that some D0's do not hit 4.0, but most will do so at a lower voltage than most C0's. A D0 is a more desirable chip, but it's not a must and this guide is still useful to owners of C0's.
4. Toms Hardware article about speed vs power consumption is flawed and based on one really terrible C0 that needed 1.5 vcore to hit 4ghz. Is a D0 at 1.2v at 4 ghz going to consume more power than a C0 at 3.6 and 1.32 volts? No. The D0 will use less. Power consumption at any given voltage will increase about 3-11 watts (avg 5 for every 100 mhz you increase). Something brough to my attention recently though is that this may differ because some chips are leakier than others. A D0 is by no means a guarantee that it will consume less power.
5. If you want to reach higher clocks, you may need a better motherboard, cooler, chip or whatever. This guide is not for advanced overclockers.
Key Terms and Settings Quick Guide:
BCLK – Base Clock - This clock controls your memory speed, QPI speed, and core speed based on whatever multiples for those settings you have. It's the most important part of overclocking the Core i7. It's stock setting is 133
Uncore – This is basically the speed of everything which isn't your core (i.e. L3 cache, IMC, etc). It should be 2x your memory speed but allows for multipliers higher than 2x as well. Stability will be greatest at 2x.
QPI – Quickpath interconnect - It's basically the intel equivalent of AMD's hypertransport. It's how the CPU and the X58 chipset communicate. It has multipliers of 18x, 22x, and 24x. The 920 should be left at 18x creating a 9:8 ratio between the uncore and the memory multiplier assuming you use the 8x ratio, which some claim offers the greatest stability. Although people have been able to run it at all sorts of ratios.
Memory - Memory is calculated based on either a 6x, 8x, 10x, 12x, or 14x of your base clock. I recommend 6x and 8x. Depending on your mobo bios it may be called ratio or multiplier.
Ram Timings – This guide will only deal with the first four and the command rate. There are other guides regarding these. You can use XMP (intel's memory profile system) to have these values plugged in but it may set your QPI/uncore voltage automatically to 1.35 which may be more than you need (although it will be stable).
Turbo mode – This enables the 21x multiplier on the chip. Most boards allow you to do this with eist disabled, but some boards require it enabled. See if a newer bios lets you change things.
CPU Multiplier – On the 920 the range is from 12x – 21x (22x on one core when at stock speeds). It has been found that the 19x and 21x multipliers are more stable than the 20x.
Vcore – Voltage of your cpu. See below for tweaking instructions.
PLL – phase-locked loop – Just use the settings recommended below (1.8 – 1.88 is within specification).
QPI/Uncore (VTT) – This voltage is the VTT although it does play a role in feeding the IMC with voltage enough to overclock your ram, the L3 cache and a number of other things (Specification is that it should be less than 1.35 but when taking droop into account you can go higher, probably 1.4 is safe. Some ram modules have XMP profiles which call for higher QPI so some will argue that this is safe. I'm not going to argue one way or the other.)
Vdimm – Your ram voltage (Specification says 1.65 max but 1.66 is fine and so is a bit higher depending on your QPI/uncore voltage).
Important to do before you overclock:
EIST – Enhanced intel speedstep technology - It's a power saving tech that should be disabled while testing overclocking stability. This should be disabled while finding your OC, but can be enabled after you are stable (Disable if you have stability issues).
C1E – Another intel power saving technology. Disable while overclocking, enable afterwards.
Anything Spread Spectrum – Disable it.
PCIE frequency – Always at 100, but see FAQ questions below.
LLC - Load Line Calibration - This gets rid of vdroop when enabled and can help stabilize overclocks. It breaks intel spec, but it is highly recommended to enable it, since it will reduce the needed vcore for a stable OC. The argument for vdroop is that it's a standard and reduces voltage spikes. I have not been able to find anyone who's done any damage by enabling LLC and thus disabling vdroop. In an old anandtech review from 2007 they found that it increased power consumption on an X38 asus board; a newer xbitlabs article using X58 found that it actually decreased with more threads or was otherwise the same. This guide pretty much assumes you use it, but like anything else you are taking the risk. Then again, on my board, enabling it doesn't give you any red letter warning like when you maybe tap your vdimm above 1.65.
All other settings leave at auto unless needed for stability.
Initial steps:
If you've played around with any settings before reset your bios to its stock options. There's probably no need to reset your CMOS, but it can't hurt; if you don't know how to reset your CMOS then I suggest you learn to do so. It's unlikely that you will have to as most modern motherboards will usually have some sort of protection against bad overclocks and automatically allow you to reset the bios upon a bad boot.
Once your bios is at its stock configuration disable EIST, turbo mode, C1, and any other power saving options that may interfere with an overclock as well as any spread spectrum settings. Now, boot into windows (If you want to use the 21x multiplier then go right ahead and set it as long as you can do so without enabling EIST). Open up cpuz, load up prime and see where the voltage goes. This is your approximate vid for stock. The chip may very well run under this voltage, but this is the vid that the bios is seeing.
From here we have a number of different methods we can try. I always change my BCLK in my bios settings so that anything set to auto will adjust itself if need be, although you are free to use whatever windows based tools you want although beware of any problems they may cause you.
You should always set your memory to 8x or 6x depending on what you have and your uncore to 2x the memory. Leave the QPI at the lowest setting.
Set windows not to restart on a bsod (You want to know what the error was):
Windows XP and Vista Directions, but it is the same for Win7.
Method #1: Optimizing for max performance per watt.
This method takes by far the most amount of time but for many its worth it in terms of its power efficiency.
Begin by going into the bios and changing your voltage to your vid and setting QPI/uncore (VTT) to 1.25 (I have raised this due to concerns about droop at 1.2) and vdimm to 1.65 (Most boards can't do this; 1.66 is safe, ignore your spaz bios warnings; you are not going to explode anything, although if you do, it's not my fault. Set it to 1.64 if it helps you sleep easier. I recommend at this point to be working with either the 21x multiplier if possible in order to keep your ram as much out of the equation as possible. 20X has known problems and 19x will land you with high ram speeds quicker which will require raises in the QPI/uncore voltage sooner.
Open up real temp and run Prime 95 with 8 threads and check stability for an hour at least (The more the better. I recommend overnight just to make sure all is good). Record your settings on a piece of paper or email them to yourself. Make sure to have Realtemp open in order to watch your temperatures. Temperatures should not exceed 80-85 during Prime. During normal use for extended periods, they should never see these kinds of temperatures. I like to keep mine below 70 for normal usage.
After its stable go into the bios and increase the BCLK by 10 and repeat the process. Find the max BCLK for your stock vid (or any voltage, if you'd like by lowering by smaller amounts when you find an unstable clock. This will help you know what you can run at any given voltage.
See below for known Prime 95 errors and how they relate to your settings (also some settings to try for stability). Once you get to the clocks you want, I recommend running Prime for at least 16-24 hours. I have in fact had errors in the 14th hour so it's good to know that you're truly stable.
See also below for optimizing your ram settings.
Method #2: Quick and dirty method for 4ghz aka screw efficiency
Set your ioh and ich to 1.2, your vdimm to 1.65, your cpu pll to 1.88, and your QPI/uncore to 1.35.
For D0 users set your vcore to 1.275 and for C0/C1 users set your vcore to 1.4 and BCLK to 190/191 or 210/211 and multiplier to 21 and 19 respectively. Check for Prime stability. D0's should be fine, but C0/C1 still may not make it, at this point your temps may be too high if you're not on water, so I suggest you start working backward in order to hit a much lower vcore or use method 3.
Method #3: Quick and dirty vcore boosting.
Set your ioh and ich to 1.2, your vdimm to 1.65, your cpu pll to 1.88, and your QPI/uncore to 1.35. Set BCLK to 190/191 or 210/211 and multiplier to 21 and 19 respectively.
The D0 chip usually hits 4.0 in the vcore range of 1.175 and 1.25. Try those voltages until you find whats right for your chip.
The C0/C1 is a much more difficult beast with a much larger range of 1.27 to around 1.4 and up to 1.5 (Do not attempt on air unless you live somewhere really, really cold). Some may not hit 4ghz at all.
This method is more difficult as some chips may not boot until you give them the proper vcore
How to use Prime95 to test stability:
Open up Prime95 and Realtemp to check your idles and loads. Set Prime95 to whatever priority you'd like. I prefer 4 or 7 so that realtemp still updates but some people prefer 10 and will run without a temperature monitor. Either is fine, but I'm always paranoid that my cooler will somehow become unlatched spontaneously. Set windows not to restart on bluescreen by setting [insert settings here] so that you can catch the error (although windows will record it somewhere). Start a mixed torture test and let it run for however long, depending on if you're only doing a temporary stability test in order to raise (about 1 hour) or a true stability test (16-24 hours). Once you've passed Prime95 you can run any other stability test that you want.
Prime 95 Errors:
Freeze: Increase the vcore
Other errors can indicate instability with the chip if they are during small fft (increase vcore by .125) or instability with ram large ftt (Try raising the ioh and/or running memtest).
BSOD code 101: Increase the vcore. I recommend increasing by +.025 if you get a bsod
BSOD code 124: Increasese or decrease the QPI/uncore by .25. Depending on where you are in your stability tests you'll probably need to increase it. 1.375 is the max I'm comfortable with although people say 1.4+ is safe. This is for you to determine and research. Don't do anything you're not comfortable with. Intel says do not go above 1.35 so 1.375 with droop and loss is safe and not too far outside specification.
It is important to note that sometimes QPI can be too high and that might cause this code. That's why it's not a good idea to just set things to 1.35 and hope for the best. If you find that increasing QPI/uncore voltage is not increasing stability, try decreasing it. Just remember of course, to keep track of your settings. I recommend not increasing, unless you have to (Don't be arbitrary about it).
D0 exclusive BSOD weird 2 letter/number codes: Treat this as a 101 and increase vcore by +.025. Update: It seems that these error codes can crop up for other reasons. Depending on where you are in the process you should take a look at your other voltages. I realize this is vague, but you may need to experiment.
If any worker fails, especially during small fft then it's cpu voltage. Bump it once or twice. If it fails during large fft then its probably memory error you can try running memtest/upping ioh. I would try running small fft at that point for a good amount of time and make sure its not the cpu voltage. If it passes 8-12 hours of small fft then work on making it pass large fft. Just remember to keep track of your settings. That's not to say that a large fft error won't be the result of cpu voltage, it's just not what I would try. Be methodical. If something allows Prime to run significantly longer then keep it. Significant depends where you are in the process. If your workers fail as soon as you start and a setting change gets you through a test then I'd say its good. If you get crashes during the 8th hour, and the setting change only gets you another 5 minutes in the 8th hour, it's probably just random and not the setting.
Testing Memory Stability with memtest 86+:
Personally, I do not run memtest until I actually encounter what could be memory errors( I assume things work until proven otherwise). Begin by setting your ram timings in the bios and setting your QPI/uncore to 1.35 and your vdimm to 1.64-1.66. Do not oc your cpu. Just run your ram at its rated spec to make sure that the ram is stable and not defective. You can also check it again with an oc'ed cpu as well. If it's unstable try raising the ioh to 1.20 or higher. If you are still getting errors try each dimm one at a time and see if you need to RMA (A pain in the *** but necessary).
Optimizing ram with memtest86+:
Assuming your ram is stable you can either overclock, lower voltage, tighten timings, or all of the above.
1. Lowering voltage. Run memtest86 for 20 minutes, if you get errors, stay where you are. Otherwise lower the vdimm by .02 and repeat until you get an error within 20 minutes. Then run it overnight.
2. Overclocking. You may be able to run your ram faster than you thought. Loosen the timings(make them higher) and then increase BCLK. You can optimize your voltage with the above number one. Depending on the ram, you may be able to overclock quite a bit or not at all. Running your ram at anything above 1066 is in fact overclocking the IMC.
3. Tightening timings. Timings should be decreased as such. Assuming you begin with 9-9-9 your next step should be 9-9-8 then 9-8-8 then 8-8-8. You can also try 8-9-8 but this is going to depend on your memory. You may need to raise voltages to tighten the timings.
The usefulness of overclocking your ram is limited. See the useful links sections below to see how certain ram settings will impact your real life performance.
Frequently asked questions:
Q: I can't raise my BCLK over some number. How do I fix it? What's the deal?
A: Not all chips and motherboards are made the same. You can try playing around with voltage amplitude, pll, skew or pcie (pcie is probably best not raised as it can cause damage). This is a question that is better asked on a thread dedicated to a specific board. You may end up being out of luck.
Q: What are safe voltages?
A: According to Intel or common knowledge the following are the safe air temperatures:
Vcore: ~1.4
QPI/uncore (VTT): 1.35
PLL: 1.88
Vdimm:~1.65 (Some will say that you are safe within .5 of your QPI/uncore allowing for a max of 1.85 on vdimm. See the link to the xtreme systems forum below on this subject for a long thread).
IOH: Less than 1.3
ICH: Less than 1.3
Q: My chip is too hot before I can reach 4 ghz. What can I do?
A: Disable hyperthreading or buy a better cooler (Noctua, TRUE or Megahalems recommended).
Q: But don't I want hyperthreading?
A: It's certainly nice to have a feature you paid for, but it sometimes decreases performance and it definitely causes a lot of heat. It's up to you.
Q: How do I go past 4ghz?
A: Same way as you got there in the first place. Just keep increasing BCLK. Past this point though it's up to you to do some research on your own.
Q: What is this multiplier throttling I've heard about?
A: Some boards will throttle down the 21x multiplier if the wattage becomes too high. The culprits without public fixes are the Asus P6T Deluxe and vanilla (The Deluxe v1 has a bios available on the xtremesystems forum which can be crossflashed onto the v2 which will fix this problem) It really only becomes a problem at high voltages with high frequencies. Other boards have ways of disabling it.
Q: Why would I want to optimize my voltages?
A: Save money on power bills and leave more wattage for other devices.
Q: My chip was stable for X amount of time and now it's not?
A: Have you added any hardware? How are your temperatures? High voltages and high temps can cause decay and make the chip require more voltage for an overclock. It may also be that your PSU is starting to go or maybe your motherboard is. Do your best to troubleshoot this.
Q: My temperatures seem really high? Is X degrees ok?
A: A better question is whether or not you are ok with X degrees. How long do you plan to won this chip? What are your ambients? If your house is 40 degrees centigrade, don't expect your chip to drop below that unless you are using extreme cooling (also try to move somewhere cooler cause that's really hot or get some AC, are you trying to cook yourself?). A cpu well taken care of can last over a decade when run within spec. How long do you really think you're going to keep this chip? A rule of thumb I go by is never push a part that I can't afford to replace if I break it (I do this anyway, but its a good rule nonetheless). Your temps will always get higher than normal when stress testing so do some normal stuff to see if your temperatures are acceptable. Try backing down a bit if you are unhappy.
Q: I heard this will work or this needs to be this way?
A: Try it. This is a general guide, not a set of hard and fast rules.
Q: My computer restarted while priming; how do I find out the error?
A: If you haven't already, disable bsod restarts in windows. Sometimes, though, it decides to restart anyway.
Open Computer Management by right-clicking the Computer icon on the start menu (or on the Desktop if you have it enabled) and select Manage. Navigate to the Event Viewer. Note: If you did not disable UAC then you will be prompted to consent to the action you're about to perform. Click Continue. Note: You can also open the Event Viewer by typing Event Viewer in the Search box and pressing Enter, or typing eventvwr.msc in the Run command.
Also check the results.txt in your Prime95 folder for a log of when it ultimately crashed and what it was doing at the time.
Q: Whats the deal with PCIE frequency? Can it help break my BCLK wall?
A: Yes, but I advise caution. Raising this too much can damage things running on the pcie bus or cause them to not work. I would not raise it personally more than a few mhz. You are probably safe at 103, but I take no responsibility of course.
Voltages/settings you can try to use to increase stability:
PLL: 1.88
IOH: 1.2+
ICH: 1.2
CPU voltage amplitude: +800mv
CPU Skew: +300ps
Command rate: change from 1n to 2n
You should really check in on your specific board as not all boards have the same settings. Be methodical in testing settings since you want to know whether something helped or hurt by itself before you combine.
Useful Links:
http://www.overclock.net/intel-cpus/538439-guide-overclocking-core-i7-920-4-a.html
Intel Info on the i7
QPI/Uncore voltage (XS) (Do not take this as gospel try to stay in spec unless you feel like really pushing things)
Info on multiplier throttling (XS)
Memory Scaling on the Core I7My i7 rig is with a socket 1156 board, an Asus P7P55D mobo, and an 860 CPU. I know the Corsair DDR3 memory @ its stock 1.65v simply doesn't run at 1600mhz like it says on its box - 1333mhz seems to be its stability wall.
I upgraded my Q6600 and Asus P5B deluxe rig because so many people said to never consider overclocking on an editing rig. Was that over-cautious advice? -
Hi,
I've been asked to see if I can fix a C program so that it will run on a mac. It currently compiles and runs perfectly on a linux machine, but as soon as you run it on a mac, it will compile, but quit with a bus error very early on. The full code is here:
// Program for the construction of cartograms (density-equalizing map
// projections) using the Gastner-Newman technique. The program needs polygon
// coordinates and a count of cases in each region as input, calculates the new
// coordinates, and writes these to a file. Postscript images of the original
// map and the cartogram are created.
// WRITTEN BY MICHAEL GASTNER, September 20, 2004.
// If you use output created by this program please acknowledge the use of this
// code and its first publication in:
// "Generating population density-equalizing maps", Michael T. Gastner and
// M. E. J. Newman, Proceedings of the National Academy of Sciences of the
// United States of America, vol. 101, pp. 7499-7504, 2004.
// The input coordinates in MAPGENFILE must be in ArcInfo "generate" format of
// the type:
// 1
// 0.3248690E+06 0.8558454E+06
// 0.3248376E+06 0.8557575E+06
// 0.3248171E+06 0.8556783E+06
// 0.3247582E+06 0.8556348E+06
// 0.3246944E+06 0.8555792E+06
// 0.3246167E+06 0.8555253E+06
// 0.3250221E+06 0.8557324E+06
// 0.3249436E+06 0.8557322E+06
// 0.3248690E+06 0.8558454E+06
// END
// 1
// 0.3248690E+06 0.8558454E+06
// 0.3249651E+06 0.8558901E+06
// 0.3250519E+06 0.8559769E+06
// 0.3250691E+06 0.8561246E+06
// 0.3249678E+06 0.8560541E+06
// 0.3249003E+06 0.8560088E+06
// 0.3076424E+06 0.8477603E+06
// 0.3075691E+06 0.8477461E+06
// 0.3075595E+06 0.8476719E+06
// END
// 2
// 0.6233591E+06 0.6056502E+06
// 0.6235193E+06 0.6056467E+06
// 0.6235054E+06 0.6055372E+06
// 0.7384296E+06 0.2334260E+06
// 0.7383532E+06 0.2345770E+06
// END
// END
// The number of cases in CENSUSFILE must be given in the form
// region #cases (optional comment), e. g:
// 43 0.9 Alabama
// 51 0.3 Alaska
// 37 0.8 Arizona
// 47 0.6 Arkansas
// 25 5.4 California
// 32 0.8 Colorado
// 19 0.8 Connecticut
// 29 0.3 Delaware
// 28 0.3 District of Columbia
// 49 2.5 Florida
// 45 1.3 Georgia
// 1 0.4 Hawaii
// The output coordinates are written to CARTGENFILE in ArcInfo "generate"
// format. A postscript image of the original input is prepared as MAP2PS,
// an image of the cartogram as CART2PS.
// Modified on Oct 29, 2004. The number of divisions in each dimension lx, ly
// will now be determined from the input map. Also fixed array bound
// violations in intpol and newt2, and centered the ps-files.
// Modified on Dec 3, 2004. Introduced pointers bbmaxx,bbmaxy,bbminx,bbminy -
// the bounding box coordinates for each polygon - to reduce calculations in
// crnmbr. Thanks to Chris Brunsdon for the suggestion.
// Program now terminates with error message if there is no density specified
// in CENSUSFILE for a region on the map.
// "Donut" polygons are now handled properly. Polygons oriented clockwise will
// be considered exterior boundaries. If they are oriented anti-clockwise they
// are holes inside an enclosing polygon. (Unconventional for mathematicians,
// but this is ArcGIS standard.) The identifier is either that of the enclosing
// polygon, or -99999 in which case it is a hole in the preceding polygon.
// The population can now be a floating-point number.
// If a region contains exactly zero population, it will be replaced by
// MINPOPFAC times the smallest positive population in any region.
// Obviously, MINPOPFAC should be <1, I will set it to 0.1 by default. This
// should reduce the value of sigma necessary for the integrator to finish
// properly.
// Modified on March 31, 2005. Initialized maxchange in nonlinvoltra() as
// INFTY. Replaced crnmbr() by a similar, but faster routine interior().
// Many thanks to Stuart Anderson for pointing out this shortcut.
// TO DO LIST:
// - Do Gaussian blur within nonlinvoltra as a simple call to calcv and
// eliminate gaussianblur().
// - Modify the NR code for the FFTs to deal more naturally with the fencepost
// issue. No more copying of arrays in sinft and cosft.
// - Write truly two-dimensional versions of coscosft, cossinft, and sincosft.
// See Chan and Ho: A new two-dimensional fast cosine transform algorithm,
// IEEE Transactions on Signal Processing, 39, 481ff. (1991).
// - Read polygon data directly from shapefile instead of generate file.
// - Reorganize data structures. It is currently quite a mess to read.
// Inclusions
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
// Definitions
#define CART2PS "./cart.ps","w" // Cartogram image.
#define CARTGENFILE "./cartogram.gen" // Cartogram generate file.
#define CENSUSFILE "./census.dat","r" // Input.
#define CONVERGENCE 1e-100 // Convergence criterion for integrator.
// #define DISPLFILE "./displ.dat","w"
#define FALSE 0
#define HINITIAL 1e-4 // Initial time step size in nonlinvoltra.
#define IMAX 50 // Maximum number of iterations in Newton-Raphson routine.
#define INFTY 1e100
#define LINELENGTH 1000
#define MAP2PS "map.ps","w" // Map image.
#define MAPGENFILE "./map.gen","r" // Input coordinates.
#define MAX(a,b) ((b>a)?(b):(a))
#define MAXINTSTEPS 3000 // Maximum number of time steps in nonlinvoltra.
#define MAXNSQLOG 18 // The number of sample points for rho_0 is <~2^MAXNSQLOG.
#define MIN(a,b) ((b<a)?(b):(a))
#define MINH 1e-5 // Smallest permitted time step in the integrator.
#define MINPOPFAC 0.1 // Replace 0 population by a fraction of the minimum.
#define NR_END 1
#define NSUBDIV 1 // Number of linear subdivisions for digitizing the density.
#define PADDING 1.5 // Determines space between map and boundary.
#define PI 3.141592653589793
#define SIGMA 0.1 // Initial width of Gaussian blur.
#define SIGMAFAC 1.2 // Increase sigma by this factor. Must be > 1.
#define SWAP(a,b) tempr=(a);(a)=(b);(b)=tempr;
#define TIMELIMIT 1e8 // Maximum time allowed in integrator.
#define TOLF 1e-3 // Sensitivity w. r. t. function value in newt2.
#define TOLINT 1e-3 // Sensitivity of the integrator.
#define TOLX 1e-3 // Sensitivity w. r. t. independent variables in newt2.
#define TRUE !FALSE
// Types
typedef int BOOLEAN;
typedef struct
float x;
float y;
} POINT;
// Globals
float bbmaxx,*bbmaxy,*bbminx,*bbminy,**gridvx,*gridvy,maxx,maxy,minpop,
minx,miny,polymaxx,polymaxy,polyminx,polyminy,*rho,**rho_0,**vx,**vy,*x,
*xappr,xstepsize,**y,*yappr,ystepsize;
int lx,ly,maxid,nblurs=0,npoly,npolycorn,*npolyinreg,nregcorn,nregion,
polygonid,**polyinreg,*regionid,*regionidinv,*within;
POINT *polycorn,*regcorn;
// Function prototypes
int readline(char line[],FILE *infile);
void countpoly(FILE *infile);
void countcorn(FILE *infile);
void readcorn(FILE *infile);
void makeregion(void);
void pspicture(FILE *outfile);
void bboxes(void);
void interior(void);
double regionarea(int ncrns,POINT *polygon);
void digdens(void);
void four1(float data[],unsigned long nn,int isign);
void realft(float data[],unsigned long n,int isign);
void cosft(float z[],unsigned long n,int isign);
void sinft(float z[],unsigned long n,int isign);
void coscosft(float **y,int isign1,int isign2);
void cossinft(float **y,int isign1,int isign2);
void sincosft(float **y,int isign1,int isign2);
float **dmatrix(long nrl,long nrh,long ncl,long nch);
float *d3tensor(long nrl, long nrh, long ncl, long nch, long ndl, long ndh);
void free_matrix(float **m,long nrl,long nrh,long ncl,long nch);
void free_f3tensor(float *t,long nrl,long nrh,long ncl,long nch,long ndl,
long ndh);
void fourn(float data[],unsigned long nn[],int ndim,int isign);
void rlft3(float *data,float **speq,unsigned long nn1,unsigned long nn2,
unsigned long nn3,int isign);
void gaussianblur(void);
void initcond(void);
void calcv(float t);
float intpol(float **arr,float x,float y);
BOOLEAN newt2(float h,float *xappr,float xguess,float *yappr,float yguess,
int j,int k);
BOOLEAN nonlinvoltra(void);
POINT transf(POINT p);
void cartogram(void);
// Function to read one line.
int readline(char line[],FILE *infile)
if (fgets(line,LINELENGTH,infile)==NULL) return 1;
return 0;
// Function to count the number of polygons.
void countpoly(FILE *infile)
char line[LINELENGTH];
npoly = 0;
while (!readline(line,infile)) if (line[0] == 'E') npoly++;
npoly--; // The .gen file ends with two consecutive "END"s.
// Function to count polygon corners. Also determines minimum/maximum x-/y-
// coordinate.
void countcorn(FILE *infile)
BOOLEAN bnd_ok = FALSE;
char line[LINELENGTH];
float x,y;
int polyctr=0,ratiolog;
npolycorn = (int*)calloc(npoly,sizeof(int));
polycorn = (POINT*)malloc(npoly*sizeof(POINT));
readline(line,infile); // Skip first line.
readline(line,infile);
sscanf(line,"%f %f",&x,&y);
polyminx = x; polymaxx = x; polyminy = y; polymaxy = y;
npolycorn[0] = 1;
while (!readline(line,infile))
if (line[0] != 'E')
sscanf(line,"%f %f",&x,&y);
if (x < polyminx) polyminx = x;
if (x > polymaxx) polymaxx = x;
if (y < polyminy) polyminy = y;
if (y > polymaxy) polymaxy = y;
npolycorn[polyctr]++;
else
readline(line,infile);
polycorn[polyctr] = (POINT)malloc(npolycorn[polyctr]sizeof(POINT));
polyctr++;
if (ceil(log((polymaxx-polyminx)/(polymaxy-polyminy))/log(2))+
floor(log((polymaxx-polyminx)/(polymaxy-polyminy))/log(2))>
2*log((polymaxx-polyminx)/(polymaxy-polyminy))/log(2))
ratiolog = (int)floor(log((polymaxx-polyminx)/(polymaxy-polyminy))/log(2));
else
ratiolog = (int)ceil(log((polymaxx-polyminx)/(polymaxy-polyminy))/log(2));
lx = (int)pow(2,(int)(0.5*(ratiolog+MAXNSQLOG)));
ly = (int)pow(2,(int)(0.5*(MAXNSQLOG-ratiolog)));
if ((polymaxx-polyminx)/lx > (polymaxy-polyminy)/ly)
maxx = 0.5((1PADDING)*polymaxx(1-PADDING)polyminx);
minx = 0.5((1-PADDING)*polymaxx(1PADDING)polyminx);
maxy = 0.5(polymaxypolyminy(maxx-minx)ly/lx);
miny = 0.5(polymaxy+polyminy-(maxx-minx)ly/lx);
else
maxy = 0.5((1PADDING)*polymaxy(1-PADDING)polyminy);
miny = 0.5((1-PADDING)*polymaxy(1PADDING)polyminy);
maxx = 0.5(polymaxxpolyminx(maxy-miny)lx/ly);
minx = 0.5(polymaxx+polyminx-(maxy-miny)lx/ly);
// Uncomment the next lines for interactive choice of boundary conditions.
/* printf("For the %i polygon(s) under consideration:\n",npoly);
printf("minimum x = %f\tmaximum x = %f\n",polyminx,polymaxx);
printf("minimum y = %f\tmaximum y = %f\n",polyminy,polymaxy);
while (!bnd_ok)
printf("Type in your choice of boundaries.\nminx = ");
scanf("%f",&minx);
printf("maxx = ");
scanf("%f",&maxx);
printf("miny = ");
scanf("%f",&miny);
printf("maxy = ");
scanf("%f",&maxy);
if (minx>polyminx || maxx<polymaxx || miny>polyminy || maxy<polymaxy)
printf("Invalid choice, does not enclose the polygon(s).\n");
else bnd_ok = TRUE;
// Function to read polygon corners. The first and last vertex of each polygon
// must be identical.
void readcorn(FILE *infile)
char line[LINELENGTH];
float xcoord,ycoord;
int i,id,polyctr=0;
polygonid = (int)malloc(npolysizeof(int));
xstepsize = (maxx-minx)/lx;
ystepsize = (maxy-miny)/ly;
if (fabs((xstepsize/ystepsize)-1)>1e-3)
fprintf(stderr,"WARNING: Area elements are not square: %f : %f\n",
xstepsize,ystepsize);
readline(line,infile);
sscanf(line,"%i",&id);
polygonid[polyctr] = id;
i = 0;
while (!readline(line,infile))
if (line[0] != 'E')
sscanf(line,"%f %f",&xcoord,&ycoord);
polycorn[polyctr].x = (xcoord-minx)/xstepsize;
polycorn[polyctr][i++].y = (ycoord-miny)/ystepsize;
else
// Is first and last vertex the same?
if (fabs(polycorn[polyctr][0].x-
polycorn[polyctr][npolycorn[polyctr]-1].x)+
fabs(polycorn[polyctr][0].y-
polycorn[polyctr][npolycorn[polyctr]-1].y)>1e-12)
fprintf(stderr,
"ERROR: %i-th polygon does not close upon itself.\n",
polyctr+1);
fprintf(stderr,"Identifier %i, first point %f %f.\n",
polygonid[polyctr],polycorn[polyctr][0].x*xstepsize+minx,
polycorn[polyctr][0].y*ystepsize+miny);
exit(1);
readline(line,infile);
sscanf(line,"%i",&id);
i = 0;
polyctr++;
if (polyctr<npoly) polygonid[polyctr] = id;
polyminx = (polyminx-minx)/xstepsize;
polyminy = (polyminy-miny)/ystepsize;
polymaxx = (polymaxx-minx)/xstepsize;
polymaxy = (polymaxy-miny)/ystepsize;
// Function to make regions from polygons.
void makeregion(void)
BOOLEAN repeat;
int i,lastid,minid,polyctr,ptctr,regctr;
// Count the number of regions.
nregion = 0;
maxid = minid = polygonid[0];
for (polyctr=0; polyctr<npoly; polyctr++)
if (polygonid[polyctr] == -99999) continue;
if (polygonid[polyctr]>maxid || polygonid[polyctr]<minid) nregion++;
else
repeat = FALSE;
for (i=0; i<polyctr; i++)
if (polygonid[polyctr]==polygonid)
repeat = TRUE;
break;
if (!repeat) nregion++;
if (polygonid[polyctr]>maxid) maxid = polygonid[polyctr];
if (polygonid[polyctr]<minid) minid = polygonid[polyctr];
if (minid < 0)
fprintf(stderr,
"ERROR: Negative region identifier %i.\n",minid);
exit(1);
// Match region identifiers.
regionid = (int)malloc(nregionsizeof(int));
nregion = 0;
maxid = minid = polygonid[0];
for (polyctr=0; polyctr<npoly; polyctr++)
if (polygonid[polyctr] == -99999) continue;
if (polygonid[polyctr]>maxid || polygonid[polyctr]<minid)
regionid[nregion++] = polygonid[polyctr];
else
repeat = FALSE;
for (i=0; i<polyctr; i++)
if (polygonid[polyctr]==polygonid)
repeat = TRUE;
break;
if (!repeat) regionid[nregion++] = polygonid[polyctr];
if (polygonid[polyctr]>maxid) maxid = polygonid[polyctr];
if (polygonid[polyctr]<minid) minid = polygonid[polyctr];
regionidinv = (int)malloc((maxid+1)sizeof(int));
// Negative number for unused identifiers.
for (i=0; i<=maxid; i++) regionidinv = -1;
for (regctr=0; regctr<nregion; regctr++)
regionidinv[regionid[regctr]] = regctr;
// Which polygons contribute to which regions?
npolyinreg = (int*)calloc(nregion,sizeof(int));
polyinreg = (int*)malloc(nregion*sizeof(int));
lastid = polygonid[0];
for (polyctr=0; polyctr<npoly; polyctr++)
if (polygonid[polyctr] != -99999)
npolyinreg[regionidinv[polygonid[polyctr]]]++;
lastid = polygonid[polyctr];
else npolyinreg[regionidinv[lastid]]++;
for (regctr=0; regctr<nregion; regctr++)
polyinreg[regctr] = (int)malloc(npolyinreg[regctr]sizeof(int));
for (regctr=0; regctr<nregion; regctr++) npolyinreg[regctr] = 0;
lastid = polygonid[0];
for (polyctr=0; polyctr<npoly; polyctr++)
if (polygonid[polyctr] != -99999)
polyinreg[regionidinv[polygonid[polyctr]]]
[npolyinreg[regionidinv[polygonid[polyctr]]]++] = polyctr;
lastid = polygonid[polyctr];
else polyinreg[regionidinv[lastid]][npolyinreg[regionidinv[lastid]]++]
= polyctr;
// Make regions from polygons. Start and end each polygon at (0,0).
nregcorn = (int*)calloc(nregion,sizeof(int));
regcorn = (POINT*)malloc(nregion*sizeof(POINT));
for (regctr=0; regctr<nregion; regctr++)
for (i=0; i<npolyinreg[regctr]; i++)
nregcorn[regctr] += npolycorn[polyinreg[regctr]]+1;
nregcorn[regctr]++;
for (regctr=0; regctr<nregion; regctr++)
regcorn[regctr] = (POINT)malloc(nregcorn[regctr]sizeof(POINT));
ptctr = 0;
regcorn[regctr][ptctr].x = regcorn[regctr][ptctr++].y = 0.0;
for (polyctr=0; polyctr<npolyinreg[regctr]; polyctr++)
for (i=0; i<npolycorn[polyinreg[regctr][polyctr]]; i++)
regcorn[regctr][ptctr++] = polycorn[polyinreg[regctr][polyctr]];
regcorn[regctr][ptctr].x = regcorn[regctr][ptctr++].y = 0.0;
// Function to prepare a map in postscript standard letter format.
void pspicture(FILE *outfile)
char line[LINELENGTH];
float addx,addy,b,conv,g,r;
int ptctr,regctr;
if (11*lx > 8.5*ly)
conv = (float)8.5*72/lx;
addx = 0;
addy = 1136-8.5*36ly/lx;
else
conv = (float)11*72/ly;
addx = 8.536-11*36lx/ly;
addy = 0;
fprintf(outfile,"0.5 setlinewidth\n");
for (regctr=0; regctr<nregion; regctr++)
fprintf(outfile,"newpath\n");
fprintf(outfile,"%f %f moveto\n",
regcorn[regctr][1].x*conv+addx,
regcorn[regctr][1].y*conv+addy);
for (ptctr=2; ptctr<nregcorn[regctr]; ptctr++)
if (fabs(regcorn[regctr][ptctr].x)+
fabs(regcorn[regctr][ptctr].y)>1e-12)
fprintf(outfile,"%f %f lineto\n",
regcorn[regctr][ptctr].x*conv+addx,
regcorn[regctr][ptctr].y*conv+addy);
else
fprintf(outfile,"closepath\n");
if (ptctr<nregcorn[regctr]-1)
ptctr++;
fprintf(outfile,"%f %f moveto\n",
regcorn[regctr][ptctr].x*conv+addx,
regcorn[regctr][ptctr].y*conv+addy);
// Determine colors for map (without better knowledge I will do it
// arbitrarily).
if (regctr%3 == 0)
r = (float)regctr/nregion;
g = 1-(float)regctr/nregion;
b = fabs(1-2*(float)regctr/nregion);
else if (regctr%3 == 1)
b = (float)regctr/nregion;
r = 1-(float)regctr/nregion;
g = fabs(1-2*(float)regctr/nregion);
else
g = (float)regctr/nregion;
b = 1-(float)regctr/nregion;
r = fabs(1-2*(float)regctr/nregion);
fprintf(outfile,"%f %f %f setrgbcolor\ngsave\nfill\n",r,g,b);
fprintf(outfile,"grestore\n0 setgray stroke\n");
fprintf(outfile,"showpage\n");
// Function to find the bounding box for each polygon.
void bboxes(void)
int i,j;
float maxx, minx, maxy, miny;
bbmaxx = (float)malloc(npolysizeof(float));
bbmaxy = (float)malloc(npolysizeof(float));
bbminx = (float)malloc(npolysizeof(float));
bbminy = (float)malloc(npolysizeof(float));
for (i = 0; i < npoly; i++)
maxx = polycorn[0].x;
maxy = polycorn[0].y;
minx = maxx;
miny = maxy;
for (j = 0; j < npolycorn; j++)
if (polycorn[j].x > maxx) maxx = polycorn[j].x;
if (polycorn[j].x < minx) minx = polycorn[j].x;
if (polycorn[j].y < miny) miny = polycorn[j].y;
if (polycorn[j].y > maxy) maxy = polycorn[j].y;
bbmaxx=maxx;
bbmaxy=maxy;
bbminx=minx;
bbminy=miny;
void interior(void)
int i,inhowmanyregions,inregion[2],j,k,l,m,n,regctr;
// Initialize within[][]. -1 means outside all regions.
for (i=0; i<=lx; i++) for (j=0; j<=ly; j++) within[j] = -1;
// Fill within[][].
for (i=0; i<nregion; i++) for (j=0; j<npolyinreg; j++)
for (k=0, n=npolycorn[polyinreg[j]]-1;
k<npolycorn[polyinreg[j]]; n=k++)
for (l=(int)ceil(MIN(polycorn[polyinreg[j]][k-1].y,
polycorn[polyinreg[j]][k].y));
l<MAX(polycorn[polyinreg[j]][k-1].y,
polycorn[polyinreg[j]][k].y); l++)
for (m=(int)floor(bbminx[polyinreg[j]]);
m<(polycorn[polyinreg[j]][n].x-
polycorn[polyinreg[j]][k].x)*
(l-polycorn[polyinreg[j]][k].y)/
(polycorn[polyinreg[j]][n].y-
polycorn[polyinreg[j]][k].y)+
polycorn[polyinreg[j]][k].x;
m++)
within[m][l] = i-within[m][l]-1;
// Function to determine polygon area. This is needed to determine the average
// population.
// The problem in short is to find the area of a polygon whose vertices are
// given. Recall Stokes' theorem in 3d for a vector field v:
// integral[around closed curve dA]v(x,y,z).ds =
// integral[over area A]curl(v).dA.
// Now let v(x,y,z) = (0,Q(x,y),0) and dA = (0,0,dx*dy). Then
// integral[around closed curve dA]Q(x,y)dy = integral[over area A]dQ/dxdxdy.
// If Q = x:
// A = integral[over area A]dx*dy = integral[around closed curve dA]x dy.
// For every edge from (x,y) to (x[i1],y[i1]) there is a
// parametrization
// (x(t),y(t)) = ((1-t)xtx[i+1],(1-t)y+ty[i1]), 0<t<1
// so that the path integral along this edge is
// int[from 0 to 1]{(1-t)xt*x[i+1]}(y[i1]-y)dt =
// 0.5(y[i1]-y)(x+x[i1]).
// Summing over all edges yields:
// Area = 0.5*[(x[0]+x[1])(y[1]-y[0]) + (x[1]+x[2])(y[2]-y[1]) + ...
// ...(x[n-1]+x[n])(y[n]-y[n-1])+(x[n]x[0])(y[0]-y[n])]
// ArcGIS treats a clockwise direction as positive, so there is a minus sign.
double regionarea(int ncrns,POINT *polygon)
double area=0;
int i;
for (i=0; i<ncrns-1; i++)
area -=
0.5(polygon.xpolygon[i+1].x)(polygon[i1].y-polygon.y);
return area -= 0.5(polygon[ncrns-1].x+polygon[0].x)
(polygon[0].y-polygon[ncrns-1].y);
// Function to digitize density.
void digdens(void)
char line[LINELENGTH];
double area,avgdens,*cases,dens,minpop=INFTY,ncases,totarea=0.0,totpop=0.0;
FILE* infile;
int i,id,ii,inhowmanyregions,inregion[2],j,jj,regctr;
if ((infile=fopen(CENSUSFILE))==NULL)
fprintf(stderr,"ERROR: Cannot find CENSUSFILE.\n");
exit(1);
// Find the minimum positive number of cases.
while (!readline(line,infile))
sscanf(line,"%i %lf",&id,&ncases);
if (ncases<minpop && ncases>1e-12) minpop = ncases;
fclose(infile);
// Store the number of cases in an array.
cases = (double)malloc(nregionsizeof(double));
for (i=0; i<nregion; i++) cases = -1.0;
infile = fopen(CENSUSFILE);
while (!readline(line,infile))
sscanf(line,"%i %lf",&id,&ncases);
if (id>maxid || regionidinv[id]<0)
fprintf(stderr,"ERROR: Identifier %i in CENSUSFILE does not\n",id);
fprintf(stderr,"match any identifier in generate file.\n");
exit(1);
if (ncases>1e-12) totpop += (cases[regionidinv[id]] = ncases);
else totpop += (cases[regionidinv[id]] = MINPOPFAC*minpop);
for (regctr=0; regctr<nregion; regctr++) if (cases[regctr] < 0.0)
fprintf(stderr,"ERROR: No density for region %i?\n",regionid[regctr]);
fprintf(stderr,"cases = %f\n",cases[regctr]);
exit(1);
fclose(infile);
// Calculate regions' areas, total area to be mapped, regional and average
// densities.
area = (double)malloc(nregionsizeof(double));
for (regctr=0; regctr<nregion; regctr++)
totarea += (area[regctr] = regionarea(nregcorn[regctr],regcorn[regctr]));
dens = (double)malloc(nregionsizeof(double));
for (regctr=0; regctr<nregion; regctr++)
dens[regctr] = cases[regctr]/area[regctr];
avgdens = totpop/totarea;
// Digitize density.
for (i=0; i<=lx; i++) for (j=0; j<=ly; j++) rho_0[j] = 0; // Initialize.
printf("digitizing density ...\n");
for (i=0; i<lx; i++) for (j=0; j<ly; j++)
if (within[j]==-1) rho_0[j] = avgdens;
else rho_0[j] = dens[within[j]];
// Fill the edges correctly.
rho_0[0][0] += rho_0[0][ly] + rho_0[lx][0] + rho_0[lx][ly];
for (i=1; i<lx; i++) rho_0[0] += rho_0[ly];
for (j=1; j<ly; j++) rho_0[0][j] += rho_0[lx][j];
for (i=0; i<lx; i++) rho_0[ly] = rho_0[0];
for (j=0; j<=ly; j++) rho_0[lx][j] = rho_0[0][j];
// Replace rho_0 by Fourier transform
coscosft(rho_0,1,1);
free(area);
free(cases);
for (i=0; i<npoly; i++) free(polycorn);
free(polycorn);
for (i=0; i<nregion; i++) free(regcorn);
free(regcorn);
free(dens);
free(npolycorn);
free(nregcorn);
free(polygonid);
free(regionid);
free(regionidinv);
free(bbmaxx);
free(bbmaxy);
free(bbminx);
free(bbminy);
for (i=0; i<nregion; i++) free(polyinreg);
free(polyinreg);
free(npolyinreg);
// Function to replace data[1...2*nn] by its discrete Fourier transform, if
// isign is input as 1; or replaces data[1...2*nn] by nn times its inverse
// discrete Fourier transform, if isign is input as -1. data is a complex array
// of length nn or, equivalently, a real array of length 2*nn. nn MUST be an
// integer power of 2 (this is not checked for!).
// From "Numerical Recipes in C".
void four1(float data[],unsigned long nn,int isign)
double theta,wi,wpi,wpr,wr,wtemp;
float tempi,tempr;
unsigned long i,istep,j,m,mmax,n;
n=nn<<1;
j=1;
for (i=1; i<n; i+=2)
if (j>i)
// This is the bit-reversal section of the routine.
SWAP(data[j],data);
SWAP(data[j1],data[i1]); // Exchange the two complex numbers.
m=n>>1;
while (m>=2 && j>m)
j -= m;
m>>=1;
j += m;
// Here begins the Danielson-Lanczos section of the routine.
mmax=2;
while (n>mmax) // Outer loop executed log_2 nn times.
istep = mmax<<1;
// Initialize the trigonometric recurrence.
theta = isign*(6.28318530717959/mmax);
wtemp = sin(0.5*theta);
wpr = -2.0wtempwtemp;
wpi = sin(theta);
wr = 1.0;
wi = 0.0;
for (m=1; m<mmax; m+=2) // Here are the two nested inner loops.
for (i=m; i<=n; i+=istep)
j=i+mmax; // This is the Danielson-Lanczos formula
tempr=wrdata[j]-widata[j+1];
tempi=wrdata[j1]widata[j];
data[j]=data-tempr;
data[j1]=data[i1]-tempi;
data += tempr;
data[i+1] += tempi;
wr = (wtemp=wr)wpr-wiwpi+wr; // Trigonometric recurrence.
wi = wiwprwtempwpiwi;
mmax=istep;
// Function to calculate the Fourier Transform of a set of n real-valued data
// points. It replaces this data (which is stored in array data[1...n]) by the
// positive frequency half of its complex Fourier Transform. The real-valued
// first and last components of the complex transform are returned as elements
// data[1] and data[2] respectively. n must be a power of 2. This routine also
// calculates the inverse transform of a complex data array if it is the
// transform of real data. (Result in this case must be multiplied by 2/n).
// From "Numerical Recipes in C".
void realft(float data[],unsigned long n,int isign)
double theta,wi,wpi,wpr,wr,wtemp;
float c1=0.5,c2,h1i,h1r,h2i,h2r;
unsigned long i,i1,i2,i3,i4,np3;
theta = 3.141592653589793/(double) (n>>1); // Initialize the recurrence
if (isign == 1)
c2 = -0.5;
four1(data,n>>1,1); // The forward transform is here.
else // Otherwise set up for an inverse transform.
c2 = 0.5;
theta = -theta;
wtemp = sin(0.5*theta);
wpr = -2.0wtempwtemp;
wpi = sin(theta);
wr = 1.0+wpr;
wi = wpi;
np3 = n+3;
for (i=2; i<=(n>>2); i++) // Case i=1 done separately below.
i4 = 1(i3=np3-(i2=1+(i1=ii-1)));
// The two separate transforms are separated out of data.
h1r = c1*(data[i1]+data[i3]);
h1i = c1*(data[i2]-data[i4]);
h2r = -c2*(data[i2]+data[i4]);
h2i = c2*(data[i1]-data[i3]);
// Here they are recombined to form the true transform of the original
// data.
data[i1] = h1r+wrh2r-wih2i;
data[i2] = h1iwrh2iwih2r;
data[i3] = h1r-wrh2r+wih2i;
data[i4] = -h1iwrh2iwih2r;
wr = (wtemp=wr)wpr-wiwpi+wr; // The recurrence.
wi = wiwprwtempwpiwi;
if (isign == 1)
data[1] = (h1r=data[1])+data[2]; // Squeeze the first and last data
// together to get them all within the original array.
data[2] = h1r-data[2];
else
data[1] = c1*((h1r=data[1])+data[2]);
data[2] = c1*(h1r-data[2]);
// This is the inverse transform for the case isign = -1.
four1(data,n>>1,-1);
// Function to calculate the cosine transform of a set z[0...n] of real-valued
// data points. The transformed data replace the original data in array z. n
// must be a power of 2. For forward transform set isign=1, for back transform
// isign = -1. (Note: The factor 2/n has been taken care of.)
// From "Numerical Recipes in C".
void cosft(float z[],unsigned long n,int isign)
double theta,wi=0.0,wpi,wpr,wr=1.0,wtemp;
float *a,sum,y1,y2;
int j,n2;
// Numerical Recipes starts counting at 1 which is rather confusing. I will
// count from 0.
a = (float)malloc((n+2)sizeof(float));
for (j=1; j<=n+1; j++) a[j] = z[j-1];
// Here is the Numerical Recipes code.
theta=PI/n; //Initialize the recurrence.
wtemp = sin(0.5*theta);
wpr = -2.0wtempwtemp;
wpi = sin(theta);
sum = 0.5*(a[1]-a[n+1]);
a[1] = 0.5*(a[1]a[n1]);
n2 = n+2;
for (j=2; j<=(n>>1); j++)
wr = (wtemp=wr)wpr-wiwpi+wr;
wi = wiwprwtempwpiwi;
y1 = 0.5*(a[j]+a[n2-j]);
y2 = (a[j]-a[n2-j]);
a[j] = y1-wi*y2;
a[n2-j] = y1+wi*y2;
sum += wr*y2;
realft(a,n,1);
a[n+1] = a[2];
a[2] = sum;
for (j=4; j<=n; j+=2)
sum += a[j];
a[j] = sum;
// Finally I revert to my counting method.
if (isign == 1) for (j=1; j<=n+1; j++) z[j-1] = a[j];
else if (isign == -1) for (j=1; j<=n+1; j++) z[j-1] = 2.0*a[j]/n;
free(a);
// Function to calculate the sine transform of a set of n real-valued data
// points stored in array z[0..n]. The number n must be a power of 2. On exit
// z is replaced by its transform. For forward transform set isign=1, for back
// transform isign = -1.
void sinft(float z[],unsigned long n,int isign)
double theta,wi=0.0,wpi,wpr,wr=1.0,wtemp;
float *a,sum,y1,y2;
int j;
unsigned long n2=n+2;
// See my comment about Numerical Recipe's counting above. Note that the last
// component plays a completely passive role and does not need to be stored.
a = (float*) malloc((n+1)*sizeof(float));
for (j=1; j<=n; j++) a[j] = z[j-1];
// Here is the Numerical Recipes code.
theta = PI/(double)n; // Initialize the recurrence.
wtemp = sin(0.5*theta);
wpr = -2.0wtempwtemp;
wpi = sin(theta);
a[1] = 0.0;
for (j=2; j<=(n>>1)+1; j++)
// Calculate the sine for the auxiliary array.
wr = (wtemp=wr)wpr-wiwpi+wr;
// The cosine is needed to continue the recurrence.
wi = wiwprwtempwpiwi;
// Construct the auxiliary array.
y1 = wi*(a[j]+a[n2-j]);
y2 = 0.5*(a[j]-a[n2-j]);
// Terms j and N-j are related.
a[j] = y1+y2;
a[n2-j] = y1-y2;
// Transform the auxiliary array.
realft(a,n,1);
// Initialize the sum used for odd terms below.
a[1] *= 0.5;
sum = a[2] = 0.0;
// Even terms determined directly. Odd terms determined by running sum.
for (j=1; j<=n-1; j+=2)
sum += a[j];
a[j] = a[j+1];
a[j+1] = sum;
// Change the indices.
if (isign == 1) for (j=1; j<=n; j++) z[j-1] = a[j];
else if (isign == -1) for (j=1; j<=n; j++) z[j-1] = 2.0*a[j]/n;
z[n] = 0.0;
free(a);
// Function to calculate a two-dimensional cosine Fourier transform. Forward/
// backward transform in x: isign1 = +/-1, in y: isign2 = +/-1.
void coscosft(float **y,int isign1,int isign2)
float temp[lx+1];
unsigned long i,j;
for (i=0; i<=lx; i++)
cosft(y,ly,isign2);
for (j=0; j<=ly; j++)
for (i=0; i<=lx; i++) temp=y[j];
cosft(temp,lx,isign1);
for (i=0; i<=lx; i++) y[j]=temp;
// Function to calculate a cosine Fourier transform in x and a sine transform
// in y. Forward/backward transform in x: isign1 = +/-1, in y: isign2 = +/-1.
void cossinft(float **y,int isign1,int isign2)
float temp[lx+1];
unsigned long i,j;
for (i=0; i<=lx; i++)
sinft(y,ly,isign2);
for (j=0; j<=ly; j++)
for (i=0; i<=lx; i++) temp=y[j];
cosft(temp,lx,isign1);
for (i=0; i<=lx; i++) y[j]=temp;
// Function to calculate a sine Fourier transform in x and a cosine transform
// in y. Forward/backward transform in x: isign1 = +/-1, in y: isign2 = +/-1.
void sincosft(float **y,int isign1,int isign2)
float temp[lx+1];
unsigned long i,j;
for (i=0; i<=lx; i++)
cosft(y,ly,isign2);
for (j=0; j<=ly; j++)
for (i=0; i<=lx; i++) temp=y[j];
sinft(temp,lx,isign1);
for (i=0; i<=lx; i++) y[j]=temp;
// Function to allocate a float matrix with subscript range
// m[nrl..nrh][ncl..nch]. From "Numerical Recipes in C".
float **dmatrix(long nrl,long nrh,long ncl,long nch)
long i, nrow=nrh-nrl1,ncol=nch-ncl1;
float **m;
/* allocate pointers to rows */
m=(float **) malloc((unsigned int)((nrow+NR_END)sizeof(float)));
if (!m)
fprintf(stderr,"allocation failure 1 in matrix()\n");
exit(1);
m += NR_END;
m -= nrl;
/* allocate rows and set pointers to them */
m[nrl]=(float *) malloc((unsigned int)((nrowncol+NR_END)sizeof(float)));
if (!m[nrl])
fprintf(stderr,"allocation failure 2 in matrix()\n");
exit(1);
m[nrl] += NR_END;
m[nrl] -= ncl;
for(i=nrl1;i<=nrh;i+) m=m[i-1]+ncol;
/* return pointer to array of pointers to rows */
return m;
// Function to allocate a float 3tensor with range
// t[nrl..nrh][ncl..nch][ndl..ndh]. From "Numerical Recipes in C".
float *d3tensor(long nrl, long nrh, long ncl, long nch, long ndl, long ndh)
long i,j,nrow=nrh-nrl1,ncol=nch-ncl+1,ndep=ndh-ndl1;
float *t;
/* allocate pointers to pointers to rows */
t=(float *) malloc((sizet)((nrow+NREND)sizeof(float*)));
if (!t)
fprintf(stderr,"allocation failure 1 in f3tensor()\n");
exit(1);
t += NR_END;
t -= nrl;
/* allocate pointers to rows and set pointers to them */
t[nrl]=(float **) malloc((sizet)((nrowncol+NREND)*sizeof(float)));
if (!t[nrl])
fprintf(stderr,"allocation failure 2 in f3tensor()\n");
exit(1);
t[nrl] += NR_END;
t[nrl] -= ncl;
/* allocate rows and set pointers to them */
t[nrl][ncl]=(float *) malloc((sizet)((nrowncol*ndep+NREND)sizeof(float)));
if (!t[nrl][ncl])
fprintf(stderr,"allocation failure 3 in f3tensor()\n");
exit(1);
t[nrl][ncl] += NR_END;
t[nrl][ncl] -= ndl;
for(j=ncl1;j<=nch;j+) t[nrl][j]=t[nrl][j-1]+ndep;
for(i=nrl1;i<=nrh;i+) {
t=t[i-1]+ncol;
t[ncl]=t[i-1][ncl]+ncol*ndep;
for(j=ncl1;j<=nch;j+) t[j]=t[j-1]+ndep;
/* return pointer to array of pointers to rows */
return t;
void free_matrix(float **m,long nrl,long nrh,long ncl,long nch)
free((char*) (m[nrl]+ncl-1));
free((char*) (m+nrl-1));
void free_f3tensor(float *t,long nrl,long nrh,long ncl,long nch,long ndl,
long ndh)
free((char*) (t[nrl][ncl]+ndl-1));
free((char*) (t[nrl]+ncl-1));
free((char*) (t+nrl-1));
// Function to replace data by its ndim-dimensional discrete Fourier transform,
// if isign is input as 1. nn[1..ndim] is an integer array containing the
// lengths of each dimension (number of complex values), which MUST be all
// powers of 2. data is a real array of length twice the product of these
// lengths, in which the data are stored as in a multidimensional complex
// array: real and imaginary parts of each element are in consecutive
// locations, and the rightmost index of the array increases most rapidly as
// one proceeds along data. For a two-dimensional array, this is equivalent to
// storing the arrays by rows. If isign is input as -1, data is replaced by its
// inverse transform times the product of the lengths of all dimensions.
void fourn(float data[],unsigned long nn[],int ndim,int isign)
int idim;
unsigned long i1,i2,i3,i2rev,i3rev,ip1,ip2,ip3,ifp1,ifp2;
unsigned long ibit,k1,k2,n,nprev,nrem,ntot;
double tempi,tempr;
float theta,wi,wpi,wpr,wr,wtemp;
for (ntot=1, idim=1; idim<=ndim; idim++)
ntot *= nn[idim];
nprev = 1;
for (idim=ndim; idim>=1; idim--)
n = nn[idim];
nrem = ntot/(n*nprev);
ip1=nprev << 1;
ip2 = ip1*n;
ip3 = ip2*nrem;
i2rev = 1;
for (i2=1; i2<=ip2; i2+=ip1)
if (i2 < i2rev)
for (i1=i2; i1<=i2+ip1-2; i1+=2)
for (i3=i1; i3<=ip3; i3+=ip2)
i3rev = i2rev+i3-i2;
SWAP(data[i3],data[i3rev]);
SWAP(data[i31],data[i3rev1]);
ibit = ip2>>1;
while (ibit>=ip1 && i2rev>ibit)
i2rev -= ibit;
ibit >>= 1;
i2rev += ibit;
ifp1 = ip1;
while (ifp1 < ip2)
ifp2 = ifp1 << 1;
theta = 2isignPI/(ifp2/ip1);
wtemp = sin(0.5*theta);
wpr = -2.0wtempwtemp;
wpi = sin(theta);
wr = 1.0;
wi = 0.0;
for (i3=1; i3<=ifp1; i3+=ip1)
for (i1=i3; i1<=i3+ip1-2; i1+=2)
for (i2=i1; i2<=ip3; i2+=ifp2)
k1 = i2;
k2 = k1+ifp1;
tempr = (float)wrdata[k2]-(float)widata[k2+1];
tempi = (float)wrdata[k21](float)widata[k2];
data[k2] = data[k1]-tempr;
data[k2+1] = data[k1+1]-tempi;
data[k1] += tempr;
data[k1+1] += tempi;
wr = (wtemp=wr)wpr-wiwpi+wr;
wi = wiwprwtempwpiwi;
ifp1 = ifp2;
nprev *= n;
// Function to calculate a three-dimensional Fourier transform of
// data[1..nn1][1..nn2][1..nn3] (where nn1=1 for the case of a logically two-
// dimensional array). This routine returns (for isign=1) the complex fast
// Fourier transform as two complex arrays: On output, data contains the zero
// and positive frequency values of the third frequency component, while
// speq[1..nn1][1..2*nn2] contains the Nyquist critical frequency values of the
// third frequency component. First (and second) frequency components are
// stored for zero, positive, and negative frequencies, in standard wrap-around
// order. See Numerical Recipes for description of how complex values are
// arranged. For isign=-1, the inverse transform (times nn1nn2nn3/2 as a
// constant multiplicative factor) is performed, with output data (viewed as
// real array) deriving from input data (viewed as complex) and speq. For
// inverse transforms on data not generated first by a forward transform, make
// sure the complex input data array satisfies property 12.5.2 from NR. The
// dimensions nn1, nn2, nn3 must always be integer powers of 2.
void rlft3(float *data,float **speq,unsigned long nn1,unsigned long nn2,
unsigned long nn3,int isign)
double theta,wi,wpi,wpr,wr,wtemp;
float c1,c2,h1r,h1i,h2r,h2i;
unsigned long i1,i2,i3,j1,j2,j3,nn[4],ii3;
if (1+&data[nn1][nn2][nn3]-&data[1][1][1] != nn1nn2nn3)
fprintf(stderr,
"rlft3: problem with dimensions or contiguity of data array\n");
exit(1);
c1 = 0.5;
c2 = -0.5*isign;
theta = 2isign(PI/nn3);
wtemp = sin(0.5*theta);
wpr = -2.0wtempwtemp;
wpi = sin(theta);
nn[1] = nn1;
nn[2] = nn2;
nn[3] = nn3 >> 1;
// Case of forward transform. Here is where most all of the compute time is
// spent. Extend data periodically into speq.
if (isign == 1)
fourn(&data[1][1][1]-1,nn,3,isign);
for (i1=1; i1<=nn1; i1++)
for (i2=1, j2=0; i2<=nn2; i2++)
speq[i1][++j2] = data[i1][i2][1];
speq[i1][++j2] = data[i1][i2][2];
for (i1=1; i1<=nn1; i1++)
// Zero frequency is its own reflection; otherwise locate corresponding
// negative frequency in wrap-around order.
j1 = (i1 != 1 ? nn1-i1+2 : 1);
// Initialize trigonometric recurrence.
wr = 1.0;
wi = 0.0;
for (ii3=1, i3=1; i3<=(nn3>>2)+1; i3+,ii3=2)
for (i2=1; i2<=nn2; i2++)
if (i3 == 1)
j2 = (i2 != 1 ? ((nn2-i2)<<1)+3 : 1);
h1r = c1*(data[i1][i2][1]+speq[j1][j2]);
h1i = c1*(data[i1][i2][2]-speq[j1][j2+1]);
h2i = c2*(data[i1][i2][1]-speq[j1][j2]);
h2r = -c2*(data[i1][i2][2]speq[j1][j21]);
data[i1][i2][1] = h1r+h2r;
data[i1][i2][2] = h1i+h2i;
speq[j1][j2] = h1r-h2r;
speq[j1][j2+1] = h2i-h1i;
else
j2 = (i2 != 1 ? nn2-i2+2 : 1);
j3 = nn3+3-(i3<<1);
h1r = c1*(data[i1][i2][ii3]+data[j1][j2][j3]);
h1i = c1*(data[i1][i2][ii31]-data[j1][j2][j31]);
h2i = c2*(data[i1][i2][ii3]-data[j1][j2][j3]);
h2r = -c2*(data[i1][i2][ii31]+data[j1][j2][j31]);
data[i1][i2][ii3] = h1r+wrh2r-wih2i;
data[i1][i2][ii3+1] = h1iwrh2iwih2r;
data[j1][j2][j3] = h1r-wrh2r+wih2i;
data[j1][j2][j3+1] = -h1iwrh2iwih2r;
// Do the recurrence.
wr = (wtemp=wr)wpr-wiwpi+wr;
wi = wiwprwtempwpiwi;
// Case of reverse transform.
if (isign == -1)
fourn(&data[1][1][1]-1,nn,3,isign);
// Function to perform Gaussian blur.
void gaussianblur(void)
float **blur,***conv,***pop,**speqblur,**speqconv,*speqpop;
int i,j,p,q;
blur = d3tensor(1,1,1,lx,1,ly);
conv = d3tensor(1,1,1,lx,1,ly);
pop = d3tensor(1,1,1,lx,1,ly);
speqblur = dmatrix(1,1,1,2*lx);
speqconv = dmatrix(1,1,1,2*lx);
speqpop = dmatrix(1,1,1,2*lx);
// Fill population and convolution matrix.
for (i=1; i<=lx; i++) for (j=1; j<=ly; j++)
if (i > lx/2) p = i-1-lx;
else p = i-1;
if (j > ly/2) q = j-1-ly;
else q = j-1;
pop[1][j] = rho_0[i-1][j-1];
conv[1][j] = 0.5*
(erf((p+0.5)/(sqrt(2.0)(SIGMApow(SIGMAFAC,nblurs))))-
erf((p-0.5)/(sqrt(2.0)(SIGMA*pow(SIGMAFAC,nblurs)))))
(erf((q+0.5)/(sqrt(2.0)(SIGMApow(SIGMAFAC,nblurs))))-
erf((q-0.5)/(sqrt(2.0)(SIGMA*pow(SIGMAFAC,nblurs)))))/(lxly);
// Fourier transform.
rlft3(pop,speqpop,1,lx,ly,1);
rlft3(conv,speqconv,1,lx,ly,1);
// Multiply pointwise.
for (i=1; i<=lx; i++)
for (j=1; j<=ly/2; j++)
blur[1][2*j-1] =
pop[1][2j-1]*conv[1][2j-1]-
pop[1][2j]*conv[1][2j];
blur[1][2*j] =
pop[1][2j]*conv[1][2j-1]+
pop[1][2j-1]*conv[1][2j];
for (i=1; i<=lx; i++)
speqblur[1][2*i-1] =
speqpop[1][2i-1]*speqconv[1][2i-1]-
speqpop[1][2i]*speqconv[1][2i];
speqblur[1][2*i] =
speqpop[1][2i]*speqconv[1][2i-1]+
speqpop[1][2i-1]*speqconv[1][2i];
// Backtransform.
rlft3(blur,speqblur,1,lx,ly,-1);
// Write to rho_0.
for (i=1; i<=lx; i++) for (j=1; j<=ly; j++) rho_0[i-1][j-1] = blur[1][j];
free_f3tensor(blur,1,1,1,lx,1,ly);
free_f3tensor(conv,1,1,1,lx,1,ly);
free_f3tensor(pop,1,1,1,lx,1,ly);
free_matrix(speqblur,1,1,1,2*lx);
free_matrix(speqconv,1,1,1,2*lx);
free_matrix(speqpop,1,1,1,2*lx);
// Function to initialize rho_0. The original density is blurred with width
// SIGMA*pow(SIGMAFAC,nblurs).
void initcond(void)
float maxpop;
int i,j;
// Reconstruct population density.
coscosft(rho_0,-1,-1);
// There must not be negative densities.
for (i=0; i<lx; i++) for (j=0; j<ly; j++) if (rho_0[j]<-1e10)
fprintf(stderr,"ERROR: Negative density in DENSITYFILE.\n");
exit(1);
// Perform Gaussian blur.
printf("Gaussian blur ...\n");
gaussianblur();
// Find the mimimum density. If it is very small suggest an increase in
// SIGMA.
minpop = rho_0[0][0];
maxpop = rho_0[0][0];
for (i=0; i<lx; i++) for (j=0; j<ly; j++) if (rho_0[j]<minpop)
minpop = rho_0[j];
for (i=0; i<lx; i++) for (j=0; j<ly; j++) if (rho_0[j]>maxpop)
maxpop = rho_0[j];
if (0<minpop && minpop<1e-8*maxpop)
fprintf(stderr,"Minimimum population very small (%f). Integrator\n",
minpop);
fprintf(stderr,
"will probably converge very slowly. You can speed up the\n");
fprintf(stderr,"process by increasing SIGMA to a value > %f.\n",
SIGMA*pow(SIGMAFAC,nblurs));
// Replace rho_0 by cosine Fourier transform in both variables.
coscosft(rho_0,1,1);
// Function to calculate the velocity field
void calcv(float t)
int j,k;
// Fill rho with Fourier coefficients.
for (j=0; j<=lx; j++) for (k=0; k<=ly; k++)
rho[j][k] = exp(-((PIj/lx)*(PI*j/lx)+(PI*k/ly)*(PI*k/ly))*t)rho_0[j][k];
// Calculate the Fourier coefficients for the partial derivative of rho.
// Store temporary results in arrays gridvx, gridvy.
for (j=0; j<=lx; j++) for (k=0; k<=ly; k++)
gridvx[j][k] = -(PIj/lx)rho[j][k];
gridvy[j][k] = -(PIk/ly)rho[j][k];
// Replace rho by cosine Fourier backtransform in both variables.
coscosft(rho,-1,-1);
// Replace vx by sine Fourier backtransform in the first and cosine Fourier
// backtransform in the second variable.
sincosft(gridvx,-1,-1);
// Replace vy by cosine Fourier backtransform in the first and sine Fourier
// backtransform in the second variable.
cossinft(gridvy,-1,-1);
// Calculate the velocity field.
for (j=0; j<=lx; j++) for (k=0; k<=ly; k++)
gridvx[j][k] = -gridvx[j][k]/rho[j][k];
gridvy[j][k] = -gridvy[j][k]/rho[j][k];
// Function to bilinearly interpolate a two-dimensional array. For higher
// accuracy one could consider higher order interpolation schemes.
float intpol(float **arr,float x,float y)
int gaussx,gaussy;
float deltax,deltay;
// Decompose x and y into an integer part and a decimal.
gaussx = (int)x;
gaussy = (int)y;
deltax = x-gaussx;
deltay = y-gaussy;
// Interpolate.
if (gaussx==lx && gaussy==ly)
return arr[gaussx][gaussy];
if (gaussx==lx)
return (1-deltay)arr[gaussx][gaussy]deltayarr[gaussx][gaussy1];
if (gaussy==ly)
return (1-deltax)arr[gaussx][gaussy]deltaxarr[gaussx1][gaussy];
return (1-deltax)(1-deltay)arr[gaussx][gaussy]+
(1-deltax)deltayarr[gaussx][gaussy1]
deltax(1-deltay)arr[gaussx1][gaussy]
deltaxdeltayarr[gaussx1][gaussy1];
// Function to find the root of the system of equations
// xappr-0.5h*v_x(t+h,xappr,yappr)-x[j][k]-0.5*hvx[j][k]=0,
// yappr-0.5h*v_y(t+h,xappr,yappr)-y[j][k]-0.5*hvy[j][k]=0
// with Newton-Raphson. Returns TRUE after sufficient convergence.
BOOLEAN newt2(float h,float *xappr,float xguess,float *yappr,float yguess,
int j,int k)
float deltax,deltay,dfxdx,dfxdy,dfydx,dfydy,fx,fy;
int gaussx,gaussxplus,gaussy,gaussyplus,i;
// Initial guess.
*xappr = xguess;
*yappr = yguess;
for (i=1; i<=IMAX; i++)
// fx, fy are the left-hand sides of the two equations. Find
// v_x(t+h,xappr,yappr), v_y(t+h,xappr,yappr) by interpolation.
fx = xappr-0.5*h*intpol(gridvx,*xappr,*yappr)-x[j][k]-0.5*hvx[j][k];
fy = yappr-0.5*h*intpol(gridvy,*xappr,*yappr)-y[j][k]-0.5*hvy[j][k];
// Linearly approximate the partial derivatives of fx, fy with a finite
// difference method. More elaborate techniques are possible, but this
// quick and dirty method appears to work reasonably for our purpose.
gaussx = (int)(*xappr);
gaussy = (int)(*yappr);
if (gaussx == lx) gaussxplus = 0;
else gaussxplus = gaussx+1;
if (gaussy == ly) gaussyplus = 0;
else gaussyplus = gaussy+1;
deltax = x[j][k] - gaussx;
deltay = y[j][k] - gaussy;
dfxdx = 1 - 0.5h
((1-deltay)*(gridvx[gaussxplus][gaussy]-gridvx[gaussx][gaussy])+
deltay*(gridvx[gaussxplus][gaussyplus]-gridvx[gaussx][gaussyplus]));
dfxdy = -0.5h
((1-deltax)*(gridvx[gaussx][gaussyplus]-gridvx[gaussx][gaussy])+
deltax*(gridvx[gaussxplus][gaussyplus]-gridvx[gaussxplus][gaussy]));
dfydx = -0.5h
((1-deltay)*(gridvy[gaussxplus][gaussy]-gridvy[gaussx][gaussy])+
deltay*(gridvy[gaussxplus][gaussyplus]-gridvy[gaussx][gaussyplus]));
dfydy = 1 - 0.5h
((1-deltax)*(gridvy[gaussx][gaussyplus]-gridvy[gaussx][gaussy])+
deltax*(gridvy[gaussxplus][gaussyplus]-gridvy[gaussxplus][gaussy]));
// If the current approximation is (xappr,yappr) for the zero of
// (fx(x,y),fy(x,y)) and J is the Jacobian, then we can approximate (in
// vector notation) for |delta|<<1:
// f((xappr,yappr)+delta) = f(xappr,yappr)+J*delta.
// Setting f((xappr,yappr)+delta)=0 we obtain a set of linear equations
// for the correction delta which moves f closer to zero, namely
// J*delta = -f.
// The improved approximation is then x = xappr+delta.
// The process will be iterated until convergence is reached.
if ((fx*fx + fy*fy) < TOLF) return TRUE;
deltax = (fy*dfxdy - fxdfydy)/(dfxdxdfydy - dfxdy*dfydx);
deltay = (fx*dfydx - fydfxdx)/(dfxdxdfydy - dfxdy*dfydx);
if ((deltax*deltax + deltay*deltay) < TOLX) return TRUE;
*xappr += deltax;
*yappr += deltay;
//printf("deltax %f, deltay %f\n",deltax,deltay);
fprintf(stderr,"newt2 failed, increasing sigma to %f.\n",
SIGMA*pow(SIGMAFAC,nblurs));
return FALSE;
// Function to integrate the nonlinear Volterra equation. Returns TRUE after
// the displacement field converged, after MAXINTSTEPS integration steps, or
// if the time exceeds TIMELIMIT.
BOOLEAN nonlinvoltra(void)
BOOLEAN stepsize_ok;
#ifdef DISPLFILE
FILE *displfile = fopen(DISPLFILE);
#endif
float h,maxchange=INFTY,t,vxplus,vyplus,xguess,yguess;
int i,j,k;
do
initcond();
nblurs++;
if (minpop<0.0)
fprintf(stderr,
"Minimum population negative, will increase sigma to %f\n",
SIGMA*pow(SIGMAFAC,nblurs));
while (minpop<0.0);
h = HINITIAL;
t = 0; // Start at time t=0.
// (x[j][k],y[j][k]) is the position for the element that was at position
// (j,k) at time t=0.
for (j=0; j<=lx; j++) for (k=0; k<=ly; k++)
x[j][k] = j;
y[j][k] = k;
calcv(0.0);
// (gridvx[j][k],gridvy[j][k]) is the velocity at position (j,k).
// (vx[j][k],vy[j][k]) is the velocity at position (x[j][k],y[j][k]).
// At t=0 they are of course identical.
for (j=0; j<=lx; j++) for (k=0; k<=ly; k++)
vx[j][k] = gridvx[j][k];
vy[j][k] = gridvy[j][k];
i = 1; // i counts the integration steps.
// Here is the integrator.
do
stepsize_ok = TRUE;
calcv(t+h);
for (j=0; j<=lx; j++) for (k=0; k<=ly; k++)
// First take a naive integration step. The velocity at time t+h for
// the element [j][k] is approximately
// v(th,x[j][k]+hvx[j][k],y[j][k]hvy[j][k]).
// The components, call them vxplus and vyplus, are interpolated from
// gridvx and gridvy.
vxplus = intpol(gridvx,x[j][k]hvx[j][k],y[j][k]hvy[j][k]);
vyplus = intpol(gridvy,x[j][k]hvx[j][k],y[j][k]hvy[j][k]);
// Based on (vx[j][k],vy[j][k]) and (vxplus,vyplus) we expect the
// new position at time t+h to be:
xguess = x[j][k] + 0.5h(vx[j][k]+vxplus);
yguess = y[j][k] + 0.5h(vy[j][k]+vyplus);
// Then we make a better approximation by solving the two nonlinear
// equations:
// xappr[j][k]-0.5hv_x(t+h,xappr[j][k],yappr[j][k])-
// x[j][k]-0.5hvx[j][k]=0,
// yappr[j][k]-0.5hv_y(t+h,xappr[j][k],yappr[j][k])-
// y[j][k]-0.5hvy[j][k]=0
// with Newton-Raphson and (xguess,yguess) as initial guess.
// If newt2 fails to converge, exit nonlinvoltra.
if (!newt2(h,&xappr[j][k],xguess,&yappr[j][k],yguess,j,k))
return FALSE;
// If the integration step was too large reduce the step size.
if ((xguess-xappr[j][k])*(xguess-xappr[j][k])+
(yguess-yappr[j][k])*(yguess-yappr[j][k]) > TOLINT)
if (h<MINH)
fprintf(stderr,
"Time step below %f, increasing SIGMA to %f\n",
h,SIGMA*pow(SIGMAFAC,nblurs));
nblurs++;
return FALSE;
h /= 10;
stepsize_ok = FALSE;
break;
if (!stepsize_ok) continue;
else
t += h;
maxchange = 0.0; // Monitor the maximum change in positions.
for (j=0; j<=lx; j++) for (k=0; k<=ly; k++)
if ((x[j][k]-xappr[j][k])*(x[j][k]-xappr[j][k])+
(y[j][k]-yappr[j][k])*(y[j][k]-yappr[j][k]) > maxchange)
maxchange =
(x[j][k]-xappr[j][k])*(x[j][k]-xappr[j][k])+
(y[j][k]-yappr[j][k])*(y[j][k]-yappr[j][k]);
x[j][k] = xappr[j][k];
y[j][k] = yappr[j][k];
vx[j][k] = intpol(gridvx,xappr[j][k],yappr[j][k]);
vy[j][k] = intpol(gridvy,xappr[j][k],yappr[j][k]);
h *= 1.2; // Make the next integration step larger.
if (i%10==0) printf("time %f\n",t);
i++;
} while (i<MAXINTSTEPS && t<TIMELIMIT && maxchange>CONVERGENCE);
if (maxchange>CONVERGENCE)
fprintf(stderr,
"WARNING: Insufficient convergence within %i steps, time %f.\n",
MAXINTSTEPS,TIMELIMIT);
#ifdef DISPLFILE
// Write displacement field to file.
fprintf(displfile,"time %f\nminx %f\nmaxx %f\nminy %f\nmaxy %f\n",
t,minx,maxx,miny,maxy);
fprintf(displfile,"sigma %f\n",SIGMA*pow(SIGMAFAC,nblurs-1));
fprintf(displfile,"background %f\nlx\nly\n\n",0,lx,ly);
for (j=0; j<=lx; j++) for (k=0; k<=ly; k++)
fprintf(displfile,"j %i, k %i, x %f, y %f\n",j,k,x[j][k],y[j][k]);
fclose(displfile);
#endif
return TRUE;
// Function to transform points according to displacement field.
POINT transf(POINT p)
float deltax,deltay,den,t,u;
int gaussx,gaussy;
POINT a,b,c,d,ptr;
p.x = (p.x-minx)*lx/(maxx-minx);
p.y = (p.y-miny)*ly/(maxy-miny);
gaussx = (int)p.x;
gaussy = (int)p.y;
if (gaussx<0 || gaussx>lx || gaussy<0 || gaussy>ly)
fprintf(stderr,"ERROR: Coordinate limits exceeded in transf.\n");
exit(1);
deltax = p.x - gaussx;
deltay = p.y - gaussy;
// The transformed point is the intersection of the lines:
// (I) connecting
// (1-deltax)(x,y[gaussx][gaussy])deltax(x,y[gaussx1][gaussy])
// and
// (1-deltax)(x,y[gaussx][gaussy1])+deltax(x,y[gaussx+1][gaussy1])
// (II) connecting
// (1-deltay)(x,y[gaussx][gaussy])deltay(x,y[gaussx][gaussy1])
// and
// (1-deltay)(x,y[gaussx1][gaussy])+deltay(x,y[gaussx+1][gaussy1]).
// Call these four points a, b, c and d.
a.x = (1-deltax)*x[gaussx][gaussy] + deltax*x[gaussx+1][gaussy];
a.y = (1-deltax)*y[gaussx][gaussy] + deltax*y[gaussx+1][gaussy];
b.x = (1-deltax)*x[gaussx][gaussy+1] + deltax*x[gaussx1][gaussy1];
b.y = (1-deltax)*y[gaussx][gaussy+1] + deltax*y[gaussx1][gaussy1];
c.x = (1-deltay)*x[gaussx][gaussy] + deltay*x[gaussx][gaussy+1];
c.y = (1-deltay)*y[gaussx][gaussy] + deltay*y[gaussx][gaussy+1];
d.x = (1-deltay)*x[gaussx+1][gaussy] + deltay*x[gaussx1][gaussy1];
d.y = (1-deltay)*y[gaussx+1][gaussy] + deltay*y[gaussx1][gaussy1];
// Solve the vector equation a+t(b-a) = c+u(d-c) for the scalars t, u.
if (fabs(den=(b.x-a.x)(c.y-d.y)+(a.y-b.y)(c.x-d.x))<1e-12)
fprintf(stderr,"ERROR: Transformed area element has parallel edges.\n");
exit(1);
t = ((c.x-a.x)(c.y-d.y)+(a.y-c.y)(c.x-d.x))/den;
u = ((b.x-a.x)(c.y-a.y)+(a.y-b.y)(c.x-a.x))/den;
if (t<-1e-3|| t>1+1e-3 || u<-1e-3 || u>1+1e-3)
fprintf(stderr,"WARNING: Transformed area element non-convex.\n");
ptr.x = (1-(a.x+t(b.x-a.x))/lx)minx + ((a.x+t(b.x-a.x))/lx)maxx;
ptr.y = (1-(a.y+t(b.y-a.y))/ly)miny + ((a.y+t(b.y-a.y))/ly)maxy;
return ptr;
// Function to read spatial features from user-specified file and map to
// cartogram.
void cartogram(void)
char id[LINELENGTH],line[LINELENGTH];
FILE infile,outfile;
float xcoord,ycoord;
POINT p;
infile = fopen(MAPGENFILE);
outfile = fopen(CARTGENFILE,"w");
while (!readline(line,infile))
if (sscanf(line,"%s %f %f",&id,&xcoord,&ycoord)==3)
p.x = xcoord;
p.y = ycoord;
p = transf(p);
fprintf(outfile,"%s %f %f\n",id,p.x,p.y);
else if (sscanf(line,"%f %f",&xcoord,&ycoord)==2)
p.x = xcoord;
p.y = ycoord;
p = transf(p);
fprintf(outfile,"%f %f\n",p.x,p.y);
else
sscanf(line,"%s",&id);
fprintf(outfile,"%s\n",id);
fclose(infile);
fclose(outfile);
main(void)
BOOLEAN n;
char c;
FILE genfile,psfile = fopen(MAP2PS);
float oldlx,oldly,oldmaxx,oldmaxy,oldminx,oldminy,totarea;
int i,polyctr,regctr;
// Read the polygon coordinates.
if ((genfile = fopen(MAPGENFILE)) == NULL)
fprintf(stderr,"ERROR: Cannot find MAPGENFILE\n");
exit(1);
countpoly(genfile);
fclose(genfile);
genfile = fopen(MAPGENFILE);
countcorn(genfile);
fclose(genfile);
genfile = fopen(MAPGENFILE);
readcorn(genfile);
fclose(genfile);
makeregion();
printf("%i polygon(s), %i region(s)\n",npoly,nregion);
printf("lx=%i, ly=%i\n",lx,ly);
// Calculate total area.
//totarea = 0.0;
//for (regctr=0; regctr<nregion; regctr++)
// printf("region %i has area %f, contains %i polygons\n",regionid[regctr],
// regionarea(nregcorn[regctr],regcorn[regctr]),npolyinreg[regctr]);
// totarea += regionarea(nregcorn[regctr],regcorn[regctr]);
//printf("totarea = %f\n",totarea);
// Make map.
pspicture(psfile);
fclose(psfile);
// Allocate memory for arrays.
gridvx = (float*)malloc((lx+1)*sizeof(float));
gridvy = (float*)malloc((lx+1)*sizeof(float));
rho = (float*)malloc((lx+1)*sizeof(float));
rho_0 = (float*)malloc((lx+1)*sizeof(float));
vx = (float*)malloc((lx+1)*sizeof(float));
vy = (float*)malloc((lx+1)*sizeof(float));
x = (float*)malloc((lx+1)*sizeof(float));
xappr = (float*)malloc((lx+1)*sizeof(float));
y = (float*)malloc((lx+1)*sizeof(float));
yappr = (float*)malloc((lx+1)*sizeof(float));
within = (int*)malloc((lx+1)*sizeof(int));
for (i=0; i<=lx; i++)
gridvx = (float)malloc((ly+1)sizeof(float));
gridvy = (float)malloc((ly+1)sizeof(float));
rho = (float)malloc((ly+1)sizeof(float));
rho_0 = (float)malloc((ly+1)sizeof(float));
vx = (float)malloc((ly+1)sizeof(float));
vy = (float)malloc((ly+1)sizeof(float));
x = (float)malloc((ly+1)sizeof(float));
xappr = (float)malloc((ly+1)sizeof(float));
y = (float)malloc((ly+1)sizeof(float));
yappr = (float)malloc((ly+1)sizeof(float));
within = (int)malloc((ly+1)sizeof(int));
// Digitize the density.
bboxes();
interior();
digdens();
// Solve the diffusion equation.
do n = nonlinvoltra(); while (!n);
// Print cartogram generate file.
cartogram();
// Read the transformed polygon coordinates.
oldlx = lx;
oldly = ly;
oldmaxx = maxx;
oldmaxy = maxy;
oldminx = minx;
oldminy = miny;
genfile = fopen(CARTGENFILE,"r");
countpoly(genfile);
fclose(genfile);
genfile = fopen(CARTGENFILE,"r");
countcorn(genfile);
fclose(genfile);
lx = oldlx;
ly = oldly;
maxx = oldmaxx;
maxy = oldmaxy;
minx = oldminx;
miny = oldminy;
genfile = fopen(CARTGENFILE,"r");
readcorn(genfile);
fclose(genfile);
makeregion();
// Make cartogram
psfile = fopen(CART2PS);
pspicture(psfile);
fclose(psfile);
The part of the code where the bus error occurs is this:
void interior(void)
int i,inhowmanyregions,inregion[2],j,k,l,m,n,regctr;
// Initialize within[][]. -1 means outside all regions.
for (i=0; i<=lx; i++) for (j=0; j<=ly; j++) within[j] = -1;
// Fill within[][].
for (i=0; i<nregion; i++) for (j=0; j<npolyinreg; j++)
for (k=0, n=npolycorn[polyinreg[j]]-1;
k<npolycorn[polyinreg[j]]; n=k++)
for (l=(int)ceil(MIN(polycorn[polyinreg[j]][k-1].y,
polycorn[polyinreg[j]][k].y));
l<MAX(polycorn[polyinreg[j]][k-1].y,
polycorn[polyinreg[j]][k].y); l++)
for (m=(int)floor(bbminx[polyinreg[j]]);
m<(polycorn[polyinreg[j]][n].x-
polycorn[polyinreg[j]][k].x)*
(l-polycorn[polyinreg[j]][k].y)/
(polycorn[polyinreg[j]][n].y-
polycorn[polyinreg[j]][k].y)+
polycorn[polyinreg[j]][k].x;
m++)
within[m][l] = i-within[m][l]-1;
I really have no idea what is going on. Can anyone help?
Thanks,
mooseguyorangekay wrote:
That is absolutely unreadable.
I agree completely. How about also providing a link to a set of input files so that we could actually run the code ourselves? Otherwise, there is no chance to debug the source code, it is just a mess.
You might have better luck with an older version of the file. To quote the comments:
// Modified on March 31, 2005. Initialized maxchange in nonlinvoltra() as
// INFTY. Replaced crnmbr() by a similar, but faster routine interior().
// Many thanks to Stuart Anderson for pointing out this shortcut.
I suspect that the "interior" function is just plain incorrect. It doesn't matter if it runs on some other OS. Something about it is wrong and the code is so cryptic that it can't be deciphered. -
Songs don't show up in iTunes ... but iTunes still thinks they're there ...
I've lost songs. They don't show up in a search, they don't show up when I scroll through all my songs, and they don't show up in the browser, but when I try to import them from the original CDs, iTunes asks me if I want to replace the files. And they're in my iTunes file directory (I keep it organized). So, they're where they're supposed to be. I've tried to add them to the library, and they remain invisible. It's the oddest thing.
Does anyone else have experience with this? What would you suggest?
Thanks,
BrianThis might be a quick and dirty method.
We're trying to force iTunes to rebuild properly.
With iTunes not running. Make a copy of the library database file (iTunes Library).
Try deleting the iTunes Library file. Start iTunes. Does this then show the missing tracks? To get the original playlists back you can import from the original xml file that you saved.
If you need to get back to the start point just delete the newly created database and .xml files and go back to the originals.
Powermac G5 DP 2.3 GHz Mac OS X (10.4.7) 4.5 GByte RAM -
How do I synce ipod 5th with ipod 4
I would like to set up (or "sync") an ipod 5th gen exactly as my ipod 4th gen,while keeping both active. How is this done while still setting it up as a new ipod?,(Which it is!).
Thank you!.
But there are many gigs of stuff on my ipod (4th g) that are Not on my new iMac,is syncing them(4th with 5th g ipods),still possible?. I really dont want to spend 10's of hours re-downloading all my audio books
,music,etc,(NOT puschased on itunes!). Just a quick "export","Copy" method or something?.I apologize for being so Numb! lol.
Message was edited by: ElijahDan
Message was edited by: ElijahDan -
How to change the owner of a GPO using command line/script? - More than 200!
I have more than 200 GPOs on the AD DOmain
Half of the GPos were created by sveeral different people or are owned by the domain admins
How can I change all of then, to a new owner, using the more "quick and easy" method?
there a tool/utility for that? (like icacls.exe/subinacl.exe?)
There is a VBS function or PS cmdlet?Hi,
How is it going? Are the suggestions provided by the above replied helpful? If you need further help regarding this issue, please don’t hesitate to let us know.
Besides, for scripts, in order to get better help, we can ask for suggestions in the following scripting forums.
The Official Scripting Guys Forum
http://social.technet.microsoft.com/Forums/scriptcenter/en-US/home?forum=ITCG
Windows PowerShell
http://social.technet.microsoft.com/Forums/windowsserver/en-US/home?forum=winserverpowershell
TechNet Subscriber Support
If you are TechNet Subscription user and have any feedback on our support quality, please send your feedback here.
Best regards,
Frank Shen -
Expression help needed - control speed of a pan via a slider
I've done this in the past but can't locate my old project, and my head is throbbing from last nite.....
I'd like to apply an expression to my null's position. I want it to pan horizontally at a speed specified with a slider control. I'd like it to be able to start, stop, and then continue. Doesn't need to ease in, but it'd be nice.
Speed = effect("Speed")("Slider");
OffsetX = effect("Offset")("Point")[0];
fps = 24;
x = OffsetX - (Speed * time * fps);
[x,243]
My problem multiplying "speed" with time means that when it stops (speed=0), it returns to the start position.... I need it to stay in place, and then continue when I animate the speed value back up.
Please help my hungover brain....Here's a quick and dirty method:
>v = effect("Velocity")("Point");
vSum = 0;
for(t = 0; t <= time; t+=thisComp.frameDuration) vSum += v.valueAtTime(t);
value+vSum*thisComp.frameDuration
Unfortunately, it is pretty slow to calculate, and just gets slower the further you go down the timeline. Also, it doesn't actually produce continuous motion, so it doesn't play well with motion blur.
I'm working on a much more efficient expression that does work with motion blur, but I can't seem to get it to behave once you get past the last keyframe. If I have a breakthrough, I'll post it. -
IPod Songs Don't Show Up in iTunes After iTunes 6.0.2 "Upgrade"
After installing iLife '06, and the iTunes 6.0.2 "upgrade" that came with it, the contents of my 4th Gen. 40 Gb iPod don't show up in iTunes. The iPod mounts on the Desktop OK, and even shows up in the Source list in iTunes 6.0.2. And I can unmount the iPod by clicking on the little up arrow icon in iTunes. But iTunes reports only 919.2 Mb used and 36.33 Gb free in the iPod.
I tried copying a song from my iTunes Library to the iPod, and it showed up in iTunes. But when I unmounted, then remounted, the iPod, it no longer showed in iTunes. It was on the iPod, however.
I tried upgrading to the latest iPod software (iPod Updater 2006-01-10) but that didn't help.
I ran Software Update and it didn't find any software that needed updating.
I repaired disk permissions and Shutdown, then powered back up and restarted. Nada.
The iPod mounts fine on my G4 AlBook running iTunes 4.9, and the contents of the iPod are also visible in iTunes 4.9, so I'm pretty sure it's not a problem on the iPod.
Don't know if it matters, but all of the music on my Mac and on the iPod was ripped by iTunes from CDs (that I own).
Anybody else seeing this?
Is there a fix?
TIA,
Scot
G5 2.5 GHz Mac OS X (10.4.4)
G5 2.5 GHz Mac OS X (10.4.2)
G5 2.5 GHz Mac OS X (10.4.2)
G5 2.5 GHz Mac OS X (10.4.4)This might be a quick and dirty method.
We're trying to force iTunes to rebuild properly.
With iTunes not running. Make a copy of the library database file (iTunes Library).
Try deleting the iTunes Library file. Start iTunes. Does this then show the missing tracks? To get the original playlists back you can import from the original xml file that you saved.
If you need to get back to the start point just delete the newly created database and .xml files and go back to the originals.
Powermac G5 DP 2.3 GHz Mac OS X (10.4.7) 4.5 GByte RAM -
Export an XML file from oracle database
plz help me its urgent requirement....could u pls tell me the step by step procedure for following questions...?how to export a data as an XML file from oracle database? is it possible..?
thanks in advance,
Bala. is it possible?
Edited by: user3523292 on Nov 14, 2008 5:45 AMHere's the quick and dirty method using SQL*Plus...
SQL> select * from emp where deptno = 10;
EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO
7782 CLARK MANAGER 7839 09-JUN-81 2450 10
7839 KING PRESIDENT 17-NOV-81 5000 10
7934 MILLER CLERK 7782 23-JAN-82 1300 10
SQL> set markup html on
SQL> select * from emp where deptno = 10;
<br>
<p>
<table border='1' width='90%' align='center' summary='Script output'>
<tr>
<th scope="col">
EMPNO
</th>
<th scope="col">
ENAME
</th>
<th scope="col">
JOB
</th>
<th scope="col">
MGR
</th>
<th scope="col">
HIREDATE
</th>
<th scope="col">
SAL
</th>
<th scope="col">
COMM
</th>
<th scope="col">
DEPTNO
</th>
</tr>
<tr>
<td align="right">
7782
</td>
<td>
CLARK
</td>
<td>
MANAGER
</td>
<td align="right">
7839
</td>
<td>
09-JUN-81
</td>
<td align="right">
2450
</td>
<td align="right">
</td>
<td align="right">
10
</td>
</tr>
<tr>
<td align="right">
7839
</td>
<td>
KING
</td>
<td>
PRESIDENT
</td>
<td align="right">
</td>
<td>
17-NOV-81
</td>
<td align="right">
5000
</td>
<td align="right">
</td>
<td align="right">
10
</td>
</tr>
<tr>
<td align="right">
7934
</td>
<td>
MILLER
</td>
<td>
CLERK
</td>
<td align="right">
7782
</td>
<td>
23-JAN-82
</td>
<td align="right">
1300
</td>
<td align="right">
</td>
<td align="right">
10
</td>
</tr>
</table>
<p>
SQL>which you can spool to a file. -
Help needed in developing midlet to communicate with pc application
hi , i am trying to develop a j2me application for mobile phone and a j2se application for pc
the midlet can send messages to my pc application, upon recieve the message, the pc application will read the message and store it into a database. any1 have any idea, samples or reference to see how to do this? thanks manyThere are a couple of ways you could do this. Bluetooth communication is available on a few J2ME devices, so you could do it through that. Or you could set up a servlet on the J2SE app end and send the data over the internet (check out HttpConnection). I'm not sure of any other quick and easy methods.
-
Links working in Safari but not Firefox
Hi friends,
I'm hoping someone can help this confused amateur (aka me) get my website to work correctly. The site works fine in Safari -- but in Firefox, the internal links do not work (external links are OK). I suspect it has something to do with defining the pathways within the directory, but beyond that I'm lost.
Does anyone have a suggestion? I'm pretty sure it's a simple fix for someone who know what they're doing
Here's the site: www.thefourglobaltruths.com
The problematic links are under the banner, specifically "about the author," "links," "schedule," and "interviews."
BTW, I'm using a Macbook Pro, 10.6.8, and CS5...if any of that matters.
Many thanks in advance!Is this website around 10+ years old?
It contains ancient, invalid code long past due for an update. It's a bit of a time machine.
Have you heard of validating code? It's a quick and easy method of checking if your code can be read properly by a browser.
If you put the address of the author page into http://validator.w3.org/
You will get 26 errors
http://validator.w3.org/check?uri=http%3A%2F%2Fwww.thefourglobaltruths.com%2Fauthor.html&c harset=%28detect+automatically%29&doctype=Inline&group=0
Two of the crucial errors preventing this page from appearing are (in Code View in DW)
Line 8
<title>The Four Global Truths: About the Author
should read
<title>The Four Global Truths: About the Author</title>
and
Line 19-21
</style>
</head>
</head>
<body>
should read
</style>
</head>
<body> -
Cropping Images with Clipping Masks | Learn Illustrator CS6 | Adobe TV
In this video you will learn a quick and easy method for cropping images in Adobe Illustrator CS6 and CS5. Using clipping masks allows you to retain the area of the image you cropped out as well as modify the clipping path later on.
http://adobe.ly/V8tW7SIs there a way to make a clipping mask for a many-layered image without collapsing all the layers? I'd love to keep my image as is (it's quite complex), I just want to crop the entire thing.
thanks!
Maybe you are looking for
-
G4 MDD wont boot past logo, or to cd. Please help!
The power was cut as I was deleting my shared folder which had about 13gb worth of data on it. The process had just started. I tried to boot back up I hear the chime and then it goes to the apple logo then the whole thing just shuts down after a few
-
My itunes can`t recognize my iphone,please i need help..the error code is ( 1602 )
please help..i tried everything but it doesn`t work..
-
Hi, Is there a report in Material Ledger showing: - consumption of all raw materials in actual price in selected month - value of production of Finished Goods in actual prices in selected month Is there a way to see the value of production of Finishe
-
How to turn on photo stream in iPhoto
After opening iPhoto and selcting Photo Stream the instructions say that there should be a Turn on Photo Stream on the right. I can't see it. What am I doing wrong?
-
Getting list header size flexible
Hi, How to make the column headers in lists flexible and/or auto adjusted to the size of the row data? Currently my columns are all the same size, very disturbing when you can't read all thing in. I would also like a horizontal scroll bar, is there o