Area Estimation
Maximum area = 36016 nand gates
C:\Program Files\Celoxica\RC1000\fpga\V2_1\XC4000\pp1000.h
/****************************************************************
* *
* Copyright 1991-2001 Celoxica Ltd. *
* All Rights Reserved *
* *
* This is "Unpublished Proprietary Source Code" of Celoxica *
* Ltd ("Celoxica"). The contents of this file may not *
* be disclosed to third parties not covered by a Celoxica *
* NDA (Non-Disclosure Agreement) or a Celoxica End User Licence *
* Agreement or other agreement. *
* *
* In addition, the source code of this file may not be *
* copied or duplicated in any form without the prior written *
* authorization of Celoxica. *
* *
* This code is protected by English and International *
* copyright laws. All use of this code is subject to the *
* End User License Agreement, Non-Disclosure Agreement, *
* or other agreement in effect with Celoxica. If a *
* licence document or agreement is not included with this *
* source code please contact Celoxica immediately for a copy of *
* the applicable licence agreement. *
* *
* Any other use of this code other than as expressly agreed *
* to by Celoxica including decompilation, *
* disassembly, or reverse engineering is unauthorised. *
* *
* Rights of confidence, trademark rights, and other *
* intellectual property rights reserved under the laws of *
* England, the United States, and the International *
* Community. *
* *
* World Wide Headquarters: *
* Celoxica Limited *
* 20 Park Gate *
* Abingdon *
* Oxfordshire *
* United Kingdom *
* OX14 4SH *
* Tel: +44 1235 863656 *
* Fax: +44 1235 863648 *
* *
* US Headquarters: *
* Celoxica Inc *
* 900 East Hamilton Ave. *
* Suite 150 *
* Campbell, CA 95008 *
* Tel: 1-408-626-9070 *
* Fax: 1-408-626-9079 *
* *
* Email<EMAIL_ADDRESS>*
* *
*****************************************************************
* Project : RC1000-PP *
* Date : 09/06/98 *
* File : pp1000.h *
* Author : Matthew Bowen *
* *
* Date Version Author Reason for change *
* 09/06/98 0.98 MB Created *
* 02/03/99 1.00 MB Updated for rev 2.0 PCB *
* 11/06/99 1.00 MB First full release *
* *
* Description *
* Header file for RC1000-PP FPGA version 2.00 PCB. *
* *
****************************************************************/
/*
* Pins for RAM bank 0
*/
macro expr PP1000_Data0_3 = {
"U29", "U33", "V32", "V31", "V29", "V30", "W31", "W33"};
macro expr PP1000_Data0_2 = {
"W30", "W29", "Y32", "AF32", "Y30", "AA33", "Y29", "AA32"};
macro expr PP1000_Data0_1 = {
"AA31", "AA30", "AK28", "AA29", "AB31", "AB30", "AC33", "AC31"};
macro expr PP1000_Data0_0 = {
"AB29", "AC30", "AD31", "AE33", "AC29", "AE32", "AD30", "AE31"};
macro expr PP1000_Data0 = {
"U29", "U33", "V32", "V31", "V29", "V30", "W31", "W33",
"W30", "W29", "Y32", "AF32", "Y30", "AA33", "Y29", "AA32",
"AA31", "AA30", "AK28", "AA29", "AB31", "AB30", "AC33", "AC31",
"AB29", "AC30", "AD31", "AE33", "AC29", "AE32", "AD30", "AE31"};
macro expr PP1000_Addr0 = {
"AN29", "AM31", "AD29", "AF31", "AE30", "AG33", "AH33", "AE29",
"AJ26", "AF30", "AH32", "AJ32", "AF29", "AH31", "AG30", "AK32",
"AJ31", "AG29", "AL33", "AH30", "AJ30" };
macro expr PP1000_CS0 = { "AL28", "AK27", "AL29", "AN31" };
macro expr PP1000_WE0 = { "AJ25" };
macro expr PP1000_OE0 = { "AK26" };
macro expr PP1000_CS0_0 = { "AN31" };
macro expr PP1000_CS0_1 = { "AL29" };
macro expr PP1000_CS0_2 = { "AK27" };
macro expr PP1000_CS0_3 = { "AL28" };
/*
* Pins for RAM bank 1
*/
macro expr PP1000_Data1_3 = {
"AB3", "AC1", "AB4", "AC3", "AA5", "AJ6", "AD3", "AE1"};
macro expr PP1000_Data1_2 = {
"AC5", "AE3", "AD4", "AF1", "AF2", "AD5", "AG2", "AE4"};
macro expr PP1000_Data1_1 = {
"AF3", "AH1", "AE5", "AJ1", "AF4", "AJ2", "AF5", "AH3"};
macro expr PP1000_Data1_0 = {
"AG4", "AK2", "AJ3", "AG5", "AL1", "AH4", "AK3", "AN3"};
macro expr PP1000_Data1 = {
"AB3", "AC1", "AB4", "AC3", "AA5", "AJ6", "AD3", "AE1",
"AC5", "AE3", "AD4", "AF1", "AF2", "AD5", "AG2", "AE4",
"AF3", "AH1", "AE5", "AJ1", "AF4", "AJ2", "AF5", "AH3",
"AG4", "AK2", "AJ3", "AG5", "AL1", "AH4", "AK3", "AN3"};
macro expr PP1000_Addr1 = {
"AK10", "AM9", "U4", "U1", "U2", "V2", "V4", "V5", "V3", "W1",
"W3", "AK9", "W5", "AL8", "Y3", "Y4", "AA1", "Y5",
"AA3", "AA4", "AN7"};
macro expr PP1000_CS1 = { "AK7", "AL6", "AJ8", "AM6" };
macro expr PP1000_WE1 = { "AK6" };
macro expr PP1000_OE1 = { "AL5" };
macro expr PP1000_CS1_0 = { "AM6" };
macro expr PP1000_CS1_1 = { "AJ8" };
macro expr PP1000_CS1_2 = { "AL6" };
macro expr PP1000_CS1_3 = { "AK7" };
/*
* Pins for RAM bank 2
*/
macro expr PP1000_Data2_3 = {
"D31", "F30", "C33", "G29", "E31", "D32", "G30", "F31" };
macro expr PP1000_Data2_2 = {
"H29", "E32", "E33", "E28", "G31", "J29", "F33", "G32" };
macro expr PP1000_Data2_1 = {
"J30", "H31", "K29", "H32", "J31", "K30", "H33", "L29" };
macro expr PP1000_Data2_0 = {
"K31", "L30", "J33", "M29", "L31", "M30", "L32", "M31" };
macro expr PP1000_Data2 = {
"D31", "F30", "C33", "G29", "E31", "D32", "G30", "F31",
"H29", "E32", "E33", "E28", "G31", "J29", "F33", "G32",
"J30", "H31", "K29", "H32", "J31", "K30", "H33", "L29",
"K31", "L30", "J33", "M29", "L31", "M30", "L32", "M31" };
macro expr PP1000_Addr2 = {
"B29", "E26", "F29", "L33", "N30", "N31", "M32", "P29",
"P30", "D30", "P31", "P32", "R29", "R30", "R31", "R33",
"T31", "T29", "T30", "T32", "U31"};
macro expr PP1000_CS2 = { "A31", "D28", "C30", "D29" };
macro expr PP1000_WE2 = { "C28" };
macro expr PP1000_OE2 = { "D27" };
macro expr PP1000_CS2_0 = { "D29" };
macro expr PP1000_CS2_1 = { "C30" };
macro expr PP1000_CS2_2 = { "D28" };
macro expr PP1000_CS2_3 = { "A31" };
/*
* Pins for RAM bank 3
*/
macro expr PP1000_Data3_3 = {
"J4", "H3", "K5", "H2", "J3", "K4", "J2", "L5"};
macro expr PP1000_Data3_2 = {
"E8", "C6", "K2", "M5", "L3", "L1", "M4", "N5"};
macro expr PP1000_Data3_1 = {
"M2", "N4", "N3", "N2", "P5", "U3", "P4", "D7"};
macro expr PP1000_Data3_0 = {
"P2", "R5", "R4", "R3", "R1", "T4", "T5", "T2"};
macro expr PP1000_Data3 = {
"J4", "H3", "K5", "H2", "J3", "K4", "J2", "L5",
"E8", "C6", "K2", "M5", "L3", "L1", "M4", "N5",
"M2", "N4", "N3", "N2", "P5", "U3", "P4", "D7",
"P2", "R5", "R4", "R3", "R1", "T4", "T5", "T2"};
macro expr PP1000_Addr3 = {
"A5", "B5", "C5", "E7", "F5", "B3", "D3", "F4",
"C1", "G5", "E3", "D2", "G4", "H5", "E2", "F3",
"H4", "G3", "J5", "F1", "G1"};
macro expr PP1000_CS3 = { "B8", "A8", "D10", "C9" };
macro expr PP1000_WE3 = { "A6" };
macro expr PP1000_OE3 = { "B7" };
macro expr PP1000_CS3_0 = { "C9" };
macro expr PP1000_CS3_1 = { "D10" };
macro expr PP1000_CS3_2 = { "A8" };
macro expr PP1000_CS3_3 = { "B8" };
/*
* Clock pin
*/
#if (defined(PP1000_DIVIDE1) && defined(PP1000_DIVIDE3)) || (defined(PP1000_DIVIDE1) && defined(PP1000_DIVIDE4)) || (defined(PP1000_DIVIDE3) && defined(PP1000_DIVIDE4))
#error Please define only one of PP1000_DIVIDE1, PP1000_DIVIDE3 or PP1000_DIVIDE4 before including pp1000.h
#endif
#if !defined(PP1000_DIVIDE1) && !defined(PP1000_DIVIDE3) && !defined(PP1000_DIVIDE4)
#error Please define one of PP1000_DIVIDE1, PP1000_DIVIDE3 or PP1000_DIVIDE4 before including pp1000.h
#endif
#ifndef PP1000_CLOCK
#define PP1000_CLOCK PP1000_MCLK
#endif
#define PP1000_MCLK "AH29"
#define PP1000_VCLK "AJ28"
#ifdef PP1000_DIVIDE1
set clock = external PP1000_CLOCK;
#elif defined(PP1000_DIVIDE3)
set clock = external_divide PP1000_CLOCK 3;
#elif defined(PP1000_DIVIDE4)
set clock = external_divide PP1000_CLOCK 4;
#endif
/*
* PLX User I/O Pins
*/
macro expr PP1000_PLXUserIn = {"AJ10"};
macro expr PP1000_PLXUserOut = {"AL9"};
/*
* Status byte pins
*/
macro expr PP1000_FPGAStatus = {
"AJ15", "AK15", "AL15", "AM16", "AL16", "AJ16", "AK16", "AN17" };
macro expr PP1000_FPGAStatusValid = { "AN15" };
macro expr PP1000_FPGAStatusAck = { "AM14" };
/*
* Control byte pins
*/
macro expr PP1000_FPGAControl = {
"AL18", "AK18", "AJ18", "AN19", "AL19", "AK19", "AM20", "AJ19" };
macro expr PP1000_FPGAControlValid = { "AM18" };
macro expr PP1000_FPGAControlAck = { "AL20" };
/*
* LED Pins
*/
macro expr PP1000_LEDPin0 = { "AN28" };
macro expr PP1000_LEDPin1 = { "AK25" };
macro expr PP1000_LEDPin2 = { "AL26" };
macro expr PP1000_LEDPin3 = { "AJ24" };
macro expr PP1000_LEDPin4 = { "AM27" };
macro expr PP1000_LEDPin5 = { "AM26" };
macro expr PP1000_LEDPin6 = { "AK24" };
macro expr PP1000_LEDPin7 = { "AL25" };
/*
* Memory bank request
*/
macro expr PP1000_Bank0Req = { "AM30" };
macro expr PP1000_Bank1Req = { "AM4" };
macro expr PP1000_Bank2Req = { "C29" };
macro expr PP1000_Bank3Req = { "C8" };
macro expr PP1000_Bank0Grant = { "AM29" };
macro expr PP1000_Bank1Grant = { "AJ7" };
macro expr PP1000_Bank2Grant = { "B30" };
macro expr PP1000_Bank3Grant = { "D9" };
/*
* Auxilliary I/O
*/
macro expr PP1000_Aux = {
"E11", "A9", "C10", "D11", "B10", "B11", "D12", "A11",
"E13", "C12", "D15", "D13", "C13", "E14", "A13", "D14",
"C14", "E15", "C15", "A15", "D16", "B16", "B17", "C20",
"E20", "B21", "C21", "D21", "B22", "E21", "D20", "D22",
"A23", "C23", "E22", "B24", "D23", "A25", "E23", "B25",
"D24", "C25", "B26", "E24", "C26", "D25", "A27", "A28",
"E25", "C27"};
/*
* Reset line
*/
macro expr PP1000_Reset = { "AL4" };
/*
* Spare pins
*/
macro expr PP1000_Spare = {
"U3", "M4", "F3", "F29", "AH5", "AJ1", "AA5", "U29",
"AE31", "AF32", "A17", "B18", "C18", "B33", "E18", "D18",
"A19", "C19", "D19", "E19", "B20", "C20", "D20", "D26",
"B28", "B29", "E26", "E27", "E28", "D30",
"E29", "AK30", "AJ29", "AN32", "AJ28", "AK29", "AL30", "AK28",
"AM31", "AJ27", "AJ26", "AJ25", "AN29", "AJ23",
"AN26", "AL24", "AK23", "AJ22", "AL23", "AM24", "AK22", "AM23",
"AJ21", "AL22", "AN23", "AK21", "AM22", "AJ20", "AL21", "AN21",
"AK20", "AL20", "AJ17", "AL17", "AL14", "AK14", "AJ14", "AN13",
"AM13", "AL13", "AK13", "AJ13", "AM12", "AL12", "AK12", "AN11",
"AJ12", "AL11", "AM10", "AL10", "AJ11", "AN9", "AK10", "AM9",
"AJ10", "AM8", "AK9", "AL8", "AN7", "AJ9", "AL7",
"AK8", "AN6", "AM5", "AN3", "AJ6",
"AJ5", "AM1", "U5", "E4", "D4", "C4", "D17", "D5",
"A2", "A3", "B4", "D7", "E8", "B5", "A5",
"D8", "C7", "E9", "A6", "B7", "E10",
"C11", "E15", "D15", "C16", "E16", "E17"};
macro expr PP1000_TDO = {"E6"};
/****************************************
* EXTERNAL RAM ACCESS MACRO DEFINITIONS *
****************************************/
/*
* General RAM defintion - assume external clock divided by 4
*/
macro expr PP1000_RAMSpec(a, d, c, w, o) =
{
offchip = 1,
addr = a,
data = d,
cs = c,
we = w,
oe = o,
#ifdef PP1000_DIVIDE1
wegate = 1,
#elif defined(PP1000_DIVIDE3)
westart = 1, /* For external clock divided by 3, set write strobe to start */
welength = 1, /* 1/3 way through cycle and last for 1/3 of a cycle. */
#elif defined(PP1000_DIVIDE4)
westart = 2, /* For external clock divided by 4, set write strobe to start */
welength = 1, /* 1/2 way through cycle and last for 1/4 of a cycle. */
#endif
warn = 0
};
#if defined(PP1000_32BIT_RAMS) && defined(PP1000_8BIT_RAMS)
#error Please define only one of PP1000_32BIT_RAMS or PP1000_8BIT_RAMS before including pp1000.h
#endif
#if !defined(PP1000_32BIT_RAMS) && !defined(PP1000_8BIT_RAMS)
#error Please define either PP1000_32BIT_RAMS or PP1000_8BIT_RAMS before including pp1000.h
#endif
#ifdef PP1000_32BIT_RAMS
/*
* Declare 32 bit wide RAMs and access routines
* Macros are:
* PP1000ReadBank#(DestReg, Address)
* where # is 0, 1, 2, 3
* DestReg is unsigned 32 bit word
* Address is 21 bit unsigned integer
* PP1000WriteBank#(Address, Value)
* where # is 0, 1, 2, 3
* Address is 21 bit unsigned integer
* Value is unsigned 32 bit expression
*/
ram unsigned 32 PP1000Bank0[2097152] with PP1000_RAMSpec(PP1000_Addr0, PP1000_Data0, PP1000_CS0,
PP1000_WE0, PP1000_OE0);
macro proc PP1000ReadBank0(Reg, Addr) { Reg = PP1000Bank0[Addr]; }
macro proc PP1000WriteBank0(Addr, Expr) { PP1000Bank0[Addr] = Expr; }
ram unsigned 32 PP1000Bank1[2097152] with PP1000_RAMSpec(PP1000_Addr1, PP1000_Data1, PP1000_CS1,
PP1000_WE1, PP1000_OE1);
macro proc PP1000ReadBank1(Reg, Addr) { Reg = PP1000Bank1[Addr]; }
macro proc PP1000WriteBank1(Addr, Expr) { PP1000Bank1[Addr] = Expr; }
ram unsigned 32 PP1000Bank2[2097152] with PP1000_RAMSpec(PP1000_Addr2, PP1000_Data2, PP1000_CS2,
PP1000_WE2, PP1000_OE2);
macro proc PP1000ReadBank2(Reg, Addr) { Reg = PP1000Bank2[Addr]; }
macro proc PP1000WriteBank2(Addr, Expr) { PP1000Bank2[Addr] = Expr; }
ram unsigned 32 PP1000Bank3[2097152] with PP1000_RAMSpec(PP1000_Addr3, PP1000_Data3, PP1000_CS3,
PP1000_WE3, PP1000_OE3);
macro proc PP1000ReadBank3(Reg, Addr) { Reg = PP1000Bank3[Addr]; }
macro proc PP1000WriteBank3(Addr, Expr) { PP1000Bank3[Addr] = Expr; }
#endif /* PP1000_32BIT_RAMS */
#ifdef PP1000_8BIT_RAMS
/*
* Declare 8 bit wide RAMs and access routines
* Macros are:
* PP1000ReadBank#(DestReg, Address)
* where # is 0, 1, 2, 3
* DestReg is unsigned 8 bit word
* Address is 23 bit unsigned integer (bottom 2 bit are byte select)
* PP1000WriteBank#(Address, Value)
* where # is 0, 1, 2, 3
* Address is 23 bit unsigned integer (bottom 2 bit are byte select)
* Value is unsigned 8 bit expression
*/
#define BUILD_RAM(n) \
ram unsigned 0 PP1000_Bank##n##WEOE[1] with PP1000_RAMSpec({}, {}, {}, PP1000_WE##n, PP1000_OE##n); \
ram unsigned 0 PP1000_Bank##n##Addr[2097152] with PP1000_RAMSpec(PP1000_Addr##n, {}, {}, {}, {}); \
ram unsigned 8 PP1000_Bank##n##Data0[1] with PP1000_RAMSpec({}, PP1000_Data##n##_0, {}, {}, {}); \
ram unsigned 0 PP1000_Bank##n##Ctrl0[1] with PP1000_RAMSpec({}, {}, PP1000_CS##n##_0, {}, {}); \
ram unsigned 8 PP1000_Bank##n##Data1[1] with PP1000_RAMSpec({}, PP1000_Data##n##_1, {}, {}, {}); \
ram unsigned 0 PP1000_Bank##n##Ctrl1[1] with PP1000_RAMSpec({}, {}, PP1000_CS##n##_1, {}, {}); \
ram unsigned 8 PP1000_Bank##n##Data2[1] with PP1000_RAMSpec({}, PP1000_Data##n##_2, {}, {}, {}); \
ram unsigned 0 PP1000_Bank##n##Ctrl2[1] with PP1000_RAMSpec({}, {}, PP1000_CS##n##_2, {}, {}); \
ram unsigned 8 PP1000_Bank##n##Data3[1] with PP1000_RAMSpec({}, PP1000_Data##n##_3, {}, {}, {}); \
ram unsigned 0 PP1000_Bank##n##Ctrl3[1] with PP1000_RAMSpec({}, {}, PP1000_CS##n##_3, {}, {}); \
macro proc PP1000ReadBank##n(Reg, Addr) \
{ \
unsigned 0 Dummy[2] with {warn=0}; \
\
par \
{ \
Dummy[0] = PP1000_Bank##n##WEOE[0]; \
PP1000_Bank##n##Addr[((unsigned 23)Addr)\\2] = 0; \
switch(((unsigned 23)Addr)[1:0]) \
{ \
case 0:\
par \
{\
Reg = PP1000_Bank##n##Data0[0]; \
Dummy[1] = PP1000_Bank##n##Ctrl0[0]; \
} \
break; \
case 1:\
par \
{\
Reg = PP1000_Bank##n##Data1[0]; \
Dummy[1] = PP1000_Bank##n##Ctrl1[0]; \
} \
break; \
case 2:\
par \
{\
Reg = PP1000_Bank##n##Data2[0]; \
Dummy[1] = PP1000_Bank##n##Ctrl2[0]; \
} \
break; \
case 3:\
par \
{\
Reg = PP1000_Bank##n##Data3[0]; \
Dummy[1] = PP1000_Bank##n##Ctrl3[0]; \
} \
break; \
default: delay; break; \
} \
} \
} \
\
macro proc PP1000WriteBank##n(Addr, Expr) \
{ \
par \
{ \
PP1000_Bank##n##WEOE[0] = 0; \
PP1000_Bank##n##Addr[((unsigned 23)Addr)\\2] = 0; \
switch(((unsigned 23)Addr)[1:0]) \
{ \
case 0: \
par \
{ \
PP1000_Bank##n##Data0[0] = Expr; \
PP1000_Bank##n##Ctrl0[0] = 0; \
} \
break; \
case 1: \
par \
{ \
PP1000_Bank##n##Data1[0] = Expr; \
PP1000_Bank##n##Ctrl1[0] = 0; \
} \
break; \
case 2: \
par \
{ \
PP1000_Bank##n##Data2[0] = Expr; \
PP1000_Bank##n##Ctrl2[0] = 0; \
} \
break; \
case 3: \
par \
{ \
PP1000_Bank##n##Data3[0] = Expr; \
PP1000_Bank##n##Ctrl3[0] = 0; \
} \
break; \
default: delay; break; \
} \
} \
}
BUILD_RAM(0)
BUILD_RAM(1)
BUILD_RAM(2)
BUILD_RAM(3)
#endif /* PP1000_8BIT_RAMS */
#ifndef SIMULATE
/*
* Macro to write word to FPGA->host status word
*/
unsigned 1 PP1000_StatusValid = 1 with {warn = 0};
interface bus_out() PP1000_StatusValidBus(PP1000_StatusValid) with {data = PP1000_FPGAStatusValid};
interface bus_clock_in(unsigned 1) PP1000_StatusAck() with {data = PP1000_FPGAStatusAck};
unsigned 8 PP1000_StatusByte with {warn = 0};
interface bus_out() PP1000_StatusBus(PP1000_StatusByte) with {data = PP1000_FPGAStatus};
macro proc PP1000WriteStatus(Value)
{
/*
* Set value and assert valid pin
*/
PP1000_StatusByte = Value;
PP1000_StatusValid = 0;
/*
* Wait for acknowledge
*/
while (PP1000_StatusAck.in==1)
{
delay;
}
/*
* Clear valid pin
*/
PP1000_StatusValid = 1;
/*
* Wait for acknowledge to clear
*/
while (PP1000_StatusAck.in==0)
{
delay;
}
}
/*
* Macro to read word from host->FPGA control word
*/
unsigned 1 PP1000_ControlAck = 1 with {warn = 0};
interface bus_out() PP1000_ControlAckBus(PP1000_ControlAck) with {data = PP1000_FPGAControlAck};
interface bus_clock_in(unsigned 1) PP1000_ControlValid() with {data = PP1000_FPGAControlValid};
interface bus_in(unsigned 8) PP1000_ControlByte() with {data = PP1000_FPGAControl};
macro proc PP1000ReadControl(Reg)
{
/*
* Wait for flag to be asserted
*/
while (PP1000_ControlValid.in==1)
{
delay;
}
/*
* Read data and assert acknowledge
*/
par
{
Reg = PP1000_ControlByte.in;
PP1000_ControlAck = 0;
}
/*
* Wait for flag to be deasserted
*/
while (PP1000_ControlValid.in==0)
{
delay;
}
/*
* Deassert acknowledge
*/
PP1000_ControlAck = 1;
}
/*
* Macros to turn LEDs on and off
*/
unsigned 1 PP1000_LEDState[8] with { warn = 0 };
interface bus_out() PP1000_LED0Bus(~PP1000_LEDState[0]) with { data = PP1000_LEDPin0, warn = 0 };
interface bus_out() PP1000_LED1Bus(~PP1000_LEDState[1]) with { data = PP1000_LEDPin1, warn = 0 };
interface bus_out() PP1000_LED2Bus(~PP1000_LEDState[2]) with { data = PP1000_LEDPin2, warn = 0 };
interface bus_out() PP1000_LED3Bus(~PP1000_LEDState[3]) with { data = PP1000_LEDPin3, warn = 0 };
interface bus_out() PP1000_LED4Bus(~PP1000_LEDState[4]) with { data = PP1000_LEDPin4, warn = 0 };
interface bus_out() PP1000_LED5Bus(~PP1000_LEDState[5]) with { data = PP1000_LEDPin5, warn = 0 };
interface bus_out() PP1000_LED6Bus(~PP1000_LEDState[6]) with { data = PP1000_LEDPin6, warn = 0 };
interface bus_out() PP1000_LED7Bus(~PP1000_LEDState[7]) with { data = PP1000_LEDPin7, warn = 0 };
macro proc PP1000SetLEDs(Mask)
{
par
{
PP1000_LEDState[0] = Mask[0];
PP1000_LEDState[1] = Mask[1];
PP1000_LEDState[2] = Mask[2];
PP1000_LEDState[3] = Mask[3];
PP1000_LEDState[4] = Mask[4];
PP1000_LEDState[5] = Mask[5];
PP1000_LEDState[6] = Mask[6];
PP1000_LEDState[7] = Mask[7];
}
}
macro proc PP1000LEDOn(Number)
{
/*
* Use a switch to allow Number to be a variable/expression
*/
switch(Number<-3)
{
case 0:
PP1000_LEDState[0] = 1;
break;
case 1:
PP1000_LEDState[1] = 1;
break;
case 2:
PP1000_LEDState[2] = 1;
break;
case 3:
PP1000_LEDState[3] = 1;
break;
case 4:
PP1000_LEDState[4] = 1;
break;
case 5:
PP1000_LEDState[5] = 1;
break;
case 6:
PP1000_LEDState[6] = 1;
break;
case 7:
PP1000_LEDState[7] = 1;
break;
}
}
macro proc PP1000LEDOff(Number)
{
/*
* Use a switch to allow Number to be a variable/expression
*/
switch(Number<-3)
{
case 0:
PP1000_LEDState[0] = 0;
break;
case 1:
PP1000_LEDState[1] = 0;
break;
case 2:
PP1000_LEDState[2] = 0;
break;
case 3:
PP1000_LEDState[3] = 0;
break;
case 4:
PP1000_LEDState[4] = 0;
break;
case 5:
PP1000_LEDState[5] = 0;
break;
case 6:
PP1000_LEDState[6] = 0;
break;
case 7:
PP1000_LEDState[7] = 0;
break;
}
}
/*
* Macros to request/release RAM banks
*/
#define PP1000_BANK0 0x1
#define PP1000_BANK1 0x2
#define PP1000_BANK2 0x4
#define PP1000_BANK3 0x8
unsigned 1 PP1000_RAMRequest[4] with { warn = 0 };
interface bus_out() PP1000_RAMRequest0Bus(~PP1000_RAMRequest[0]) with { data = PP1000_Bank0Req, warn = 0 };
interface bus_out() PP1000_RAMRequest1Bus(~PP1000_RAMRequest[1]) with { data = PP1000_Bank1Req, warn = 0 };
interface bus_out() PP1000_RAMRequest2Bus(~PP1000_RAMRequest[2]) with { data = PP1000_Bank2Req, warn = 0 };
interface bus_out() PP1000_RAMRequest3Bus(~PP1000_RAMRequest[3]) with { data = PP1000_Bank3Req, warn = 0 };
interface bus_clock_in(unsigned 1) PP1000_RAMGrant0Bus() with { data = PP1000_Bank0Grant, warn = 0 };
interface bus_clock_in(unsigned 1) PP1000_RAMGrant1Bus() with { data = PP1000_Bank1Grant, warn = 0 };
interface bus_clock_in(unsigned 1) PP1000_RAMGrant2Bus() with { data = PP1000_Bank2Grant, warn = 0 };
interface bus_clock_in(unsigned 1) PP1000_RAMGrant3Bus() with { data = PP1000_Bank3Grant, warn = 0 };
macro proc PP1000RequestMemoryBank(BankMask)
{
macro expr GrantMask = ~(PP1000_RAMGrant3Bus.in @
PP1000_RAMGrant2Bus.in @
PP1000_RAMGrant1Bus.in @
PP1000_RAMGrant0Bus.in);
/*
* Request banks
* Use if statements to allow multiple requests in parallel
* while avoiding parallel writes to registers
*/
par
{
if (BankMask[0])
{
PP1000_RAMRequest[0] = 1;
}
else
{
delay;
}
if (BankMask[1])
{
PP1000_RAMRequest[1] = 1;
}
else
{
delay;
}
if (BankMask[2])
{
PP1000_RAMRequest[2] = 1;
}
else
{
delay;
}
if (BankMask[3])
{
PP1000_RAMRequest[3] = 1;
}
else
{
delay;
}
}
/*
* Wait for requested banks to be granted
*/
while ((GrantMask&BankMask)!=BankMask)
{
delay;
}
}
macro proc PP1000ReleaseMemoryBank(BankMask)
{
/*
* Release requests
* Use if statements to allow multiple requests in parallel
* while avoiding parallel writes to registers
*/
par
{
if (BankMask[0])
{
PP1000_RAMRequest[0] = 0;
}
else
{
delay;
}
if (BankMask[1])
{
PP1000_RAMRequest[1] = 0;
}
else
{
delay;
}
if (BankMask[2])
{
PP1000_RAMRequest[2] = 0;
}
else
{
delay;
}
if (BankMask[3])
{
PP1000_RAMRequest[3] = 0;
}
else
{
delay;
}
}
}
/*
* PLX General Purpose Input/Output
*/
unsigned 1 PP1000_PLXUser=0 with { warn = 0 };
interface bus_out() PP1000_PLXUserInBus(PP1000_PLXUser) with { data = PP1000_PLXUserIn, warn = 0 };
interface bus_clock_in(unsigned 1) PP1000_PLXUserOutBus() with { data = PP1000_PLXUserOut, warn = 0 };
macro proc PP1000SetGPI(Value)
{
PP1000_PLXUser = Value!=0 ? 1 : 0;
}
macro expr PP1000ReadGPO() = PP1000_PLXUserOutBus.in;
/*
* Reset bus
*/
interface bus_clock_in(unsigned 1) PP1000_ResetBus() with { data = PP1000_Reset, warn = 0 };
macro expr PP1000Reset() = ~PP1000_ResetBus.in;
#endif
˙
C:\USER\PETES\PhD\hwgpperf\hwgp.c
/**************************************************************************
* hwgp: Hardware implementation of Genetic Programming. Written in
* Handel-C for compilation to a Xilinx FPGA
*
* Pete Martin 2001
*
***************************************************************************
* This file implements the following versions:
*
* -DHANDELC for compling under handelc, both simulator and edif
* -DDEBUG for compliling for the handelc simulator
* if this is not defined but HANDELC is then it will compile
* for EDIF
*
* -DPOPSIZE Overrides the default population size
* -DMAXPROGLEN Overrides the default maximum progam length
* -DPROBLEM=xxx Set the problem to compile for
* XOR
* ANT
***************************************************************************/
#define VERSION "1.0"
/*#define PRESET*/
#ifndef HANDELC
#include
#include
#include
#include
#include
#include
#include
#include
#include
#else
#ifdef DEBUG
set clock = external "P35";
#else
/*
* Include RC1000-PP support header file
*/
#if defined XC4000
#define BOARD_TYPE PP1000_V2_4000
#define PP1000_CLOCKRATE 10
#define PP1000_CLOCK PP1000_MCLK with {rate=PP1000_CLOCKRATE}
#define PP1000_32BIT_RAMS
#define PP1000_DIVIDE1
#else
#define BOARD_TYPE PP1000_V2_VIRTEX
#define PP1000_CLOCKRATE 40
#define PP1000_CLOCK PP1000_MCLK
#define PP1000_32BIT_RAMS
#define PP1000_DIVIDE4
#endif
#include
#endif /* DEBUG */
#endif /* !HANDELC */
#include
#include
/* Define the internal population storage
* this is a subset of the full population that is held in external
* static RAM. These are used for internal operations.
* There are 2 separate sets of individuals in ram here.
* Each one is used for a different phase of the pipeline
* The working ram is arranged as WORDLEN bit words. The evaluation
* function will decode this into instruction sized chunks as needed.
* MPRAMs are used here, not because we want to access the rams twice in once
* clock cycle, but because this allows better routing performance.
*/
RAM Word workingPop [MAXPHASE*MAXPAR][MAXNODES] WITHBLOCK;
RAM Bool populationControl [POPSIZE] WITHBLOCK;
RAM Word populationFitness [POPSIZE]36016 WITHBLOCK;
RAM Word populationLen [POPSIZE]35954 WITHBLOCK;
/* Storage for the population control information
* This can be processed in parallel with the main population */
RAM Word workingLen [MAXPHASE] [MAXPAR] WITHBLOCK;
RAM PopIndex workingprogNum[MAXPHASE][MAXPAR] WITHBLOCK;
RAM Word workingFitness [MAXPHASE] [MAXPAR] WITHBLOCK;
RAM Word workingParentFitness[MAXPHASE] [MAXPAR] WITHBLOCK;
UINT32 cycles; /* Count of cycles executed in main program */
Bool running; /* Control the measurement of cycles */
#if 1
#if DEBUG
/* Provide some storage for sram if we are using the simulator */
ram UINT32 sram[4][POPSIZE*MAXNODES] WITHBLOCK;
#define RAMW (log2ceil(POPSIZE*MAXNODES))
macro proc PP1000WriteBank0(C_UINT addr, C_UINT val)
{
sram[0][adju(addr,RAMW)]=val;
}
macro proc PP1000WriteBank1(C_UINT addr, C_UINT val)
{
sram[1][adju(addr,RAMW)]=val;
}
macro proc PP1000ReadBank0(C_UINT val, C_UINT addr)
{
val = sram[0][adju(addr,RAMW)];
}
macro proc PP1000ReadControl(x)
{
x=1;
}
macro proc PP1000WriteStatus(x)
{
}
#endif
#if defined ANT
static UINT32 initialMap[32]6784 = {
0x0000000e,
0x00000008,
0x0e000008,
0x21000008,
0x21000008,
0x00601f78,
0x20001000,
0x00101000,
0x00101000,
0x20101000,
0x00100000,
0x00001000,
0x20001000,
0x00101000,
0x1c101000,
0x00820000,
0x00000000,
0x00001000,
0x01011000,
0x08011000,
0x00011000,
0x00011000,
0x04001000,
0x00801000,
0x00010f98,
0x00010002,
0x00010002,
0x00007f02,
0x00000082,
0x00000080,
0x0000003c,
0x00000000,
};
/* The active maps for the evalProgs to use */
RAM UINT32 map[MAXPAR][GRIDX];
/* Init the maps from the initialMap */
macro proc initMap(C_UINT i)
{
unsigned int p;
Bool done;
p = 0;
do {
map[i][p]=initialMap[p]7047;
PAR {
p++;
done = (p == 31);
}
} while(!done);
}
#endif
/*
* Define some control variables
*/
#if !defined HANDELC
Bool tree = 0; /* If true then print program tree */
Bool newseed= 0; /* If true then ANSI_C version will generate seed */
#endif
Bool stopon = 0; /* If true then stop if 100% correct prog */
UINT8 nbreed, nxover, ncopy, nmutate, nrand;
Phase phBreed;
Phase phEval;
Phase phWriteback;
unsigned char good = 0;
int dumpProg = 0;
int dumpFittest = 0;
int dumpLengths = 0;
int verbose = 0;
int dumpFitlen = 0;
/*
* Generic GP function prototypes
*/
macro proc initPop();
macro proc writeBack();
//macro proc writeBackInd(C_UINT phase, C_UINT ind);
//macro proc readIn(C_UINT i, C_UINT ind);
void readIn(PopIndex, WorkIndex);
macro proc findBest(C_UPTR best);
macro proc RandomGen();
macro proc evalProg(C_UINT indx);
macro proc CycleCount();
/*
* output channel
*/
#ifdef HANDELC
/*chanout stdout;*/
chanout Short logout;
macro proc dooutdata(C_UINT c, C_UINT v)
{
#if DEBUG
logout ! (Short)c;
logout ! (Short)v;
#else
PP1000WriteStatus(c);
PP1000WriteStatus(v);
#endif
}
#endif
/********************************************************************
* Random number generator for Handelc
*
* Uses a shift register with taps and feedback
********************************************************************/
#ifdef HANDELC
#define RANDWIDTH 32 /* Number of bits in the generator
This is greater than the biggest number
wanted from the generator*/
#endif
#define TAP1 0
#define TAP2 5
#define TAP3 9
#define TAP4 20
#define TAP5 30
#define TAP6 31
/* Channel for getting the seed */
#ifdef HANDELC
#ifdef SIMULATE
chanin RandReg seedIn with {infile = "c:/tmp/seed.dat"};
chanout RandReg randout with {outfile = "c:/tmp/random.dat"};
#endif
#endif
#if defined HANDELC
/***************************************************************************
* Name: random
*
* Purpose: Generate a pseudo-random number
*
* Inputs: Nothing
*
* Returns: Nothing
*
* Notes: The number is stored in the static variable randReg
*
***************************************************************************/
RandReg randReg; /* The register used for generating the number */
macro proc random()
{
static unsigned int BITW oldbit0;
unsigned int BITW bit0;
par {
bit0 = randReg[TAP1] ^
randReg[TAP2] ^
randReg[TAP3] ^
randReg[TAP4] ^
randReg[TAP5] ^
randReg[TAP6];
/* Shift by using all bits except top bit and adding bit 0 */
randReg = randReg[RANDWIDTH-2:0]@oldbit0;
oldbit0=bit0;
}
}
macro proc RandomGen()
{
while(1) {
random();
}
}
macro proc CycleCount()
{
while(1) {
if(running) {
cycles++;
} else {
delay;
}
}
}
/***************************************************************************
* Name: randseed
*
* Purpose: Seed the random number generator
*
* Inputs: Nothing
*
* Returns: Nothing
*
***************************************************************************/
macro proc randseed()
{
#ifdef SIMULATE
RandReg seed;
seedIn ? seed;
randReg = seed;
#else
PP1000RequestMemoryBank(1);
PP1000ReadBank0(randReg,0);
PP1000ReleaseMemoryBank(1);
#endif
}
/***************************************************************************
* Name: randXXXXX functions
*
* Purpose: Generate random numbers of given widths and limits
*
* Inputs: None
*
* Returns: A random number of the correct width
*
* Notes: Each function requires 1 clock cycle for the random() call
*
***************************************************************************/
/* Return a value that is between 0 and MAXPROGLEN */
macro expr randPC() = 0@randReg[PROGW-1:0];
macro expr randLen() = 0@randReg[PROGW-1:0]|1;
macro proc randMethod(method)
{
#define mask1 0x1f
#define mask2 0xfc
#define mask3 (~mask1)
#define mask4 (~mask2)
UINT8 v, v1, v2, v3, v4;
v = adju(randReg,8);
PAR {
v1 = v&mask1;
v2 = v&mask2;
v3 = v&mask3;
v4 = v&mask4;
method = XOVER; /* Default method */
}
/* This long winded code generates shallow logic as
compared to a long if-then-else chain */
/* Only override if we have the less probable cases */
if(!v3&&v1)
method = MUTATE;
else
delay;
if(!v4&&v2)
method = COPY;
else
delay;
}
macro expr randPopIndex() = randReg[POPW-1:0];
#endif
macro proc PP1000WriteBank0func(C_UINT addr, C_UINT val)
{
UINT32 v;
do {
PP1000WriteBank0(addr, val);
PP1000ReadBank0(v,addr);
} while(v != val);
}
macro proc PP1000WriteBank1func(C_UINT addr, C_UINT val)
{
UINT32 v;
do {
PP1000WriteBank1(addr, val);
PP1000ReadBank1(v,addr);
} while(v != val);
}
macro proc mutate(C_UINT ind)
{
Index address;
Phase ph;
ph = phBreed;
/* Select an instruction to mutate */
address = randPC() & adju(WorkingLenRead(ph,ind), IDXW);
WorkingPopWrite(ph, ind, address, genNode());
#if 0
printf("MASK = 0x%x\n", (FUNCMASK << (REGBITS+REGBITS)) | (REGMASK << REGBITS) | REGMASK);
printf("GETOPCODEMASK = 0x%x\n", FUNCMASK << (REGBITS+REGBITS));
printf("GETEA1MASK = 0x%x\n", (((REGMASK << REGBITS))));
printf("GETEA2MASK = 0x%x\n", (REGMASK));
#endif
}
/* Copy individual at work index w to work index w+1
* w is used directly and is always even (bit 0 == 0) and
w+1 is always odd (bit 0 == 1) */
macro proc copyInd(C_UINT w)
{
Word val;
Index_1 count;
Index i;
Phase ph;
Bool done;
PAR {
i = 0;
count = 0;
ph = phBreed;
}
do {
WorkingPopRead(ph,w, i, C_ADDR val);
WorkingPopWrite(ph,w | 1, i, val);
PAR {
count++;
i++;
done = (count == MAXNODES-1);
}
}while(!done);
}
/* Original saturating crossover */
#if defined TRUNCATE
#warning Truncate method selected
macro proc xover(C_UINT w)
{
Word val, val2;
Word len1;
Word len2;
Word newlen1, newlen2;
PC x1, x2;
PC i1, i2;
Index idx1, idx2;
Index count1, count2;
Phase ph;
ph = phBreed;
/*
* Choose two crossover points at random and get the program lengths
*/
PAR {
x1 = randPC();
len1 = WorkingLenRead(ph,w);
}
PAR {
x2 = randPC();
len2 = WorkingLenRead(ph,w | 1);
}
/*
* Crudely adjust the crossover points so that they lie within the
* individual
*/
PAR {
#if defined BOOLOP
x1 &= adju(len1, PROGW);
x2 &= adju(len2, PROGW);
#else
x1 %= adju(len1, PROGW);
x2 %= adju(len2, PROGW);
#endif
}
/*
* calculate the starting points for crossover
*/
PAR {
i1 = x1;
i2 = x2;
}
/*
* Calculate the count of instructions for copying
* count1 correspnds to individual 1
*/
PAR {
count1 = adju(len1, IDXW) - i1;
count2 = adju(len2, IDXW) - i2;
}
/*
* Copy until both counts have been exhausted
*/
do {
PAR {
idx1 = i1;
idx2 = i2;
}
PAR {
WorkingPopRead(ph, w, idx1, C_ADDR val);
WorkingPopRead(ph,w | 1, idx2, C_ADDR val2);
}
PAR {
WorkingPopWrite(ph,w,idx1, val2);
WorkingPopWrite(ph, w | 1, idx2, val);
}
/*
* Calculate the counts, but don't let them go below zero
* and calculate the next indexes, but don't let them go beyond MAXNODES
*/
PAR {
if(count1)
count1--;
else
delay;
if(count2)
count2--;
else
delay;
if(i1 != MAXPROGLEN-1)
i1++;
else
delay;
if(i2 != MAXPROGLEN-1)
i2++;
else
delay;
}
}while( count1|| count2);
/*
* Adjust the lengths - broken into 2 bits to speedup the logic
*/
PAR {
newlen1 = adju(x1 + (adju(len2,PROGW)), WORDW);
newlen2 = adju(x2 + (adju(len1,PROGW)), WORDW);
}
PAR {
newlen1 = newlen1 - adju(x2, WORDW);
newlen2 = newlen2 - adju(x1, WORDW);
}
// printf("x1=%d x2=%d len1=%d, len2=%d, newlen1=%d, newlen2=%d\n",
// x1,x2,len1,len2,newlen1,newlen2);
#if defined BOOLOP
/* Guard against zero length programs whcih are no good at all */
while(!len1) {
len1 = randLen();
}
while(!len2) {
len2 = randLen();
}
#endif
/* Saturate the sizes to the maximum */
if(newlen1>MAXNODES-1) newlen1=MAXNODES-1;
if(newlen2>MAXNODES-1) newlen2=MAXNODES-1;
PAR {
WorkingLenWrite(ph, w) = newlen1;
WorkingLenWrite(ph, w | 1) = newlen2;
}
}
#elif defined LIMITED
#warning Limiting crossover selected
/* New improved crossover */
macro proc xover(C_UINT w)
{
Word val, val2;
Word len1;
Word len2;
Word olap1, olap2;
PC x1, x2;
PC i1, i2;
Index idx1, idx2;
Index count1, count2;
Phase ph;
Word newlen1, newlen2;
Bool done1, done2;
Bool olapDone1, olapDone2;
ph = phBreed;
do {
/*
* Choose two crossover points at random and get the program lengths
*/
PAR {
x1 = randPC();
len1 = WorkingLenRead(ph,w);
}
PAR {
x2 = randPC();
len2 = WorkingLenRead(ph,w | 1);
}
/*
* Adjust the crossover points so that they lie within the
* individual. This is modulus by remainder.
*/
PAR {
while(x1>=adju(len1,PROGW)) {
x1 -= adju(len1,PROGW);
}
while(x2>=adju(len2,PROGW)) {
x2 -= adju(len2,PROGW);
}
}
/* Get size of new individuals */
newlen1 = adju(x1, WORDW) + (len2 - adju(x2, WORDW));
newlen2 = adju(x2, WORDW) + (len1 - adju(x1, WORDW));
/* See if the newlens are bigger than MAXNODES-1 */
olap1 = newlen1 & ~(MAXNODES-1);
olap2 = newlen2 & ~(MAXNODES-1);
olapDone1 = !(olap1 == 0);
olapDone2 = !(olap2 == 0);
#if defined DUALXOVER
#warning DUAL Xover
} while(olapDone1 || olapDone2);
#else
#warning SINGLE xover
} while(olapDone1 && olapDone2);
#endif
/*
* calculate the starting points for crossover
*/
PAR {
i1 = x1;
i2 = x2;
}
/*
* Calculate the count of instructions for copying
* count1 corresponds to individual 1
*/
PAR {
if(!olap1)
count1 = adju(len2, IDXW) - x2;
else
count1 = 0;
if(!olap2)
count2 = adju(len1, IDXW) - x1;
else
count2 = 0;
idx1 = x1;
idx2 = x2;
}
/*
* Copy until both counts have been exhausted
*/
do {
PAR {
done1 = (count1 == 0);
done2 = (count2 == 0);
}
PAR {
WorkingPopRead(ph, w, idx1, C_ADDR val);
WorkingPopRead(ph,w | 1, idx2, C_ADDR val2);
}
PAR {
if(!done1) {
WorkingPopWrite(ph,w,idx1, val2);
count1--;
idx1++;
}
if(!done2) {
WorkingPopWrite(ph, w | 1, idx2, val);
count2--;
idx2++;
}
}
}while( count1 || count2);
PAR {
if(!olap1)
WorkingLenWrite(ph, w) = newlen1;
if(!olap2)
WorkingLenWrite(ph, w | 1) = newlen2;
}
}
#else
#error Please specify TRUNCATE or LIMITED crossover
#endif
/***************************************************************************
* Name: selection
*
* Purpose: Selects MAXPAR individuals for breeding and copies them from
* external SDRAM into working ram
*
* Inputs: Nothing
*
* Returns: Nothing
*
* Notes: Uses the phSelect to index into the required working memory
* No attempt is made to see if we overselect an individual.
* We only allow individuals that are not in workingPop
*
* The selection is tournament and uses a tournament size of 2.
*
***************************************************************************/
macro proc selection()
{
WorkIndex w;
PopIndex i, i1,i2;
Word fit1,fit2;
Phase ph;
Word fit;
#if defined HANDELCXX && !defined DEBUG
interface fastle(unsigned 1 A_LT_B)
FastLt(Word A=fit1, Word B=fit2) with {busformat="B"};
#endif
PAR {
w = 0;
ph = phBreed;
}
do {
/*
* Find 2 individuals that are not the same and that are not in
* workingPop
*/
do {
i1 = randPopIndex();
fit1 = populationFitness[i1];
} while(populationControl[i1]);
do {
i2 = randPopIndex();
fit2 = populationFitness[i2];
} while(populationControl[i2] || i1 == i2);
/*
* Choose the one with best fitness. 0 is best!
*/
i = UnsignedLt(fit1, fit2, MAXFITW) ? i1 : i2;
/*
* Read it into workingPop and remember the fitness in the parent array
*/
readIn(i,w);
fit = adju(workingFitness[ph][w], WORDW);
workingParentFitness[ph][w] = fit;
w++;
}while(LIMIT(w,MAXPAR));
}
/***************************************************************************
* Name: breed
*
* Purpose: Performs the breeding operations on the working ram pointed to
* by phBreed
* Once this has finished, there will be MAXPAR new individuals
* to evaluate
*
* Inputs: Nothing
*
* Returns: Nothing
*
* Notes: Since crossover and copy use 2 individuals, we arrange for
* all breed operations to operate on 2 individuals.
* This means that there are MAXWORK/2 breed operations.
* The individuals for breeding have already been placed in pairs
* in working memory, at addresses i, i+1
***************************************************************************/
macro proc breed()
{
WorkIndex count1, count2;
WorkIndex_1 loop;
Method method;
#if !defined PRESET
/* Count1 and count2 get incremented twice in the do loop */
PAR {
count1 = 0;
count2 = 0;
loop = 0;
}
do {
/*
* Select breed method
*/
PAR {
randMethod(C_ADDR method);
count2++; /* Now count 2 = count1+1 */
}
xover(count1);
nxover++;
#if 0
switch(method) {
case MUTATE:
mutate(count1);
PAR {
mutate(count2);
nmutate++;
}
break;
case XOVER:
PAR {
xover(count1);
nxover++;
}
break;
default:
PAR {
copyInd(count1);
ncopy++;
}
break;
}
#endif
loop+=2;
}while(!BITSET(loop, MAXPAR));
#endif
}
/***************************************************************************
* Name: replacement
*
* Purpose: Replaces an individual with the newly evaluated individual.
*
* Inputs: The PAR number
*
* Returns: Nothing
*
***************************************************************************/
macro proc replacement()
{
/* Decide whether the evaluated individual will replace
* the corresponding w'th parent */
WorkIndex w;
Phase


Colors
The jQuery brand is an umbrella for a vast family of jQuery products and sub-brands. It is important to preserve the identity of each individual brand while still maintaining its ties to the parent jQuery brand. We've done this by incorporating specific color palettes for each member of the jQuery family.
jQuery Blue
jQuery Primary Blue
- HEX: #0769AD
- CMYK: 96 39 0 32
- RGB: 7 105 173
- Pantone: 3005
jQuery Secondary Blue
- HEX: #7ACEF4
- CMYK: 50 16 0 4
- RGB: 122 206 244
- Pantone: 297
There are two shades of blues that live within the jQuery brand. They are not interchangeable. Each blue has its own purpose and must be respected when representing the jQuery brand.
A. When presenting the jQuery brand on a light background, the proper treatment is to use the primary jQuery blue within the color palette. The primary jQuery blue is deep and strong, and using the primary blue on a light background is the best way to present the jQuery logo and tagline.
B. When presenting the jQuery brand on a dark background, the proper treatment is to use the secondary blue within the color palette. This allows the jQuery mark to be crisp, clear and strong. Also, be sure to keep all type white, including name and tagline, when presenting on a dark background.


{% extends "saas/base_dashboard.html" %} {% block saas_title %} Provider Dashboard {% endblock %} {% block saas_descr %}A section short description{% endblock %} {% block saas_content %} [[entry.slug]] [[entry.full_name]] [[entry.email]] [[entry.created_at | relativeDate]] To do items No items to take care of Today. Today Sales: [[humanizeTotal()]] No sales data yet [[entry.amount]] [[entry.created_at | relativeDate]] Recently registered [[entry.slug]] [[entry.created_at | relativeDate]] {% endblock %}
No items to take care of Today.
No sales data yet


| DOSE: |
7 hits |
smoked |
Cannabis |
(plant material) |
This is about the first time I was REALLY stoned. The first few times I smoked, I didn't feel much but maybe a little giddy. Since this experience, I have gotten stoned many times, but never quite like this.
I was at a friend's house, and we were just talking and having a good time. I suggested we get some weed, so I sprung for a dimebag. The room was lit only with a blacklight and the glow of the TV. I smoked a lot, I would guess about seven hits. I got up off the couch and I felt like I was swimming. I could barely walk. After that, things get hazy, but I left the apartment and went down to mine.
I laid down on my bed and put on my headphones and 'Tomorrow Never Knows' by the Beatles. I was instantly tranported into another world. It vaguely felt like India, but like a desert with strange people with weird clothes walking around in the sand. I closed my eyes and let the music talk to me. I could see the face of John Lennon, and he seemed to be telling me what to do. I heard (or felt) a voice say, 'Music is the language of the universe'. I was thrown into deep, reflecting thought. The line of the song, 'Listen to the color of your dreams' had a similer effect.
The song was sort of fast, so everything in my 'mind-movie' was, like, sped up. Things moved very fast. I got the feeling that I had entered a new world. I could 'see' the music, and be inside the mind of the artists. I felt like I was taking a leap of faith off a cliff, yet overwhelming peace. Overall, it was a 'it's OK' feeling, like no matter what happens, It's gonna turn out fine.
It felt as if a veil was lifted off my mind, and I could see the universe as a whole, and see beauty in everything. I knew that the universe is one, bound together by music and love. I knew that I would always see the world from a slightly different perspective, perhaps a higher one. Since then I have seen order in chaos, and chaos in order. As a musician, I have changed dramatically. Overall, I feel a hightened awareness, and a greater connection with the universe, the earth, and mankind.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


After he was diagnosed with pancreatic cancer, Steve Jobs gave a commencement address at Stanford University titled “How to Live before You Die.”
In that address, Steve Jobs concluded, “Your time is limited, so don’t waste it.. While Steve was specifically referencing “working for someone else,” this basic precept of not “wasting time” is salient.
Yur-Tyme was formed during the Fall of 2014, when a class titled Innovation, Entrepreneurship, and Business Transformation at the Harvard Extension School asked its students to put together an idea and develop an initiative towards pursuing their goals. During brainstorming sessions, our team concluded the greatest waste of time we encounter is waiting in line, so that became our problem to solve. We want to minimize the amount of time spent in waiting line “purgatory” to allow our users and members to increase the amount of time actually doing the things they set out to do!
At the time, I used all the latest and greatest cloud services to design the below backend for yurtyme…
6 years later and the technology landscape widely different how would I alter my approach?


Error: JavaScript is unsupported or disabled. This app can not work as expected without JavaScript.
If you can read this, it is most likely that your browser does not support Web Canvas technology used in this app.
Canvas is empty.
JSON:


--- layout: post title: game theory date: '2016-03-02T13:59:41+01:00' categories: - Illustration picture_url: https://film-Storyboards.tumblr.com/post/140345892421/game-theory ---
Game theory.


VGRABBJ(1) VGRABBJ(1) NAME vgrabbj - grab images from a v4l-compatible webcam SYNOPSIS vgrabbj [options] DESCRIPTION This manual page documents briefly the vgrabbj command. vgrabbj is a program that will grab images from any v4l-capable device which supports one of the rgb24, rgb32, yuv420, yuv420p, yuyv, or yuv422 palettes and saves the image as a .jpg, .png, or .pnm file. Optional, it can timestamp the resulting image, and/or upload it to a ftp-server. Additionally, a daemon-mode is available to do the above reg‐ ularly. On startup, the default configuration file /etc/vgrabbj.conf is read and evaluated. If a configuration file is specified via the -c parameter (see below), that file is read and parsed. Values which are present in the default config file keep their values. Finally, the commandline is eval‐ uated. If an option is presented more than once, the last in the command‐ line is taken. If no options given, vgrabbj tries to open the default v4l-device /dev/video, grab an image and return it on /dev/stdout. So be aware. OPTIONS All options are either numeric values, strings, or booleans. If it is a boolean switch (e.g. no value/string shown after the switch), it plainly switches the current setting of that particular option. Remember, vgrabbj.conf is read first, so any option set to on or off there will be toggled by the commandline switch. -h Show summary of options and version number. -c <filename> Speci‐ fies filename as alternative configuration file. -l <seconds> Daemonize & loop with seconds intervals (min. 1). -L <microseconds> Daemonize & loop microseconds intervals (min. 1). Same as -l except you can control it more precisely. -a Enable vgrabbj's brightness adjustment (default: disabled). To use vgrabbj's brightness adjustment, RGB24 support of the device is necessary. You may have to provide it to your device via the -F parameter (see below). If your device does not support RGB24, this setting is silently ignored. -q <quality> Sets the quality of a jpeg output to quality (1-100, default: 75). -i <imagesize> Sets the imagesize of input device, where imagesize is one of: sqcif= 128x96, qsif = 160x120, qcif = 176x144, sif = 320x240, cif = 352x288, vga = 640x480, svga = 800x600, xga = 1024x768, sxga = 1280x1024, uxga = 1600x1200, (default: cif) -w <width> Sets the width of the image to width. Needs -H. The v4l-device has to support the image width you set with this option. -H <height> Sets the height of the image to height. Needs -w. The v4l-device has to support the image height you set with this option. -o <format> Sets the output to format (either jpeg, png, or pnm, default: jpeg) -f <filename> Output is written to filename (default: /dev/stdout) -A <path+filename> Additional to the output of -f another file is written to the named path+filename, whereas the whole may be formatted according to strftime(2). This enables the creation of an archive of images. Currently, the output is only supported on the same filesystem as the original output. -E <value> Defines how many images shall be read until a copy for the archive is made. E.g. 1 means each image taken is also put in the archive. 5 would mean every fifth image taken is put in the archive. -M <value> Sets the maximum number of images kept in the archive. If you defined 5 seconds for daemon mode, archive every image, you col‐ lect 720 images per hour. If you set this switch to 720 you would keep an hour of images in the archive. -d <device> Sets the input device to device (default: /dev/video) -s <device> This flag causes vgrabbj to print the v4l capabilities of <device> and exit. -C Causes vgrabbj to open the device only while image data is grabbed. This is helpful if you need access to the device besides vgrabbj. It's use is discouraged due to possible problems with memory fragmentation. Default is to keep the v4l-device open while vgrabbj is running. -g Disables setting of the image size (see -i, -H, and -w. Necessary for certain v4l-devices which do not support to be set to a par‐ ticular image size (e.g. IBM-usb-cam, QuickCam). For these devices you have to specify the size at module load time. -S Switches colormap from BGR to RGB (or vice versa). Use if you have odd colors. -R Swaps left and right of the image like a mirror. -U Swaps top and bottom of the image like a mirror (e.g. for upside- down montage of the cam). -G Turns off use of mmap'ed memory. see vgrabbj.conf(5) for details. -D <value> Sets the loglevel of vgrabbj. Valid for value are 0, 2, 3, 4, 6, 7 (default: 4). 0 means no messages at all, 7 is debug. Don't use 7 if you are running vgrabbj in daemon mode, it'll surely fill your syslog. Be aware, that loglevel 7 will also write your ftp-pass‐ word (if defined in vgrabbj.conf(5)) in the logfile! -n Disable the use of the temporary outputfile and write directly to the output-file specified with -f. Output to /dev/stdout is always written directly without the use of a temporary file. If a filename different from /dev/stdout was given with the -f parameter, vgrabbj defaults to use a temporary file called file‐ name.tmp to write the image. This file is then renamed to filename to shorten the time period corrupt data may be read from filename. -F <palette> Force the usage of the specified palette. If palette is not sup‐ ported by either vgrabbj or the v4l-device, fallback to a palette supported by both is provided. If no common denominator is avail‐ able, vgrabbj exits. See DESCRIPTION for details on palettes sup‐ ported by vgrabbj. Possible values are (copy from videodev.h): 1 VIDEO_PALETTE_GREY Linear greyscale 2 VIDEO_PALETTE_HI240 High 240 cube (BT848) 3 VIDEO_PALETTE_RGB565 565 16 bit RGB 4 VIDEO_PALETTE_RGB24 24bit RGB 5 VIDEO_PALETTE_RGB32 32bit RGB 6 VIDEO_PALETTE_RGB555 555 15bit RGB 7 VIDEO_PALETTE_YUV422 YUV422 capture 8 VIDEO_PALETTE_YUYV 9 VIDEO_PALETTE_UYVY 10 VIDEO_PALETTE_YUV420 10 VIDEO_PALETTE_YUV411 YUV411 capture 11 VIDEO_PALETTE_RAW RAW capture (BT848) 12 VIDEO_PALETTE_YUV422P YUV 4:2:2 Planar 13 VIDEO_PALETTE_YUV411P YUV 4:1:1 Planar 14 VIDEO_PALETTE_YUV420P YUV 4:2:0 Planar 15 VIDEO_PALETTE_YUV410P YUV 4:1:0 Planar 16 VIDEO_PALETTE_PLANAR 17 VIDEO_PALETTE_COMPONENT (no default, depends on v4l-device) -z <value> value images are grabbed and immediately discarded. Only the last image is written to the output. This might be helpful if your v4l- device needs to take a couple of images to auto-adjust to the cur‐ rent light. -X Does not fork daemon process and keeps vgrabbj in daemon mode in foreground, attached to the terminal. Useful for debugging pur‐ pose. Not available in config file. HARDWARE CONTROL OPTIONS With the following options you can control the hardware settings of your cam - if it is supported by your cam. Be aware that these options might break your hardware, as there is no check on what values are available, allowed, and supported by your hardware. -W <value> Whiteness definition. -r <value> Color definition. -x <value> Contrast definition. -b <value> Brightness definition. -u <value> Hue definition. TIMESTAMP OPTIONS The following options are available only if vgrabbj was compiled with the freetype library available. If you set any one of these options on the commandline timestamp will be enabled with default values for all other options. -e Switches timestamp to be used or not. Default is off, but may be overridden by config-file, so just try to enable this switch if there is no timestamp in the resulting image. -t <filename> The TrueType font to be used for the timestamp (default /usr/X11R6/lib/X11/fonts/TrueType/Arialn.ttf) -T <size> Set the fontsize to size for timestamp (3-100, default: 12). -p "<format-str>" Defines the timestamp. format-str can be plain text or any strf‐ time format and has to be enclosed with '""' (default: "%a, %e. %B %Y - %T" - see strftime(3) for details) -P <value> Alignment of the timestamp in the image. Possible value: 0 = upper left, 1 = upper right, 2 = lower left, 3 = lower right, 4 = upper center, 5 = lower center (default: 1). -m <value> Defines the blend between font background and image (1-100, default: 60). -B <value> value pixels will be used as border around the timestamp string (1-255, default: 2). FTP OPTIONS There are no options for ftp-upload on the command line. This is due to the need to provide a password which would be visible via the ps(1) com‐ mand. See vgrabbj.conf for details on how to set-up the ftp-upload option. Additionally, vgrabbj has to be compiled with libftp support. BUGS %F in the archive time-string (year with century) causes memory corrup‐ tion at a pentium-machine running vgrabbj (not validated). No further bugs are known at this time. SEE ALSO vgrabbj.conf(4), strftime(3), ps(1) AUTHOR This manual page was originally written by Michael Janssen<EMAIL_ADDRESS>for the Debian GNU/Linux system and enhanced by Jens Gecius<EMAIL_ADDRESS>February 24, 2002 VGRABBJ(1)


{% extends 'base.html' %} {% block content %}
{# TODO (gdingle): fill in link to addgene post #} This guide will show you how to use CrispyCrunch to setup and analyze a CRISPR experiment. For more background, read this blog post on addgene.org.
Create a new experiment by giving it a name. This is the name CrispyCrunch will use to refer to your batch of CRISPR edits.
Design your guide RNAs by inputting the target regions (i.e. the genes you would like to edit). Targets can be input as Ensembl transcript IDs (ENSTxxx), gene names, chromosome locii, or raw FASTA sequences. Each type of input will be translated to other types for versatility.
Optionally override the default genome, guides per target and other settings.
On submission, you may need to wait up to 30 minutes as CrispyCrunch gets candidate guides for each target from Crispor. After all guides are returned, you will have a chance to review them and make modifications.
Optional: Design a donor template for insertion by HDR (Homology Directed Repair).
Inserts can be make just after the start codon or just before the stop codon of a gene. Specify a custom sequence to be inserted, and the desired length of the homolgy arms.
To verify the genomic sequence post-editing, each target locus can be PCR-amplified from genomic DNA fro deep-sequencing analysis. Specify optimal temperature and maximum amplicon length. These values are passed down to Primer3 to design PCR primers.
On submission, you may need to wait up to 10 minutes as CrispyCrunch gets primers for each guide from Crispor. After all primers are returned, you will have a chance to review them and make modifications.
On the summary page, you can see all information gathered so far, and you can download pre-filled excel order forms ready for submission to IDT or other vendors. You can order guides, primers and HDR donor templates in this way.
After a few weeks, once your reagents have arrived, the experiments are ready to be performed. Do what you know how to do!
If you'd like to characterize the targeted loci post-editing, deep sequence your cells and gather the resulting FASTQ files and upload them to a publicly accessible Amazon S3 bucket. If you don't have such an S3 bucket, please contact {{ settings.ADMIN_EMAIL }} for alternatives.
Optional: Choose the experiment you want to analyze. Upload your sequencing files to your S3 bucket if you haven't already. Point CrispyCrunch to the S3 folder that contains from sequencing files associated with the selected experiment.
CrispyCrunch will automatically identify the correct pair of FASTQ files for each sample by comparing the primers in each sequencing sample to the known primers of the experiment.
On submission, you may need to wait up to 45 minutes as CrispyCrunch sends each pair of FASTQ files to Crispresso for analysis. After all reports are returned, you will get a summary page with links to each detailed report.
Crispresso quantifies repair outcomes––both NHEJ and HDR––in a variety of ways that are useful for ensuring that your CRISPR edits occurred as expected.


{% extends "base.html" %} {% block map_data %} {% if maps %} {% for map in maps %} {{map.js}} {% endfor %} {% endif %} {% endblock %} {% block content %}
Location: {{flight.location}}
Notes: {{flight.notes}}
Project: {{project.name}}
Drone: {{drone.name}}
Flight Type: {{flight.flight_type}}
Operation Type: {{flight.operation_type}}
Additional notes on flight type: {{flight.more_type_info}}
Was during night: {{flight.night_flight}}
Duration: {{flight.duration//3600}} hour(s), {{ (flight.duration%3600)//60 }} minute(s), {{ flight.duration%60 }} second(s)
Number of landings: {{flight.landing_count}}
Distance travelled: {{flight.travelled_distance}}
Maximum AGL(above ground level) altitude: {{flight.max_agl_altitude}}
Log # {{log.id}}
#}No logs yet!


Frequently asked questions¶
Please direct your questions or comments to us by raising an issue here and we will try to address them.
Problem:
After a recent rebase with the E3SM V1, the following error occurred in a SCM simulation:
ERROR: ice_open_nc: Cannot open /project/projectdirs/acme/inputdata//share/domains/UNS ET
Answer:
The namelist setting for the input data is not correctly configured.
- Check ice_in in the run directory and see if grid_file, kmt_file, and stream_fldfilename are correctly set.
- SCM is running at T42 originally, so check your cime/config/e3sm/config_grids.xml and/or components/cam/bld/namelist_files/namelist_defaults_cam.xml to see if they have the domain and SST file correctly set.


The quest of Technical Project Exhibition 2019 is to provide a launching pad to all the future engineering superstars to showcase their innovative and unique projects in front of an esteemed panel of judges and peers from all over IEEE Delhi Section.
This technical extravaganza witness projects from various tech-domains like Digital Image Processing (MATLAB), Machine Learning, Artificial Intelligence, Robotics, Android App Development and wireless applications, IoT projects, signal processing and VLSI projects.
The magnificent event organized by IEEE MSIT provides a platform to exceptional ideas and creativity. Every project idea is aimed at creating solutions for a challenging future ahead. One of the major objectives of TPE is to develop affordable technologies that creates an overall positive impact on the society.
All the aspiring participants must send in a brief descriptive account of their respective projects at<EMAIL_ADDRESS>by 11th February 2019. The abstracts will be screened by the honourable judges and the selected entries will be invited for the succeeding rounds.
The teams summoned from the first round will have to deliver a detailed presentation of their projects to the illustrious judges. (No software/hardware demonstration is required for this level)
The teams will have to present a working demonstration of their project or it’s prototype to the eminent panel of judges.
Computer Science Expert
Robotics Expert
Business Development Expert
You are allowed to reach out to the judges and get their opinion on your abstract before you submit it. Your abstract and team profile will be responsible for selection to the next round.
Maharaja Surajmal Institute of Technology
C-4 Janak Puri, New Delhi-110058
(+91)7838765583
(+91)9716720437
ieee@msit.in


transmission environmental model influenza stochastic rate direct persistence Figure avian time epidemic infected number virus breeding wintering dynamics {border-style continuous px;} #ffffff;} ducks population variables (i.e., grounds infection versus virions deterministic infectious â€" birds model. season AIV epidemics infectiousness low model, transmission. viral viruses cholera corresponding critical does parameters presented probability respectively. using wild Dis Infect [], []. chain disease-free equations given larger patterns periodicity populations processes px; rates results shows summer susceptible years zero {font-family (e.g., Markov Text Therefore, Thus, University average community font-size infecteds interval modeling note orbits realizations role series smaller spectrum year Biol Breeding Georgia, Note Press Table conditions disease double; end environment. following however, integrated mechanisms observed outbreaks parameter peaks persist prevalence region set time-average transmissibility wavelet winter (Figure American Avian Fourier However, North Soc [],[] approximation assume bifurcation border-color border-width chicks contribution data defined differential diseases epidemic. epidemics. epidemiological equation explanation exposed extinction human hybrid individuals initial mean-field mechanism new orbit pattern peak power rapid re-scaled shed solid; transition values waterfowl years. zero. {font-style {font-weight ()where (see Dynamics. Grounds Model Panels Sci States United []), analysis bird bold clearance continuous-time courier; density disease-free/endemic duck em; endemic event example, high host increases large left line migration migratory numbers obtained occur pathogenic period plague pool predicts present provides pt;} recovered recurrent scale season, season. similar small temperature transmission, understanding


November 22th, 2019
Data science, data science, and data science. I heard this word for the first time in my sophomore year of high school. Since then, many things have changed in the data science industry. Until 2015 data science was not a big profession, but from 2016 things have changed and now it is one of the highest paid jobs in the market. Why did it get so popular and what do you need to know to become a data scientist?
What is Data Science? It is the study of data. Scientist usually analyzes the data and predict the future in their certain data by using algorithms, programs, and methods. One of the biggest companies, Facebook, uses data science all over it. Facebook uses our data and analyzes the data and gives us advertisements according to our data. If we search a lot about airway tickets, most of our ads will be about travel and flight tickets.
Why did data science get so popular? There is data all over the world and it is even more in the internet world. We need to understand that data and we need to predict what the audience wants and how it will change the future. We need complicated algorithms to solve those problems and to solve those complicated programs and understand the data, we need people with both mathematical knowledge and computer science knowledge. Data science is the stream where people have both math and computer science knowledge.
What skills do you need to be a data scientist? Data Science is one of the highest-paid in the market with around 100k salary. You need various skills to get into data science, few of them are, programming, machine learning, statistics, data visualization, and software engineering. If you are a programmer and if you are interested in becoming a data scientist, Python and R are the most used languages in Data Science, also a solid understanding of machine learning is the key for success. There are tutorials for Python and R all over the internet and there are some paid certifications for Data Science too.


Where can I afford to study?
How much can you spend?
Include unknown cost
Choose the rank
1 to 10
11 to 30
31 to 50
51 to 100
101 and more
Select discipline
Any
Agriculture and Forestry
Applied Sciences and Professions
Arts, Design and Architecture
Business and Management
Computer Science and IT
Education and Training
Engineering and Technology
Environmental Studies and Earth Sciences
Hospitality, Leisure and Sports
Humanities
Journalism and Media
Law
Medicine and health
Natural science
Social science
Results


Notebooks
Story: Words and sentences: names of animals given by Tamme at the museum
Words and sentences: names of animals given by Tamme at the museum
Title
Words and sentences: names of animals given by Tamme at the museum
Collection
Summary
Tamme (and occasionally !nanni) provides Lloyd with the !kun names of animals, birds and insects at the South African Museum.
Comments
1) Inserts on the inside front cover of Book XI & XII-9: pencil and pen script in Lloyd's hand concerning birds and insects, 2) Pages 9682-9757 in this notebook are blank, 3) This is found in Book XI & XII-9
Contributors
Date
20 March 1880 (started)
Categories
Words and sentences, Plants and animals
Keywords
names (of animals given by Tamme at the SA museum) , vocabulary (!kun) , vocabulary (names of animals at the SA museum) , words and sentences (names of animals given by Tamme at the SA museum)
Story Pages
9671-9673, 9675-9681


A fundraiser was launched for the family of Sharon Bithell, who died aged just 44 ten days after she suffered a brain aneurysm.
The mum-of-one passed away as her husband, Dave, underwent life-extending treatment.
'Active' Mrs Bithell, born and bred in Chelmsley Wood, was due to become the breadwinner for the family-of-three as her 55-year-old partner is off sick until next July.
But she died on Thursday, October 24, as the couple had just celebrated their 20th anniversary of being together.
Her husband has been left to raise their 12-year-old son Harry.
Relatives from both sides of the family have moved near to support the father and son and a GoFundMe page was launched to help them.
It smashed its target of £7,000, having raised a total of £10,177 on Wednesday, November 6 to help with day-to-day life.
Tributes flooded in alongside the donations, with people paying tribute to a 'lovely, special' woman.
One friend donated £200 and wrote: "I have great memories of us at toddler group with our babies in Osmington village hall.
"It was so nice to meet someone who was so down to earth and honest and who made me feel at ease!
"You were always the coolest mum at the school gates."
Another said: "Shaz was very special in my life!"
Even strangers took to the page to pitch in what they could.
Joanne Evans shared £100, commenting: "My husband has cancer and there is no treatment. We been married 35 years. He's my soul mate and best friend.
"Nobody really understands until it happens to them. Sorry to hear your sad news of your wife.
"She sounds a lovely person and I'm sure she looking after you and your son. Lots of love to you and your family. Sorry its not a lot but I hope it helps ❤❤"
You can donate to the appeal and help support the tragic family here
The GoFundMe page is crucial as Dave cannot work while undergoing his cancer treatment.
He said: "[The cancer] is incurable so. At some point, I might go into remission.
"One of the consultants said to me: 'If you had this five years ago your chances of survival would be poor, but now its quite likely that we can give you another five years.
"Maybe I might get ten years, I might get five - I might get two, we just don't know."
Catering team leader Sharon attended Lode Heath School.
She completed an apprenticeship at Birmingham's Jewellery Quarter before settling down in Southampton, where she married Dave and gave birth to Harry.
Between chemotherapy sessions and looking after his son, the grieving widower previously told BirminghamLive: "I had the best years of my life with Sharon, we were best friends, we loved each other.
"I absolutely adored her, she was the love of my life and I thought we would have many years together still. We had hope the future."
Paying tribute to his wife, he added: "She was really lovely. She was liked by everyone, very popular. She was very fit and active and a fantastic mum to Harry. At work, she was like a mother figure to a lot of people that worked there.
"It's the last thing we thought would happen"
"Aneurysms just come on really quickly, it can just happen like that - and it did - it just happened out the blue.
"We can't believe it's happened, I'm up and down like a yo-yo, one minute I'm alright, the next I'm in floods of tears. It's like a bad dream. It's the last thing we expected.

An aneurysm is a bulge in a blood vessel caused by a weakness in the blood vessel wall, usually where it branches.

Aneurysms can develop in any blood vessel in the body, but the 2 most common places are:
- the artery that transports blood away from the heart to the rest of the body (the abdominal aorta)
- the brain
This topic is about brain aneurysms.
There's a separate topic about abdominal aortic aneurysm.
Most brain aneurysms only cause noticeable symptoms if they burst (rupture).
This leads to an extremely serious condition known as a subarachnoid haemorrhage, where bleeding caused by the ruptured aneurysm can cause extensive brain damage and symptoms.
Symptoms include:
- a sudden agonising headache – it's been described as a "thunderclap headache", similar to a sudden hit on the head, resulting in a blinding pain unlike anything experienced before
- a stiff neck
- sickness and vomiting
- pain on looking at light
About 3 in 5 people who have a subarachnoid haemorrhage die within 2 weeks.
Half of those who survive are left with severe brain damage and disability.
Find out more about brain aneurysms here.

An aneurysm is a bulge in a blood vessel caused by a weakness in the blood vessel wall, usually where it branches.

Aneurysms can develop in any blood vessel in the body, but the 2 most common places are:
- the artery that transports blood away from the heart to the rest of the body (the abdominal aorta)
- the brain
This topic is about brain aneurysms.
There's a separate topic about abdominal aortic aneurysm.
Most brain aneurysms only cause noticeable symptoms if they burst (rupture).
This leads to an extremely serious condition known as a subarachnoid haemorrhage, where bleeding caused by the ruptured aneurysm can cause extensive brain damage and symptoms.
Symptoms include:
- a sudden agonising headache – it's been described as a "thunderclap headache", similar to a sudden hit on the head, resulting in a blinding pain unlike anything experienced before
- a stiff neck
- sickness and vomiting
- pain on looking at light
About 3 in 5 people who have a subarachnoid haemorrhage die within 2 weeks.
Half of those who survive are left with severe brain damage and disability.
Find out more about brain aneurysms here.
"Sharon was going to be the breadwinner when I was going through all my treatment, so we just didn't have any indication of this happening."
He said Sharon was"fit as a flea" and the aneurysm came on suddenly on Sunday, October 13.
She was airlifted to hospital in Southampton after neighbours gave her CPR.
He said: "It was Sunday she went in and really we knew on the Wednesday that she wasn't going to survive, ten days later."


Send your homework as a single ZIP archive with your files, or send a link to your GitHub repo. Try to keep line lengths below 80 characters.
Create a long positive integer. Find the number of zeros. Hint: change the number to a string.
# Explain the results. x = 5 x == 5 and 3 # 3 x == 4 and 3 # False 3 and x == 5 # True 3 and x == 4 # False isinstance(True, int) # True isinstance(True, bool) # True
Find the sum 1*1 + 3*3 + 5*5 + ... + 2021*2021 [hint: use sum()].
(a) Find Unicode code points (int) for all characters of your name. Example: "Andrzej" --> [65, 110, 100, 114, 122, 101, 106]
(b) Prepare the periodic table (ten elements) as a list pt = [(1,"Hydrogen","H",1), (2,"Helium","He",4), ...]. Use pt to print a table (3 right + 20 left + 6 center + 10 right) +---+--------------------+------+----------+ |No.|Name (en) |Symbol|Weight (u)| +---+--------------------+------+----------+ | 1|Hydrogen | H | 1| | 2|Helium | He | 4| | | ... | | | +---+--------------------+------+----------+
Let S be a long string (many lines).
Find the number of black characters in S [not whitespace, see the method S.isspace()].
Find the number of words in S (a word is a sequence of black characters).
Find the longest word in S.
Sort words from S according to (1) the lexicographic order, (2) the length.
# Find and explain the results. t = (2, 4) print(t[2]) t.append(6) a, b = t ; print(a, b)
Create a dict for conversion of roman numerals/strings (I, IV, V, IX, X, XL, L, XC, C, CD, D, CM, M) to arabic numbers. Use different methods.


Choose a Type of Cheese
Cheddar One
American Cheese
Monterey Jack
Mozzarella
Parmesan
Pepperjack Cheese
Provolone Cheese
Swiss Cheese
Cheddar Two
Next
free html templates


Constitutive activation of NF-kB in human thymocytes.
Abstract
NF-kB is a eukaryotic transcription regulatory factor. In T cells and T cell lines, NF-kB is bound to a cytoplasmic proteic inhibitor, the IkB. Treatment of T cells with mitogens (phorbol esters) or cytokines (TNF alpha) induces NF-kB nuclear translocation and the subsequent expression of NF-kB dependent T cell genes. Here we examined the activation of NF-kB in human T cell thymic progenitors. We report differences in (Ca2+) i requirement for NF-kB activation in thymocytes as compared to mature T cells. Furthermore, our results indicated that thymocytes have a constitutively active form of NF-kB, suggesting that they are activated in vivo.


Located on the southern coast of Madeira, Funchal is a popular port of call for cruise ship. It lies in a bowl with a dramatic mountain backdrop. It has many spectacular festivals, the foremost of which is that held on New Years Eve.
 Formalities are completed at the reception dock, immediately to starboard on entrance to the marina. Note this dock is low and only really suitable for boats up to 13m.
Officers from Guarda Fiscal (Customs) and Policia Maritima (Immigration) are here daily. If there is no space to come alongside, boats should anchor in the outer harbour and visit the office by dinghy. The Guarda Fiscal will issue a transit log to non-EU yachts arriving from outside of Madeira. Even if coming from Porto Santo, the clearance procedure must still be completed. On departure the marina office and all other officials must be visited.
Last updated December 2015.
Docking facilities for visitors in the main harbour at Funchal are not very comfortable as there are no pontoons available, and boats have to raft to the quay walls. Larger boats over 13m will find it hard to find space here. Turning room is very tight.
During the busy months of October and November, if wishing to moor here, anchoring in the centre of the harbour may be the only option. Note that during public holidays there are no dockmasters available. An increasing number of cruise ships are calling here, to encourage this, and to allow the docking of even larger vessels, the commercial activities are being moved to Canical, to the east of Funchal.
A more comfortable and secure berth can now be found in the new marina at Quinta do Lorde, 2 nm from Canical, at the eastern end of the island. The approaches to this marina can be easily identified by the wind farm on the land to the west of the entrance.
Last updated March 2016.
Visiting yachtsmen are welcome at the club (Clube Naval do Funchal), which is rather far from the harbour, although the club maintains a base next to the marina.


Music Settings
New Feature
Manage how skipping music will directly work.
| Any | Any user is able to skip the music reguardless |
| Queuer Only | Only the Queuer can skip or a DJ. If the user is no longer in the voice channel, it will be treated as Any |
| Voting | A users in the voice channel must vote by skipping and will do so when the voting percentage is reached. |
| No Skipping | Nobody will be able to skip unless the user has left the voice channel or a DJ skips |
| Skipless | Nobody, even DJs will be able to skip. The song will not be skipped if the user has left either |
New Feature
User ids for DJs. When this is enabled, this also allows for DJs to be able to get full control of all music features such as forcing skips and moving channels when it is playing
New Feature
When DJs are enabled, they will have full control over the Music function of Welcomer. To add new DJs, add their ID above in Music DJs
New Feature
Percentage of users who need to vote before it is skipped. This is only taken into effect if Voting has been set as the skip type. If the threshold is 100, every user would require to do a skip. It is recommended you do 50%


fakeroot(1) Debian manual fakeroot(1) NAME fakeroot - run a command in an environment faking root privileges for file manipulation SYNOPSIS fakeroot [-l|--lib library] [--faked faked-binary] [-i load-file] [-s save-file] [-u|--unknown-is-real ] [-b|--fd-base ] [-h|--help ] [-v|--version ] [--] [command] DESCRIPTION fakeroot runs a command in an environment wherein it appears to have root privileges for file manipulation. This is useful for allowing users to create archives (tar, ar, .deb etc.) with files in them with root permis‐ sions/ownership. Without fakeroot one would need to have root privileges to create the constituent files of the archives with the correct permis‐ sions and ownership, and then pack them up, or one would have to con‐ struct the archives directly, without using the archiver. fakeroot works by replacing the file manipulation library functions (chmod(2), stat(2) etc.) by ones that simulate the effect the real library functions would have had, had the user really been root. These wrapper functions are in a shared library /usr/lib/libfakeroot.so* which is loaded through the LD_PRELOAD mechanism of the dynamic loader. (See ld.so(8)) If you intend to build packages with fakeroot, please try building the fakeroot package first: the "debian/rules build" stage has a few tests (testing mostly for bugs in old fakeroot versions). If those tests fail (for example because you have certain libc5 programs on your system), other packages you build with fakeroot will quite likely fail too, but possibly in much more subtle ways. Also, note that it's best not to do the building of the binaries them‐ selves under fakeroot. Especially configure and friends don't like it when the system suddenly behaves differently from what they expect. (or, they randomly unset some environment variables, some of which fakeroot needs). OPTIONS -l library, --lib library Specify an alternative wrapper library. --faked binary Specify an alternative binary to use as faked. [--] command Any command you want to be ran as fakeroot. Use ‘--’ if in the command you have other options that may confuse fakeroot's option parsing. -s save-file Save the fakeroot environment to save-file on exit. This file can be used to restore the environment later using -i. However, this file will leak and fakeroot will behave in odd ways unless you leave the files touched inside the fakeroot alone when outside the environment. Still, this can be useful. For example, it can be used with rsync(1) to back up and restore whole directory trees complete with user, group and device information without needing to be root. See /usr/share/doc/fakeroot/README.saving for more details. -i load-file Load a fakeroot environment previously saved using -s from load- file. Note that this does not implicitly save the file, use -s as well for that behaviour. Using the same file for both -i and -s in a single fakeroot invocation is safe. -u, --unknown-is-real Use the real ownership of files previously unknown to fakeroot instead of pretending they are owned by root:root. -b fd Specify fd base (TCP mode only). fd is the minimum file descriptor number to use for TCP connections; this may be important to avoid conflicts with the file descriptors used by the programs being run under fakeroot. -h Display help. -v Display version. EXAMPLES Here is an example session with fakeroot. Notice that inside the fake root environment file manipulation that requires root privileges suc‐ ceeds, but is not really happening. $ whoami joost $ fakeroot /bin/bash # whoami root # mknod hda3 b 3 1 # ls -ld hda3 brw-r--r-- 1 root root 3, 1 Jul 2 22:58 hda3 # chown joost:root hda3 # ls -ld hda3 brw-r--r-- 1 joost root 3, 1 Jul 2 22:58 hda3 # ls -ld / drwxr-xr-x 20 root root 1024 Jun 17 21:50 / # chown joost:users / # chmod a+w / # ls -ld / drwxrwxrwx 20 joost users 1024 Jun 17 21:50 / # exit $ ls -ld / drwxr-xr-x 20 root root 1024 Jun 17 21:50 // $ ls -ld hda3 -rw-r--r-- 1 joost users 0 Jul 2 22:58 hda3 Only the effects that user joost could do anyway happen for real. fakeroot was specifically written to enable users to create Debian GNU/Linux packages (in the deb(5) format) without giving them root privi‐ leges. This can be done by commands like dpkg-buildpackage -rfakeroot or debuild -rfakeroot (actually, -rfakeroot is default in debuild nowadays, so you don't need that argument). SECURITY ASPECTS fakeroot is a regular, non-setuid program. It does not enhance a user's privileges, or decrease the system's security. FILES /usr/lib/libfakeroot/libfakeroot.so* The shared library containing the wrapper functions. ENVIRONMENT FAKEROOTKEY The key used to communicate with the fakeroot daemon. Any program started with the right LD_PRELOAD and a FAKEROOTKEY of a running daemon will automatically connect to that daemon, and have the same "fake" view of the file system's permissions/ownerships. (assuming the daemon and connecting program were started by the same user). LD_LIBRARY_PATH LD_PRELOAD Fakeroot is implemented by wrapping system calls. This is accom‐ plished by setting LD_LIBRARY_PATH=/usr/lib/fakeroot and LD_PRELOAD=libfakeroot.so.0. That library is loaded before the system's C library, and so most of the library functions are intercepted by it. If you need to set either LD_LIBRARY_PATH or LD_PRELOAD from within a fakeroot environment, it should be set relative to the given paths, as in LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/foo/bar/ LIMITATIONS Library versions Every command executed within fakeroot needs to be linked to the same version of the C library as fakeroot itself. open()/create() fakeroot doesn't wrap open(), create(), etc. So, if user joost does either touch foo fakeroot ls -al foo or the other way around, fakeroot touch foo ls -al foo fakeroot has no way of knowing that in the first case, the owner of foo really should be joost while the second case it should have been root. For the Debian packaging, defaulting to giving all "unknown" files uid=gid=0, is always OK. The real way around this is to wrap open() and create(), but that creates other problems, as demonstrated by the libtricks package. This package wrapped many more functions, and tried to do a lot more than fakeroot . It turned out that a minor upgrade of libc (from one where the stat() function didn't use open() to one with a stat() function that did (in some cases) use open()), would cause unexplainable segfaults (that is, the libc6 stat() called the wrapped open(), which would then call the libc6 stat(), etc). Fixing them wasn't all that easy, but once fixed, it was just a matter of time before another function started to use open(), never mind trying to port it to a different operating system. Thus I decided to keep the number of functions wrapped by fakeroot as small as possible, to limit the likelihood of ‘collisions’. GNU configure (and other such programs) fakeroot, in effect, is changing the way the system behaves. Pro‐ grams that probe the system like GNU configure may get confused by this (or if they don't, they may stress fakeroot so much that fakeroot itself becomes confused). So, it's advisable not to run "configure" from within fakeroot. As configure should be called in the "debian/rules build" target, running "dpkg-buildpackage -rfakeroot" correctly takes care of this. BUGS It doesn't wrap open(). This isn't bad by itself, but if a program does open("file", O_WRONLY, 000), writes to file "file", closes it, and then again tries to open to read the file, then that open fails, as the mode of the file will be 000. The bug is that if root does the same, open() will succeed, as the file permissions aren't checked at all for root. I choose not to wrap open(), as open() is used by many other functions in libc (also those that are already wrapped), thus creating loops (or pos‐ sible future loops, when the implementation of various libc functions slightly change). COPYING fakeroot is distributed under the GNU General Public License. (GPL 2.0 or greater). AUTHORS joost witteveen<EMAIL_ADDRESS>Clint Adams<EMAIL_ADDRESS>Timo Savola MANUAL PAGE mostly by J.H.M. Dassen<EMAIL_ADDRESS>Rather a lot mods/additions by joost and Clint. SEE ALSO faked(1) dpkg-buildpackage(1), debuild(1) /usr/share/doc/fakeroot/DEBUG Debian Project 6 August 2004 fakeroot(1)


The standard way to show the relationship between two continuous variables, each of which has its own axis.Note this template doesn't currently produce a size key; this needs to be done in Illustrator
Non-responsive chart
Responsive image set


I enjoy traveling and watching basketball and football
I am also a fan of the artsit i enjoy singing in the shower
| Books | Movies | Games |
|---|---|---|
| Rich Poor and Ratchet | Coming To America | Fight Night Boxing |
| Digital Minilism | The Talent Mr Ripley | Madden Football 2013 |
| Kobe Bryant | American Beauty | Call of Duty |


JavaScript Number Guessing Game
Create a random generated number between 1 - 10
Guess which number it is
Enter a number


?PLANTS
OF
CUBA
PROVINCE
OF
SANTA
CLARA
Jasminum
fluminense
Veil.
Det.:
P.
A.
González
/
Holguin-
Cuba;
VI-
2005
Jasminum
Climbing
on
garden
fence.
Naturalized
FIs.
white,
fruit
tolaok
Jasminum
fluminense
Veil
NEW
YORK
BOTANICAL
GARDEN
KarohS,
1929
oltriRA,
500-800
FT.
ALT.
Collected
for
the
Arnold
Arboretum
by
J.
G.
Jack.
01497849
det.
RICHARD
A.
HOWARD
0
1
The
New
York
copyright
reserved
botanical
Garden
01497849
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


| forums | owner | date | status |
|---|
| Topics | owner | date | status |
|---|
| replies |
|---|
| picture | username | date reg | role | status |
|---|
Please fill info under to register!
Please fill info under to login!
Fill data bellow to add new forum!
| forums | owner | date | status |
|---|
| Topics | owner | date | status |
|---|
| replies |
|---|
| picture | username | date reg | role | status |
|---|
Please fill info under to register!
Please fill info under to login!
Fill data bellow to add new forum!
Edit data bellow to edit this forum!
Advanced Search


"""
measure.py
molssi workshop: A python package for analyzing and visualizing xyz file.
Handles the calculations like bonds and angles
"""
import numpy as np
from .atom_data import atomic_weights
[docs]def calculate_distance(r_A, r_B):
"""
Calculate the distance between two points given as numpy arrays.
Parameters
----------
r_A, r_B : np.ndarray
The coordinates of points A and B.
Returns
-------
distance : float
The distance between the two points A and B.
Examples
--------
>>> r1 = np.array([1, 0, 0])
>>> r2 = np.array([3, 0, 0])
>>> calculate_distance(r1, r2)
2.0
"""
if not isinstance(r_A, np.ndarray) or not isinstance(r_B, np.ndarray):
raise TypeError("Input must be of type np.ndarray for calculate_distance function!!!")
distance_vector = (r_A - r_B)
distance = np.linalg.norm(distance_vector)
return distance
[docs]def calculate_angle(r_A, r_B, r_C, degrees=False):
# Calculate the angle between three points. Answer is given in radians by default, but can be given in degrees
# by setting degrees=True
AB = r_B - r_A
BC = r_B - r_C
theta = np.arccos(np.dot(AB, BC)/(np.linalg.norm(AB)*np.linalg.norm(BC)))
if degrees:
return np.degrees(theta)
else:
return theta
def calculate_molecular_mass(symbols):
"""Calculate the mass of a molecule.
Parameters
----------
symbols : list
A list of elements.
Returns
-------
mass : float
The mass of the molecule
"""
mass = 0
for i in range(len(symbols)):
mass = mass + atomic_weights[symbols[i]]
return mass
[docs]def calculate_center_of_mass(symbols, coordinates):
"""Calculate the center of mass of a molecule.
The center of mass is weighted by each atom's weight.
Parameters
----------
symbols : list
A list of elements for the molecule
coordinates : np.ndarray
The coordinates of the molecule.
Returns
-------
center_of_mass: np.ndarray
The center of mass of the molecule.
Notes
-----
The center of mass is calculated with the formula
.. math:: \\vec{R}=\\frac{1}{M} \\sum_{i=1}^{n} m_{i}\\vec{r_{}i}
"""
total_mass = calculate_molecular_mass(symbols)
mass_array = np.zeros([len(symbols), 1])
for i in range(len(symbols)):
mass_array[i] = atomic_weights[symbols[i]]
center_of_mass = sum(coordinates * mass_array) / total_mass
return center_of_mass


Akan names are derived from Ghanian culture
Frequently in Ghana, children are given their first name as a 'day name'...
which corresponds to the day in the week they were born. Here are Ghanian day names.


13-Jul-2017 | Milku
It's the day for doing it and no one should complain.
I have to admit that I like technology...not as much as I like snacks and treats, but gadgets are high on the list of things I enjoy. And I don't like to conform to hamster norms. What is it with hamsters liking to run on exercise wheels? That's not for me! But I do have my little obsessions...when I get to know you better I might share them with you. Who knows, you might like them too and we can be geeks together...
On Embrace Your Geekness Day, it's time to celebrate everything that sets you apart.
Be proud that you can recite the scripts of every Star Wars film word for word. Get out your costumes and battle for the Empire...even if you are a little short for a storm trooper...Or simply turn to your nearest and dearest and wax lyrical about the properties of cement.
Forgive me if I ignore you. I'm going to settle down with my Warehouse 13 box set and memorise all the artifacts that are stored in there.


Finances summary
| Total costs | % Grant | Funding sought | Other public sector funding | Contribution to project | |
|---|---|---|---|---|---|
|
Lead organisation
Partner
|
|||||
| Total |


--- layout: post status: publish published: true title: Not much content lately author: display_name: Tomas Restrepo login: tomasr email<EMAIL_ADDRESS>url: http://winterdom.com/ author_login: tomasr author_email<EMAIL_ADDRESS>author_url: http://winterdom.com/ wordpress_id: 492 wordpress_url: http://winterdom.com/2003/09/notmuchcontentlately date: '2003-09-28 09:33:11 +0000' date_gmt: '2003-09-28 09:33:11 +0000' categories: - Personal tags: [] comments: [] ---
As many of you have probably noticed (yes, all of you three that actually read this :)), I haven't been posting much lately. The reasons? A lack of time (too busy), not having anything really interesting to say, and the fact I've been feeling a little burned out lately. Hopefully this will improve now, but I'll just have to wait and see how it goes.


fma
, fmaf
—floating multiply addSynopsis
#include <math.h> double fma(double x, double y, double z); float fmaf(float x, float y, float z);
Description
The fma
functions compute (x * y) + z, rounded as one ternary
operation: they compute the value (as if) to infinite precision and round once
to the result format, according to the rounding mode characterized by the value
of FLT_ROUNDS. That is, they are supposed to do this: see below.
Returns
The fma
functions return (x * y) + z, rounded as one ternary
operation.
Bugs
This implementation does not provide the function that it should, purely
returning "(x * y) + z;" with no attempt at all to provide the
simulated infinite precision intermediates which are required. DO NOT USE THEM.
If double has enough more precision than float, then fmaf
should provide
the expected numeric results, as it does use double for the calculation. But
since this is not the case for all platforms, this manual cannot determine
if it is so for your case.
Portability
ANSI C, POSIX.