Syfran.com

When performance matters

syfran — Thu, 04 Mar 2010 17:56:36 +0000

Linked Lists, Double Linked Lists, Arrays, Queues, Stacks… the data structures go on and on, but don’t they all do pretty much the same thing? If you’re like me you probably don’t worry about which you use most the time. Just use whatever is convenient at the time, in C-like languages this will usually be an array, in Functional Languages a List (I believe they use linked lists by default).

Usually the defaults are fine, I mean how much difference could it really make? I didn’t think it would be too much, maybe a couple seconds until my recent experience with Project Euler 78.

Let p(n) represent the number of different ways in which n coins can be separated into piles. For example, five coins can separated into piles in exactly seven different ways, so p(5)=7.
OOOOO
OOOO O
OOO OO
OOO O O
OO OO O
OO O O O
O O O O O

Find the least value of n for which p(n) is divisible by one million.

After a lot of research I came across the pentagonal number theorem. (I’m not one of those people who think you need to derive everything yourself, the only thing I care about is that I understand exactly what I’m doing)

The formulation of Euler’s generating function is a special case of a q-Pochhammer symbol and is similar to the product formulation of many modular forms, and specifically the Dedekind eta function. It can also be used in conjunction with the pentagonal number theorem to derive a recurrence for the partition function stating that:

p(k) = p(k − 1) + p(k − 2) − p(k − 5) − p(k − 7) + p(k − 12) + p(k − 15) − p(k − 22) − …

where the sum is taken over all generalized pentagonal numbers of the form ½n(3n − 1), for n running over positive and negative integers: successively taking n = 1, -1, 2, -2, 3, -3, 4, -4, …, generates the values 1, 2, 5, 7, 12, 15, 22, 26, 35, 40, 51, …. The signs in the summation continue to alternate +, +, −, −, +, +, …

source:wikipedia

I’m far from a mathematician so I had to dig around to understand exactly what was happening here (including looking at other code) and came up with the following program.

module Euler78
where

pent = let p n = (n * ((3*n) - 1)) `div` 2
       in map (p) (concat [[i , (-i)] | i < - [1..]])

p = let part 0 = 1
        part 1 = 1
        part n = sum $ zipWith (*) [p (n-k) | k <- takeWhile (<=n) pent] (cycle
    in ((map (part) [0..]) !!)

main78 :: IO ()
main78 = do print $ head $ filter (\x -> (p x) `mod` 10^6 == 0) [1..]

> ghc --make Main.hs -o out/e78
> time out/e78
      real    277m16.556s
      user    276m26.416s
      sys     0m41.162s

(Main.hs contains code that executes main78, and yes I know it’s not the best configuration)

277 minutes!!!

I know this was the most efficient algorithm for finding the partitions so why was it taking 3 and 1/2 hours?? It got the right answer but it should be under 1min. Curious I downloaded the source code for another solution in Haskell (should look similar, It is what I used to wrap my head around what Wikipedia was saying). Here is the
source.

> ghc --make Main.hs
> time ./Main
     real    0m49.656s
     user    0m49.432s
     sys     0m0.134s

Looks like I really screwed that up. Comparing the source the only large difference is the memoization of the partitions, their code imports Array just to store the results whereas mine uses a list. By default Haskell uses a linked list. To figure out where the time difference is coming from lets look at the Wikipedia articles for Linked List (yes I use Wikipedia a lot):

The principal benefit of a linked list over a conventional array is that the order of the linked items may be different from the order that the data items are stored in memory or on disk. For that reason, linked lists allow insertion and removal of nodes at any point in the list, with a constant number of operations.

On the other hand, linked lists by themselves do not allow random access to the data, or any form of efficient indexing. Thus, many basic operations — such as obtaining the last node of the list, or finding a node that contains a given datum, or locating the place where a new node should be inserted — may require scanning most of the list elements.

In summary-
Linked List: Easy insertion and removal, slow access to random elements
Array: Slow Insertion and removal, fast access to random elements

When we try to access

p (n-k)

we are access a random element and with a linked list it will have to traverse from the very beginning to find the element. When replaced by an array the function can access the element directly without traversal. With so many calls to p that could definitely add up to some time, by it can be hard to believe it could increase the speed of the program by almost 300x. Regardless let’s try it just to see what happens.

module Euler78
where

import Data.Array

pent = let p n = (n * ((3*n) - 1)) `div` 2
       in map (p) (concat [[i , (-i)] | i < - [1..]])

p = let part 0 = 1
        part 1 = 1
        part n = sum $ zipWith (*) [p (n-k) | k <- takeWhile (<=n) pent] (cycle
    in ((listArray (0,10^6) (map (part) [0..])) !)

main78 :: IO ()
main78 = do print $ head $ filter (\x -> (p x) `mod` 10^6 == 0) [1..]

> ghc --make Main.hs -o out/e78
> time out/e78

   real    0m59.389s
   user    0m57.495s
   sys     0m1.211s

Nice that is exactly what I was thinking for. The 300x change with an import and 1 line changed.

Right now the more experienced programmers are thinking “Duh, you should have had an array from the very start”. Unfortunately, we’re not all expert programmers and don’t realize how much it really matters.

This program really opened my eyes to performance of data structures, you can read about the efficiency of data structures all you want but the only way to really get it is to see it used in an actual program. Hopefully this will help a couple others realize the same.

Bookmark It

Hide Sites

The death of the GPL

syfran — Tue, 12 Jan 2010 15:56:02 +0000

No guarantees but my prediction is that we are going to see the gradual downfall of the GPL license over the next couple years. For awhile now there has been a trend of developers switching from GPL to less restrictive licenses, often citing the viral nature of the GPL as the reason.

Is it possible to save the GPL? It might be possible to save but the best solution would be to just let it go. The licenses that are better suited will come into it’s place.

The GPL stage of open source is ending and viral licenses are no longer needed to spread open source around. What we need now are licenses to make open source more usable. Some of the ones hat have been floating around have been the “unlicense” which effectively puts the work into public domain and ms-pl.

Is this trouble for the open source community? Absolutely not. It simply shows that it is going into a stable phase where it does not need developers to force adoption through licenses, and open source will be used regardless.

Bookmark It

Hide Sites

Java Gotchas

syfran — Thu, 08 Oct 2009 22:35:24 +0000

Gotchas are bits of code that do something completely different from what you expected. These bits of code are often hard to catch and identify leaving you debugging for hours on end with no luck. The best way to keep yourself safe is to know them ahead of time. Here are some of the ones I have encountered before.

Collections: remove(int) vs remove(Object)

With two different versions of the remove method on a Collection you can unintentional call the wrong one. For example remove(char c); will cast the char to an int and try to remove the object at 99 (the ascii code for ‘c’). This leads to unpredictable results or an arrayIndexoutofbounds error depending on the size of the array.

The solution is to use non-primitive types for the object. So instead of remove(char) do remove(Character).

Boolean Comparison: && and ||
This problem can lead to some of the more confusing errors. The root cause is that when java the value for the left side that will set the result regardless of the second side, it won’t even evaluate the second side. This becomes a problem when the second side does something other than return the value (like many remove functions that return true or false depending on if it actually removes anything).

The solution here is to make sure the second is a variable. If both sides are functions then assign one of them to a boolean variable before comparing. Of course completely avoiding this situation in the first case would also help : )

Integer Division
When you type 9/4 into the program you expect 2.25 but instead you only get 2. If both numbers in the operation are integers, the answer is cast to an integer. This gotcha can be found fairly easily if it is a simple equation. The trouble appears when you get really complex equations, imagine trying to pick that out of a quartic equation :P.

This solution to the problem is to have one of the operands be a double. If the value is assigned somewhere else and you are using variables (int1/int2) you can add ‘(double)’ in front of one of the numbers. If the values are defined in the equation (2/5), converting to a double is a simple matter of adding a decimal point ‘2./5′.

equality: == vs .equals()
As beginners we are taught that == means equality. In most programs beginners wrote, this worked fine. 2==2 would come out true and 2 == 1 would come out false, that was all we needed. Then you start learning about object oriented programs and create your own classes.

Suddenly == doesn’t work like expected anymore, even though the objects are the same in all ways it comes up false. The reason is that == doesn’t test for equality, it tests to see if the object takes up the same space in memory ( other languages use ‘is’ which I think is more obvious). Because primitives are so simple the jvm can safely store two references to equal primitives in the same memory creating the illusion that == checks for equality. == feels so natural that even after you realize exactly what it does it can slip up and catch you when you get careless.

The .equals() method is java’s solution. The .equals() should be designed to test for that ( though the reliability depends on the developer who made the class). When you create your own class you have the option of overriding the .equals() method and designing it to get whether or not the object is equal based on what you decide.

Bookmark It

Hide Sites

Python base converter

syfran — Mon, 07 Sep 2009 02:55:36 +0000

Converts from any base less than or equal to 36 to any other base less than or equal to 36. This is my first python program so it is definitely not amazing, but I don’t think I did too bad.

My verdict on python, the interpreter works great for the quick scripts, but dynamic typing drives me crazy. For ex. trying to iterate through all the letters in the input it tries to treat it as an int and complains. Just seems too unpredictable and hard to catch errors. I get a feeling like there are a ton of errors waiting to happen : (

Anyway, here is the code, enjoy : )

'''
Created on Sep 6, 2009                                                

@author: syfran
'''            

def convert(oBase, oNum, newBase):

    if(oBase > 36 or newBase > 36):
        print "Please use a base lower than or equal to 36"
        quit()                                             

    numToLett = {10:"A", 11:"B", 12:"C", 13:"D", 14:"E", 15:"F", 16:"G", 17:"H", 18:"I", 19:"J", 20:"K", 21:"L", 22:"M", 23:"N", 24:"O", 25:"P", 26:"Q", 27:"R", 28:"S", 29:"T", 30:"U", 31:"V", 32:"W", 33:"X", 34:"Y", 35:"Z"}
    # returns a function that is used to quickly calculate a power
    def getToPower(base):
        def toPower(exponent):
            return pow(base, exponent)
        return toPower
    # converts the list into a solid string
    def listToString(list):
        returnString = ""
        for letter in list:
            returnString += str(letter)
        return returnString                                                                                                    

    def replaceAlpha(num):
        for value in numToLett:
            if num.upper() == numToLett[value]:
                return value                   

    def addAlpha(num):
        return numToLett[num]                  

    newNum = []
    oBasePower = getToPower(oBase)
    newBasePower = getToPower(newBase)         

    # first convert to decimal
    deci = 0
    exp = len(oNum) - 1
    for digit in oNum:
        if digit.isalpha():
            digit = replaceAlpha(digit)
        deci += oBasePower(exp) * int(digit)
        exp -= 1                               

    # find the highest possible starting number for the new Base
    exp = 0
    while deci >= newBasePower(exp + 1):
        exp += 1                                                

    # break it down into the divisors
    while exp >= 0:
        coeff = deci / newBasePower(exp)
        deci -= newBasePower(exp) * coeff
        if coeff > 9:
            coeff = addAlpha(coeff)
        newNum.append(coeff);
        exp -= 1

    # return
    return listToString(newNum)

def run():
    num = raw_input("Please enter number")
    originalBase = raw_input("Please enter starting base")
    newBase = raw_input("Please enter new Base")
    print convert(int(originalBase),str(num),int(newBase))

if __name__ == '__main__':
    run()

Bookmark It

Hide Sites

How Java passes variables

syfran — Wed, 02 Sep 2009 20:24:53 +0000

In my opinion one of the most confusing topics that Java has to offer is how it passes its variables. Two people can argue for over a page trying to say the same thing but not realize it until after.

The subject gets brought up mostly by C++ programmers transferring over to java. This is because in C++ you can choose how you want your variables to be passed ( by passed I mean used as an argument in a method/constructor) and you begin to realize how much it matters. Likewise it is good ( I’d argue necessary) to know how it is done in Java.

In C++ there are two main ways to pass a variable, pass by reference and pass by value.

pass by Value – Passing by value means you that when you give an object to a method, the method is never going to touch the object you passed it. Instead the method will copy the object an manipulate that.
Passing by value is characterized by the fact that whatever you do inside of the method will have no effect on the variables on the outside. For example
```
void f( int x, int y) {
     int temp = y;
     y = x;
     x = temp;
}

int main() {
    int x = 2;
    int y =3;
    f(x,y);
    cout < < x; // will print out 2
    cout << y; // will print out 3
}
```
So even though the program swapped the two variables in the method, it had no effect on the outside.
pass by reference – Passing by reference is the near opposite of passing by value. Instead of copying a new variable, the old ones are used. Now any changes made to the variables inside will have the same effect on the ones outside.
Here is an example of passing by reference
```
void f( int& x, int& y) {
     int temp = y;
     y = x;
     x = temp;
}

int main() {
    int x = 2;
    int y =3;
    f(x,y);
    cout < < x; // will print out 3
    cout << y; // will print out 2
}
```
This example will switch the numbers because it is altering the variables like they were the original ones.

That seems easy enough right? Well, unfortunately Java doesn’t do either. Yet depending on how you do it, the switch test could go either way.

What Java does is called passing the reference by value. I’m sure that doesn’t help much, possibly only makes it more confusing, so let me explain.

When you create an object Java assigns it a spot on the memory. Every time you use that object Java uses the variable to locate the Object in the memory.

Double pi = new Double(3.14);

In this example the variable pi is pointing to the a Double object in memory.

The key here is to realize that there is a difference between the variable and the object. Just because we said that pi = new Double(); does not mean that pi is exactly the same as the double, it simply points to the Double in memory.

pi = new Double(3.1415);

Now we create a new Double object in memory and tell pi to point to it. It does not take the previous Double’s place in memory. The previous Double will most likely just sit there until the Garbage Collector picks it up.

function(pi);
...
static void function(Double passedPi) {
    passedPi = new Double(3.14);
}

Now we are going to pass the variable to the function. Notice: we are not passing the object itself, just the variable that is pointing at it. This variable that is pointing at it is passed by reference.

So once we pass the variable we have pi that is pointing to the Double(3.1415) and when we enter the method passedPi is pointing towards Double(3.1415).

They are both pointing to the same object, but they are completely separated from each-other now. To prove this we will assign passedPi to a Double(3.14).

If you print out the values you will see that pi is still pointing at Double(3.1415) but passedPi is pointing at Double(3.14). There were no outside effects from the change.

So if you can’t assign new values to variables what can you do? The secret is to modify the memory itself not the pointer to the memory ie. You may modify the attributes of an object and it will apply all around.

Point myPoint = new Point();
myPoint.x = 2;
myPoint.y = 3;
swap(myPoint);

...

void swap(Point p) {
    int temp = p.x;
    p.x = p.y;
    p.y = temp;
}

That code will actually swap the x and the y values. This is because you are modifying the object that is in memory.

They key to remembering this is to separate the variables from the actual objects themselves, where the variable is simply a pointer to the Object.

For those that know C++/C it is effectively a pointer that you can’t selectively dereference.

Bookmark It

Hide Sites

Quick Intro to the Ternary Operator

syfran — Mon, 31 Aug 2009 08:34:30 +0000

The Ternary Operator

The ternary operator is a source of confusion for many beginning programmers. In case you don’t know what the ternary operator is, it looks something like

String message = (isvalid?"Valid":"Invalid");

The ? represents the thought that goes through their head when they see it and they probably won’t get to the : .

One of the reasons why this operator is so confusing is that the symbols have no logical connection to the actual function. Everyone knows that + means addition same with – , /, and *. It’s all pretty basic math/computer stuff, even ++ isn’t too hard to figure out, but what in god’s name does ? : do? Adding to the confusion the operator is not widely used or taught in books or tutorials, so beginners are never exposed to it.

Lucky you, I’m here to teach you all about them (or maybe unlucky you? I don’t know you decide). Let’s start by pulling an example out of the big black hat of code…

Say you have created a virtual world and you need to write a code that determines whether your character buys a car or a bicycle based on how much money he has. If he has less than $20,000 he will buy a bike, else he will by a used car.

The first way to write this would be an if else statement:

Item itemToBuy;
if(amountOfMoney > 20000) {
    itemToBuy = new UsedCar();
} else {
    itemToBuy = new Bicycle();
}
itemToBuy.purchase();

That looks okay, but that it can be cut down considerably with our operator.

Item itemToBuy = (money > 20000 ? new UsedCar() : new Bicycle() );
itemToBuy.purchase();

or even

(money > 20000 ? new UsedCar() : new Bicycle()).purchase();

Using the ternary operator allowed it to be much more compact than a usual if/else statement (also much more confusing).

Now that we have something to work with, let’s break it into pieces.

money > 20000

This is the if statement of the operator. The result of the boolean comparison will determine what gets returned.

This is what signals that it is a ternary operator. It separates the ‘if statement’ from the return clauses.

new UsedCar()

This is the first return clause. If the expression evaluated to true then the value here, will be returned.

This is the second separator. It separates the ‘then’ clause from the ‘else’ clause.

new Bicycle()

And finally there is the ‘else’ clause. The value here is returned if the expression evaluated to false.

Notice how it is worded that it ‘returns’ the value. This is the main difference between the ternary operator and an if/else statement. So a better representation of a ternary operator is an if/else statement within a method.

public Item makeDecision(boolean canAfford) {
    if(canAfford) {
        return new UsedCar();
    } else {
        return new Bicycle();
    }
}
public void someMethod(...) {
    ...
    makeDecision(money > 20000).purchase();
    ...
}

All right so hopefully you know how the ternary operator works now. Let’s go over some ways that you can use it.

Almost forgot, for extra confusing boolean logic you can use nested ternary operators.

(money > 20000 ? (money > 40000 ? (money > 100000  ? new SuperFancyCar() : new NewCar() : new UsedCar()) : new Bicycle()).purchase();

Using the ternary operator

Unless you actually believe it will make your code cleaner, don’t. While it is nifty feature and good for showing off your coding skills, it will just confuse anybody reading your code (including you).

The few times I have seen it put to good use is with strings. Situations where similar to the first one I posted where you need to print a response based on a variable and an if/else would be cumbersome.

Whatever you do, don’t use it to return a boolean value. I didn’t believe my eyes when I saw this

if (speed > speedLimit ? true : false;) {
  pullEmOver();
}

on the first result when Googling ternary operator. It is adding useless code that is especially confusing. What would have been the problem with the following?

if (speed > speedLimit) {
  pullEmOver();
}

Ranting aside, I hope you learned something from this tutorial/short intro (600 words is short right?), now go out there and show off/confuse people with your new awesome coding skillz!!!!

Bookmark It

Hide Sites

Multithreaded String Permutations

syfran — Thu, 27 Aug 2009 14:11:13 +0000

This code snippet is designed to take in a string an print out every possible permutation of that string. The only problem I’ve encountered so far is that it uses a lot of memory with longer strings.

package com.syfran.Permut;

import java.util.ArrayList;
import java.util.EmptyStackException;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Permutations {

	public static void main(String[] pie) {

		String input = "";

		// if there are no arguments, prompt the user
		if (pie.length > 0) {

			// Get all the arguments, gets rid of the need for pesky quotes
			for (String temp : pie)
				input += " " + temp;
		} else {
			System.out.println("Please enter String: ");
			input = (new Scanner(System.in).nextLine());
		}

		Permutations p = new Permutations();

		p.begin(input);

	}

	public void begin(final String myString) {

		// Number of threads, probably best to set it just over the number of
		// cores you have
		final int THREADS = 4;

		// Create a thread safe queue, add initialize it with a blank string.
		Stack myStack = new Stack();
		myStack.push("");

		// Used to execute the threads
		ExecutorService ex = Executors.newFixedThreadPool(THREADS);

		Runnable myRunnable = new PermutWorker(myStack, myString);

		// make sure there is enough in the queue so that it doesn't end early
		final int SEED = 2;
		for (int x = 0; x < SEED; x++)
			seedQueue(myRunnable, ex);

		// continue to execute the worker
		try {
			while (true) {

				ex.execute(myRunnable);
			}
		} catch (EmptyStackException e) {

		}

		// shutdown the executor
		ex.shutdown();

	}

	private void seedQueue(Runnable run, ExecutorService ex) {
		ex.execute(run);

		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// give up / sad panda
			return;
		}

	}

	// Main content of the thread
	private class PermutWorker implements Runnable {
		private Stack stack;
		private final String original;

		PermutWorker(Stack myStack, final String original) {
			this.stack = myStack;
			this.original = original;
		}

		@Override
		public void run() {
			String current = null;
			try {
				// get the current state of permutations from the queue
				current = stack.pop();
			}
			// if we get null then wait for awhile then try again
			catch (EmptyStackException ex) {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					return;
				}
				try {
					current = stack.pop();
				} catch (EmptyStackException e) {
					return;
				}
			}

			// create List of current characters
			List currentList = new ArrayList();
			for (Character c : current.toCharArray())
				currentList.add(c);

			// create list of characters in original
			List remaining = new ArrayList();
			for (Character c : original.toCharArray())
				remaining.add(c);

			// remove current from the original to get the remaining
			for (Character c : currentList)
				remaining.remove(c);

			// for every remaining character, add it to current
			// if it is the same length as the original then print it
			// else add it to the queue
			for (Character c : remaining) {
				String result = current + c;
				if (result.length() == original.length()) {
					// change this as needed
					System.out.println(result);
				} else {
					stack.push(result);
				}

			}

		}
	}
}

UPDATE: Replaced the queue with a stack to try to help with the memory problem. It will still get outofMemory errors on longer strings but it can handle a bit more. The stack should focus on the longest strings first and get them (hopefully if the GC does its job) out of the memory quickly.

Bookmark It

Hide Sites

Increase Your Productivity!!

syfran — Sun, 26 Jul 2009 20:07:30 +0000

Just uploaded a project I have been hiding away for awhile. My amazing name for it is Productivity Timer.

I read somewhere that you could increase productivity by writing down what you do every 15 minutes. I saw this and immediately decided to make a program for it.

This program stays in a small box with a timer, well out of the way until the timer runs up. At that point it pops up with a small box. You then enter a short summary of your accomplishments and continue. The program writes what you say into the directory you designate labeled with the date. Each line inside is labeled with the time and the comment.

Whether you run it from the files or from the jar it has two arguments. The first one is required, it is the folder you want to keep the logs under. The second is optional. It is the amount of time between polls in minutes, the default is 15.

I cleaned it up and put it up so that it is ready for other people to use, though it is still fairly messy. The method of initializing all the parts that have circular dependencies on eachother is pretty messy as well. I might come back and revise this sooner or later.

All the source code can be found http://code.syfran.com/productivTim/ including an up to date jar file that can be run with java -jar ProductivityTimer.jar MyDir. It can also be checked out with svn co http://code.syfran.com/productivTim.

Bookmark It

Hide Sites

Modeling the Human Memory

syfran — Sat, 25 Jul 2009 04:48:10 +0000

All right, this is a very rough idea and is going to be far from perfect (and I’m sure someone else has though of it before). The idea is to use a node type system that defines an object based on it’s relationships.

Relationships can be strengthened or weakened and will slowly degrade over time. These relationships will change and shift over time similar to the human mind. For example, a tree.

Some of the associations may be color, size, similarities, properties etc. Even the name of the object will be associated by a relationship.

With this model it could be possible to represent abstract concepts and ideas. In addition to that it would perfectly model the differences in everyone’s thought processes and decision making.

The downside would be that it would have to learn exactly like a human would slowly and one step at a time.

Once again this is just a quick half formed idea I had and most likely will not work or is impossible ( or both), but I’d figured I’d share it anyway.

Bookmark It

Hide Sites

Converting Images from rgb to grayscale with Java

syfran — Mon, 13 Jul 2009 10:03:44 +0000

Not sure what motivated me here but I took a little time and came up with this. It takes the original image file ( can be a multitude of formats, has worked with both jpg and png so far) and outputs a grayscale image (jpeg or png).

Tux the penguin in full color.

The aftermath.

Here is the slightly ugly code…

import javax.imageio.*;
import java.io.*;
import java.awt.image.*;                                   

public class GrayScale {
        public static void main(String [] pie) {

                // Argument Checks
                if(!((pie.length == 3) && (new File(pie[0]).exists()) &&(pie[2].equals("jpeg") || pie[2].equals("png")))) {
                        System.out.println("Usage: java GrayScale {original image} {modified image} {Output Format}\nOutput Format can be jpeg or png");
                        System.exit(0);
                }                                                                                                              

                BufferedImage image = null;
                try {
                image = ImageIO.read(new File(pie[0])); // Read in the original file
                } catch(IOException e) {
                        System.err.println("Error reading in file, check file name and format");
                        System.exit(0);
                }                                                                               

                // loop through every pixel in the image
                for(int x = 0; x > 8;
                                int red = (RGB & 0x00FF0000) >> 16;
                                int average = (blue + green + red)/3;
                                int newRGB = 0xFF000000 + (average < < 16) + (average << 8 ) + average; // and reassign it
                                image.setRGB(x,y,newRGB);
                        }
                }
                try {
                        ImageIO.write(image, pie[2], new File(pie[1])); // Writes the new grayscale file.
                } catch(IOException e) {
                        System.err.println("Unable to output results");
                }

        }
}

UPDATE: Edited thanks to the comment from Gasper. Swapped out the Color class for bitwise operations and it seems to be working well. Also figured out how to format the code in a way that looks better.

Bookmark It

Hide Sites