Programming Discussion Thread - Printable Version

Code:

import bpy

import mathutils

import math



class MakeOneSOrbital(bpy.types.Operator):

    bl_idname = "mesh.make_one_s_orbital"

    bl_label = "Add 1s Orbital"

    

    def invoke(self, context, event):

        e = 2.71828182845904523536028747135266249775724709369995

        psimax=0

        psimin=2**31

        res = 50

        multi = 2*res

        cubedim = 2.5/res

        stretch = 5/res

        psilist = [[[0 for k in range(res*2+1)] for j in range(res*2+1)] for i  in range(res*2+1)]

        for x in range(-res,res+1):

            for y in range(-res,res+1):

                for z in range(-res,res+1):

                    xco = x/multi

                    yco = y/multi

                    zco = z/multi

                    

                    r = xco**2 + yco**2 + zco**2

                    r = r**0.5

                    psi=e**-r

                    if psi > psimax:

                        psimax = psi

                    if psi < psimin:

                        psimin = psi

                    psilist[x+res][y+res][z+res] = psi

        print(psimax,psimin)

        for x in range(-res,res+1):

            for y in range(-res,res+1):

                for z in range(-res,res+1):

                    xco = x/stretch

                    yco = y/stretch

                    zco = z/stretch

                    bpy.ops.mesh.primitive_cube_add(location=(xco,yco,zco))

                    bpy.ops.transform.resize(value=(cubedim,cubedim,cubedim))

                    mat = bpy.ops.material.new()

                    mat.type = 'VOLUME'

                    mat.volume.density = psimax/psilist[x+res][y+res][z+res]

        

        return {"FINISHED"}



bpy.utils.register_class(MakeOneSOrbital)

Code:

import java.util.Random;import java.lang.Math;

//This is broken, but follows the psuedocode perfectly. It is set to exit when something breaks. The error tends to infinity, leading things to break when a correction is attempted. The error problem is either caused by overflow, or division by zero.public class NeuralNet{    final double RATE = 0.1;    double[][] synone = new double[2][30];    double[][] syntwo = new double[30][2];    double[] input = new double[2];    double[] medin = new double[30];    double[] medout = new double[30];    double[] output = new double[2];    double[] error = new double[2];        public void initialise()    {        //set synone to random values between -0.1 and 0.1        for(int i=0; i<30; i++)        {            for(int j=0; j<2; j++)            {                synone[j][i] = new Random().nextDouble();                synone[j][i] = synone[j][i]*0.2 - 0.1;            }        }        //Same for syntwo        for(int i=0; i<2; i++)        {            for(int j=0; j<30; j++)            {                syntwo[j][i] = new Random().nextDouble();                syntwo[j][i] = syntwo[j][i]*0.2 - 0.1;            }        }    }        public void run()    {        for(int i=0; i<=10000; i++)        {            //Generate polar coords on unit circle            double length = 1.0;            double theta = new Random().nextDouble();            theta = theta * 360.0;            //put length and theta into input neurons            input[0] = length;            input[1] = theta;            //Pass these to convert to get back error            convert(input);            //Use back propagation to adjust neural net            backProp();            //Output error E            double errorE = 0.0;            for(int j=0; j<error.length; j++)            {                errorE = errorE + error[j]*error[j];            }            errorE = Math.sqrt(errorE);            System.out.println(errorE);        }    }        public void convert(double[] input)    {        //for each medial neuron        for(int i=0; i<30; i++)        {            //reset medial input            medin[i] = 0;            //for each input neuron            for(int j=0; j<2; j++)            {                //add input times weight to the neuron                medin[i] = medin[i] + synone[j][i]*input[j];            }            //compute tanh of the neuron's value to get it's output            medout[i] = Math.tanh(medin[i]);        }                double[] target = new double[2];        //for each output neuron        for(int i=0; i<2; i++)        {            //reset output            output[i] = 0;            //for each medial neuron            for(int j=0; j<30; j++)            {                //add input times weight to the neuron                output[i] = output[i] + syntwo[j][i] * medout[j];                System.out.println("O"+output[i]+" S2"+syntwo[j][i]+" Mo"+medout[j]);                if(Double.isNaN(output[i]))                    System.exit(0);            }            //compute correct value for this output            //must use correct trig function for x and y            switch(i)            {                case 1: target[i] = input[0] * Math.sin(Math.toRadians(input[1]));                    break;                case 2: target[i] = input[0] * Math.cos(Math.toRadians(input[1]));                    break;                default: break;            }            error[i] = target[i] - output[i];        }    }        public void backProp()    {        //adjust second synaptic layer        //for each output neuron        for(int i=0; i<2; i++)        {            //for each medial neuron            for(int j=0; j<30; j++)            {                //adjust the synaptic multiplier/weight                syntwo[j][i] = syntwo[j][i] + RATE*medout[j]*error[i];            }        }        //Derive the sigmoidal signal        double[] sigma = new double[30];        double[] sigmoid = new double[30];        //for each medial neuron        for(int i=0; i<30; i++)        {            //reset sigma            sigma[i] = 0;            //for each output neuron            for(int j=0; j<2; j++)            {                //add value to sum                sigma[i] = sigma[i] + error[j]*syntwo[i][j];            }            //calculate sigmoid            sigmoid[i] = 1 - medin[i]*medin[i];        }        //adjust the first synaptic layer        //probably for each output neuron, although that doesn't seem obvious        for(int i=0; i<2; i++)        {            //for each medial neuron            for(int j=0; j<30; j++)            {                double delta = RATE*sigmoid[j]*sigma[j]*input[i];                synone[1][j] = synone[i][j] + delta;            }        }    }        public static void main(String[] args)    {        NeuralNet net = new NeuralNet();        net.initialise();        net.run();    }}