I'm a student learning responsive web design ! Welcome to my little corner of the web!
I'm a student learning responsive web design ! Welcome to my little corner of the web!
I'm from south Louisiana, right in the heart of Cajun country. I'm currently based out of the sunny midwest! I am a jack of all trades, and absolutely love learning new things! My hobbies span from photography, reading, yoga, traveling, camping, hiking, dancing, painting, and more!
I started my coding journey a few years ago, and after doing some self-teaching, I signed up for Skillcrush this year and never looked back! Learning to code has proven to be one of the most interesting pursuits, it is an ever-changing field. There is always something new to learn, and coding is never boring!
I started my coding journey making simple html and CSS websites. Lately I am focusing more on responsive web design. I want to create websites for clients that look beautiful no matter from what device their website is being viewed! Next up is Javascript and delving more into Wordpress. I can't wait!


Anxiety Disorder
Anxiety Disorders affect about 18% of the general population. This condition causes fearfulness and uncertainty. Anxiety disorders commonly occur along with other mental or physical illnesses.
Some major types of Anxiety Disorders include:
Obsessive Compulsive Disorder,
Social Anxiety Disorder (social phobia),
Post-traumatic Anxiety Disorder, and
specific phobias.
Obsessive Compulsive Disorder has been identified as the most common of the Anxiety Disorders to co-occur with TS. Others occur with less frequency.


This Tipperary town wants to keep on improving itself! Can you help?
Fethard Community Council wish to gather the opinions of the residents of Fethard with a view to further improving the Town.
While a lot has been achieved over the years, we now consider it an opportune time to plan for the future. In order to do this we want to involve you from the start.
As a first step, we invite you to take a few minutes to complete our short survey. Forms will be delivered to your home by a member of the Community Council or a person from your area.
You can also access the form through any of the Fethard Clubs and Organisations.
We hope that each person in your household will fill-in an individual form.
TOTALLY ANONYMOUS
All answers will be treated as anonymous. We aim to collect the forms in the coming days.
If you would prefer, you can access the Form at the Town Hall or online at Fethard.com website.
All we are asking you to do is to list the following:
Things I DISLIKE about Fethard;
Things I LIKE about Fethard;
My IDEAS TO IMPROVE Fethard.
All these opinions will be collated and based on this. After further consultations, we can start planning for new projects for the Town.
Remembering Tipperary's Road Traffic Victims at Memorial Mass in Fethard


Extracting data on a specific region¶
The main aim of this library is to facilitate the extraction of knowledge over a specific region at the lunar surface. For the moment, only topography and images are available but more should come in the future.
This module is composed of three different class which I briefly detail in the following.
BinaryTable¶
This class allows to read binary file from the PDS site to retrieve the desired information.
The different possible binary files are all the ldem files listed here LRO/LOLA ldem for topography and all the images listed here LROC/WAC wac for WAC images.
For instance, if you want to read the information contained in ldem_512_90s_45s_090_180.img, simply load it in a variable called ldem here for the example:
from PDS_Extractor import BinaryTable
ldem = BinaryTable('ldem_16')
If the file is not already on your computer, the program is going to ask if you want to download it on the fly. Be careful with the size of high resolution image though, the download can take a few minutes !
When creating the object, the class store information contained in the header, either a separate .lbl file for files on the LRO/LOLA ldem or contained in the .img file for files on the LROC/WAC wac. All information can be access as attribute of the object.
However, the class does not load the data contained in the image during initialization. PDS images can be very large and resolution higher than 16 pixel per degree (ppd) usually do not fit into memory if you want to load the full image.
In agreement, the class proposed two methods to extract the data:
- extract_all which extract the whole image. Again, make sure that information will fit into your computer memory.
- extract_grid which extract the data contained in a window defined by its latitude/longitude boundaries.
In addition, the class proposed two methods than can give the latitude/longitude boundaries given a center long/lat point and a radius:
- lambert_window will return square Lambert Azimuthal equal area projection of the region and
- cylindrical_window will return the simple cylindrical projection of the region.
For instance, taken the object ldem
we have just created, we can
ask to get the data covering a region centred at (120 E, 60S) spanning
a radius of 5 km by simply taping:
boundary = ldem.lambert_window(5,-60,120)
X,Y,Z = ldem.extract_grid(*boundary)
By default, if the given regime boundaries end up outside of the map, the class will re-size them so that they correspond to the image boundary. This should not happen for resolution smaller than 64 ppd as each image contains the whole lunar surface though.
However, for large resolution, the lunar surface is cut off in many subregions, i.e. subimages of reasonable size and it can be annoying to identify which one is relevant for the particular region of interest.
For this reason, this module also integrated two other class, one specialized in the topography and one specialized for images, that should be preferred to BinaryTable.
WacMap¶
WacMap is class which handle the treatment of WAC images. Indeed, getting an image over a specific region at the lunar surface can be annoying, you have to:
- Identify the region of interest.
- Identify the relevant img file ( possibly multiple due to overlap).
- Load the information about each img files to be able to read the binary record into it.
- Extract the data from the binary record.
With WacMap, you basically only need to feed it an input region and a desired resolution, and it does all that work for you.
For instance, for an image with a resolution of 512 ppd centred centred at (120 E, 60S) spanning a radius of 20 km, I simply use:
from PDS_Extractor import WacMap
boundary = ldem.lambert_window(20,-60,120)
wac_image = WacMap(512,*boundary)
X,Y,Z = wac_image.image()
with X
containing the array of longitude where data exist, Y
the latitudes and Z
the information about the wac image itself. If
you want to take a rapid look, just try:
import matplotlib as plt
plt.imshow(Z)
LolaMap¶
Same for the topography !
Say we’d like to overlap our nice images with the topography to get a beautiful image to show off with, simply add:
from PDS_Extractor import LolaMap
ldem_image = LolaMap(512,*boundary)
Xl,Yl,Zl = ldem_image.Image()
Now, you can simply overlay Zl and Z to get it. While the
PDS_Extractor
is designed to facilitate the extraction of data
(X,Y,Z) arrays, the library also contained a second module that you
can also use if you want to make beautiful images Structure
.
Index¶
-
class
pdsimage.PDS_Extractor.
BinaryTable
(fname, path_pdsfile='/Users/thorey/miniconda2/envs/bayescrat/lib/python2.7/site-packages/pdsimage/PDS_FILES')¶ Bases:
object
Class to read image binary file from the LRO experiment
For the moment, it can gather information about the topography (from LRO LOLA experiment) and texture (from the LRO WAC experiment). More information about the Lunar Reconnaissance Orbiter mission (LRO) can be found here
LRO LOLA - Informations can be found at LRO/LOLA website. In particular, the header, located in a separate file .LBL file, contains all the informations.
LROC WAC - Informations can be found at LROC/WAC website. In particular, HEADER in the binary file that contain all the information - Read with the module pvl module for informations about how the header is extracted directly from the file.
This class has a method able to download the images, though it might be better to download them before as it takes a lot of time, especially for large resolution.
Both are NASA PDS FILE - Meaning, they are binary table whose format depends on the file. All the information can be found in the Header whose reference are above. Line usualy index latitude while sample on the line refers to longitude.
 PROJECTION : [WAC : ‘EQUIRECTANGULAR’, LOLA : ‘“SIMPLE”’] FURTHER WORK IS NEEDED FOR IT TO BECOMES MORE GENERAL.
Parameters: - fname (str) – Name of the image.
- path_pdsfiles (Optional[str]) –
Path where the pds files are stored. Defaults, the path is set to the folder
PDS_FILES
next to the module files where the library is install.See
defaut_pdsfile
variable of the class
-
fname
¶ str – Name of the image.
-
path_pdsfiles
¶ str – path where the pds files are stored.
-
lolapath
¶ str – path for LOLA images
-
wacpath
¶ str – path for WAC images
-
grid
¶ str – WAC or LOLA
-
img
¶ str – name of the image
-
lbl
¶ str – name of the lbl file, where information are stored. Empty for WAC.
Note
It is important to respect the structure of the PDS_FILES folder. It should contain 2 subfolder called
LOLA
andLROC_WAC
where the corresponding images should be download.I also integrate all the specification of the image contained in the header or the .LBL file as attribute of the class. However, the list is long and I do not introduce them into the documentation. See the file directly for details.
The abreaviations correspond to:
- LRO Lunar Reconnaissance Orbiter
- LOLA Lunar Orbiter Laser Altimeter
- LROC Lunar Reconnaissance Orbiter Camera
- WAC Wide Angle Camera
-
array
(size_chunk, start, bytesize)¶ Read part of the binary file
Parameters: - size_chunk (int) – Size of the chunk to read
- start (int) – Starting byte
- bytesize (int) – Ending byte
Returns: array of the corresponding values
Return type: (np.array)
-
boundary
()¶ Get the image boundary
Returns: A tupple composed by the westernmost_longitude, the westernmost_longitude, the minimum_latitude and the maximum_latitude.
-
cylindrical_window
(radius, lat0, long0)¶ Cylindrical projection of a window centered at (lat0, long0) with a given radius (km).
Parameters: - radius (float) – Radius of the window (km).
- lat0 (float) – Latitude at the center (degree).
- long0 (float) – Longitude at the center (degree).
Returns: A tuple
(longll, longtr, latll, lattr)
withlongll
the longitude of the lower left corner,longtr
the longitude of the top right corner,latll
the latitude of the lower left corner andlattr
the latitude of the top right corner.Note
All return coordinates are in degree
-
defaut_pdsfile
= '/Users/thorey/miniconda2/envs/bayescrat/lib/python2.7/site-packages/pdsimage/PDS_FILES'¶
-
extract_all
()¶ Extract all the image
Returns: A tupple of three arrays (X,Y,Z)
withX
contains the longitudes,Y
contains the latitude andZ
the values extracted from the image.Note
All return arrays have the same size.
All coordinate are in degree.
-
extract_grid
(longmin, longmax, latmin, latmax)¶ Extract part of the image
img
Parameters: - longmin (float) – Minimum longitude of the window
- longmax (float) – Maximum longitude of the window
- latmin (float) – Minimum latitude of the window
- latmax (float) – Maximum latitude of the window
Returns: A tupple of three arrays
(X,Y,Z)
withX
contains the longitudes,Y
contains the latitude andZ
the values extracted from the window.Note
All return arrays have the same size.
All coordinate are in degree.
-
lambert_window
(radius, lat0, long0)¶ Square Lambert Azimuthal equal area projection of a window centered at (lat0, long0) with a given radius (km).
Parameters: - radius (float) – Radius of the window (km).
- lat0 (float) – Latitude at the center (degree).
- long0 (float) – Longitude at the center (degree).
Returns: A tuple
(longll, longtr, latll, lattr)` with ``longll
the longitude of the lower left corner,longtr
the longitude of the top right corner,latll
the latitude of the lower left corner andlattr
the latitude of the top right corner.Note
All return coordinates are in degree
-
lat_id
(line)¶ Return the corresponding latitude
Parameters: line (int) – Line number Returns: Correponding latitude in degree
-
line_id
(lat)¶ Return the corresponding line
Parameters: lat (int) – latitude in degree Returns: Correponding line
-
long_id
(sample)¶ Return the corresponding longitude
Parameters: sample (int) – sample number on a line Returns: Correponding longidude in degree
-
sample_id
(lon)¶ Return the corresponding sample
Parameters: lon (int) – longidute in degree Returns: Correponding sample
-
class
pdsimage.PDS_Extractor.
LolaMap
(ppd, lonm, lonM, latm, latM, path_pdsfile='/Users/thorey/miniconda2/envs/bayescrat/lib/python2.7/site-packages/pdsimage/PDS_FILES')¶ Bases:
pdsimage.PDS_Extractor.WacMap
Class to handle the creation of LRO LOLA images
This class is specifically designed to handle the creation of image from LOLA images. It is able to identify the image (or the groupe of images) necessary to extract an array over a given window. Four cases are possible and taken care of:
- The desired structure is entirely contained into one image.
- The span in latitude of the image is ok but not longitudes(2 images).
- The span in longitude of the image is ok but not latitudes (2 images).
- Both latitude and longitude are not contained in one image(4 images).
Parameters: - ppd (int) – Required resolution
- lonm (float) – Lower left window longitude (degree)
- lonM (float) – Upper right window longitude (degree)
- latm (float) – Lower left window latitude (degree)
- latM (float) – Upper right window latitude (degree)
- path_pdsfiles (Optional[str]) –
Path where the pds files are stored. Defaults, the path is set to the folder
PDS_FILES
next to the module files where the library is install.See
defaut_pdsfile
variable of the class
-
ppd
¶ int – Required resolution
-
lonm
¶ float – Lower left window longitude (degree)
-
lonM
¶ float – Upper right window longitude (degree)
-
latm
¶ float – Lower left window latitude (degree)
-
latM
¶ float – Upper right window latitude (degree)
-
path_pdsfiles
¶ str – Path where the pds_files are stored.
Note
It is important to respect the structure of the PDS_FILES folder. WAC images should be contained within a subfolder called
LROC_WAC
.Possible resolution are stored in the class variable
implemented_res
. Longitude in the code spans 0 to 360.The abreviations correspond to:
- LRO Lunar Reconnaissance Orbiter
- LOLA Lunar Orbiter Laser Altimeter
Example
This class allows to simply gather three arrays X, Y, Z given a specific window. For instance, if we want to gather the data for a window which span 10 to 20 degree in longitude and the same in latitude, simply ask.
>>> X, Y, Z = LolaMap(512,10,20,10,20).image()
-
implemented_res
= [4, 16, 64, 128, 256, 512, 1024]¶
-
class
pdsimage.PDS_Extractor.
WacMap
(ppd, lonm, lonM, latm, latM, path_pdsfile='/Users/thorey/miniconda2/envs/bayescrat/lib/python2.7/site-packages/pdsimage/PDS_FILES')¶ Bases:
object
Class to handle the creation of LROC WAC GLOBAL images
This class is specifically designed to handle the creation of image from LROC WAC images. It is able to identify the image (or the groupe of images) necessary to extract an array over a given window. Four cases are possible and taken care of:
- The desired structure is entirely contained into one image.
- The span in latitude of the image is ok but not longitudes(2 images).
- The span in longitude of the image is ok but not latitudes (2 images).
- Both latitude and longitude are not contained in one image(4 images).
Parameters: - ppd (int) – Required resolution
- lonm (float) – Lower left window longitude (degree)
- lonM (float) – Upper right window longitude (degree)
- latm (float) – Lower left window latitude (degree)
- latM (float) – Upper right window latitude (degree)
- path_pdsfiles (Optional[str]) –
Path where the pds files are stored. Defaults, the path is set to the folder
PDS_FILES
next to the module files where the library is install.See
defaut_pdsfile
variable of the class
-
ppd
¶ int – Required resolution
-
lonm
¶ float – Lower left window longitude (degree)
-
lonM
¶ float – Upper right window longitude (degree)
-
latm
¶ float – Lower left window latitude (degree)
-
latM
¶ float – Upper right window latitude (degree)
-
path_pdsfiles
¶ str – Path where the pds_files are stored.
Note
It is important to respect the structure of the PDS_FILES folder. WAC images should be contained within a subfolder called
LROC_WAC
.Possible resolution are stored in the class variable
implemented_res
. Longitude in the code spans 0 to 360.The abreaviations correspond to:
- LROC Lunar Reconnaissance Orbiter Camera
- WAC Wide Angle Camera
Example
This class allows to simply gather three arrays X, Y, Z given a specific window. For instance, if we want to gather the data for a window which spans 10 to 20 degree in longitude and the same in latitude, simply ask.
>>> X, Y, Z = WacMap(512,10,20,10,20).image()
-
defaut_pdsfile
= '/Users/thorey/miniconda2/envs/bayescrat/lib/python2.7/site-packages/pdsimage/PDS_FILES'¶
-
image
()¶ Return the values over the required window
Returns: A tupple of three arrays (X,Y,Z)
withX
contains the longitudes,Y
contains the latitude andZ
the values extracted over the window.Note
All return arrays have the same size.
All coordinates are in degree.
-
implemented_res
= [4, 8, 16, 32, 64, 128, 256]¶


We build websites so you don't have to.
We help businesses thrive online with great website design and focus on developing great user experiences.
Design
Design should always communicate with meaning.
Development
Develop a website that engages with the customer.
Support
Need hosting, email, domain and SSL support?
Reviews
MAKE A WEB created a professional logo and branding guidelines document very efficiently! Helping us establish our brand at Rex's Yarra Valley House. We are so happy with the work and continued online support.
MAKE A WEB went above and beyond to create the perfect website for our business, and continue to do so every time we contact them. They maintain our email accounts and showed us how to edit the website from our end.


28 Sep 2020 Tzu-Li (Gordon) Tai (@tzulitai) & Igal Shilman (@IgalShilman)
The Apache Flink community is happy to announce the release of Stateful Functions (StateFun) 2.2.0! This release introduces major features that extend the SDKs, such as support for asynchronous functions in the Python SDK, new persisted state constructs, and a new SDK that allows embedding StateFun functions within a Flink DataStream job. Moreover, we’ve also included important changes that improve out-of-the-box stability for common workloads, as well as increased observability for operational purposes.
We’ve also seen new 3rd party SDKs for StateFun being developed since the last release. While they are not part of the release artifacts, it’s great seeing these community-driven additions! We’ve highlighted these efforts below in this announcement.
The binary distribution and source artifacts are now available on the updated Downloads page of the Flink website, and the most recent Python SDK distribution is available on PyPI. For more details, check the complete release changelog and the updated documentation. We encourage you to download the release and share your feedback with the community through the Flink mailing lists or JIRA!
New Features
Asynchronous functions in Python SDK
This release enables registering asynchronous Python functions as stateful functions by introducing a new handler
in the Python SDK: AsyncRequestReplyHandler
.
This allows serving StateFun functions with Python web frameworks that support asynchronous IO natively (for example,
aiohttp):
from statefun import StatefulFunctions
from statefun import AsyncRequestReplyHandler
functions = StatefulFunctions()
@functions.bind("example/greeter")
async def greeter(context, message):
html = await fetch(session, 'http://....')
context.pack_and_reply(SomeProtobufMessage(html))
# expose this handler via an async web framework
handler = AsyncRequestReplyHandler(functions)
For more details, please see the docs on exposing Python functions.
Flink DataStream Integration SDK
Using this SDK, you may combine pipelines written with the Flink DataStream
API or higher-level libraries
(such as Table API, CEP etc., basically anything that can consume or produce a DataStream
) with the programming constructs
provided by Stateful Functions, as demonstrated below:
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<RoutableMessage> namesIngress = ...
StatefulFunctionEgressStreams egresses =
StatefulFunctionDataStreamBuilder.builder("example")
.withDataStreamAsIngress(namesIngress)
.withRequestReplyRemoteFunction(
RequestReplyFunctionBuilder.requestReplyFunctionBuilder(
REMOTE_GREET, URI.create("http://..."))
.withPersistedState("seen_count")
.withFunctionProvider(GREET, unused -> new MyFunction())
.withEgressId(GREETINGS)
.build(env);
DataStream<String> responsesEgress = getDataStreamForEgressId(GREETINGS);
Events from DataStream
ingresses are being routed to bound functions, and events sent to
egresses are captured as DataStream
egresses. This opens up the possibility of building complex streaming
applications.
Construct for Dynamic State Registration
Prior to this release, the persisted state constructs in the Java SDK, such as PersistedValue
, PersistedTable
etc.,
had to be eagerly defined in a stateful function’s class. In certain scenarios, what state a function requires is not
known in advance, and may only be dynamically registered at runtime (e.g., when a function is invoked).
This release enables that by providing a new PersistedStateRegistry
construct:
public class MyFunction implements StatefulFunction {
@Persisted
private final PersistedStateRegistry registry = new PersistedStateRegistry();
private final PersistedValue<String> myValue;
public void invoke(Context context, Object input) {
if (myValue == null) {
myValue = registry.registerValue(PersistedValue.of("my-value", String.class));
}
...
}
}
Improvements
Remote Functions Communication Stability
After observing common workloads, a few configurations for communicating with remote functions were adjusted for a better out-of-the-box connection stability. This includes the following:
- The underlying connection pool was tuned for low latency, high throughput workloads. This allows StateFun to reuse existing connections much more aggressively and avoid re-establishing a connection for each request.
- StateFun applies backpressure once the total number of uncompleted requests reaches a per JVM threshold (
statefun.async.max-per-task
), but observing typical workloads we have discovered that the default value is set too high. In this release the default was reduced to improve stability and resource consumption, in the face of a slow-responding remote function.
Operational observability of a StateFun Application
One major goal of this release was to take a necessary step towards supporting auto-scaling of remote functions. Towards that end, we’ve exposed several metrics related to workload of remote functions and resulting backpressure applied by the function dispatchers. This includes the following:
- Per function type invocation duration / latency histograms
- Per function type backlog size
- Per JVM (StateFun worker) and per function type number of in-flight invocations
The full list of metrics and their descriptions can be found here.
Fine-grained control over remote connection lifecycle
With this release, it’s possible to set individual timeouts for overall duration and individual read and write IO operations of HTTP requests with remote functions. You can find the corresponding field names in a function spec that defines these timeout values here.
3rd Party SDKs
Since the last release, we’ve seen new 3rd party SDKs for different languages being implemented on top of StateFun’s remote function HTTP request-reply protocol, including Go and Rust implementations. While these SDKs are not endorsed or maintained by the Apache Flink PMC and currently not part of the current releases, it is great to see these new additions that demonstrate the extensibility of the framework.
For that reason, we’ve added a new page in the documentation to list the 3rd party SDKs that the community is aware of. If you’ve also worked on a new language SDK for StateFun that is stable and you plan to continue maintaining, please consider letting the community know of your work by submitting a pull request to add your project to the list!
Important Patch Notes
Below is a list of user-facing interface and configuration changes, dependency version upgrades, or removal of supported versions that would be important to be aware of when upgrading your StateFun applications to this version:
- [FLINK-18812] The Flink version in StateFun 2.2 has been upgraded to 1.11.1.
- [FLINK-19203] Upgraded Scala version to 2.12, and dropped support for 2.11.
- [FLINK-19190] All existing metric names have been renamed to be camel-cased instead of snake-cased, to conform with the Flink metric naming conventions. This breaks existing deployments if you depended on previous metrics.
- [FLINK-19192] The connection pool size for remote function HTTP requests have been increased to 1024, with a stale TTL of 1 minute.
- [FLINK-19191] The default max number of asynchronous operations per JVM (StateFun worker) has been decreased to 1024.
Release Notes
Please review the release notes for a detailed list of changes and new features if you plan to upgrade your setup to Stateful Functions 2.2.0.
List of Contributors
The Apache Flink community would like to thank all contributors that have made this release possible:
abc863377, Authuir, Chesnay Schepler, Congxian Qiu, David Anderson, Dian Fu, Francesco Guardiani, Igal Shilman, Marta Paes Moreira, Patrick Wiener, Rafi Aroch, Seth Wiesman, Stephan Ewen, Tzu-Li (Gordon) Tai, Ufuk Celebi
If you’d like to get involved, we’re always looking for new contributors.


STUDENT REGISTRATION FORM
FIRST NAME
(max 30 characters a-z and A-Z)
LAST NAME
(max 30 characters a-z and A-Z)
DATE OF BIRTH
Day:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Month:
January
Feburary
March
April
May
Year:
1999
2000
2001
2002
2003
EMAIL ID
MOBILE NUMBER
(10 digit number)
GENDER
Male
Female
ADDRESS
CITY
(max 30 characters a-z and A-Z)
PIN CODE
(6 digit number)
STATE
(max 30 characters a-z and A-Z)
COUNTRY
HOBBIES
Drawing
Singing
Dancing
Sketching
Others
QUALIFICATION
SI.No.Examination
Board
Percentage
Year of Passing
1. Class X
2.Class Xll
3.Graduation
4.Masters
(10 char max)
(upto 2 decimal)
COURSES
APPLIED FOR
BCA
B.Com
B.Sc
B.A


Where in the U.S. will you find the most “pleasant” days in a year? The following was published in Feb 2014 at http://www.kellegous.com/j/2014/02/03/pleasant-places.


Airline Company
Loading...
Click Register
UnRegister
Get Current Airline Balance
Request method
Tranfer to which airline
Customer ID
Customer Name
Destination
Select a destination
New York
Boston
Fuzhou
Number of Seat
Response a request
Which airline?
Settle a request
Which airline?


|
|
|
|
2013--, Distinguished Professor, 特聘教授
2011--, Professor, 责任教授
2008--2011, Associate Professor
2006--2008, Lecturer
Institute of Wireless
Communication and Technology
Department of Electronic
Engineering
School of
Electronic, Information and Electrical Engineering
Shanghai Jiao Tong
Universtiy,
Shanghai
,
China
|
|
|
2001-2006,
Ph.D. major in Electrical
and Computer Engineering
minor in Mathematics
North
Carolina State University, Raleigh, NC, USA
|
|
|
1998-2001,
M.S. in Computer
Science and Technology
Tsinghua
University, Beijing , China
|
|
|
1994-1998,
B.S. (with honors) in Automation
Shanghai
Jiao Tong Universtiy, Shanghai , China
|
|
|


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/.23reduce.20vs.20.23eval.html ---
Does it ever happen that #reduce runs forever while #eval terminates immediately?
Try 1000*1000
it times out
Does that not count as "I ran forever but I explained this to you in a different kind of way"
It would but my example involves numbers such as 1 and 0
Try (1+1)*(1+1)*(1+1)*(1+1)*...*(1+1)
... but it also involves an encoding of an infinite tree ... I wonder if that's what is taking super duper long
I'll be more specific. I'm trying:
#reduce to_bin_tree 3 (mk_tree 0)
where my_tree
creates an infinite tree starting at 0 and incrementing it from time to time and to_bin_tree
truncates it after 3 steps. It creates the following binary tree:
(node 0 (node 1 (node ⊥ ⊥)))
Anyway, you made your point. Truncating the tree is probably much more expensive now that I changed their representation
Thanks!
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


Software Engineer
Jaipur, Rajasthan, IN
>English, Hindi, Bengali
<EMAIL_ADDRESS>Skills
Angular
React
Node.js
Languages
JavaScript
Java
As a Software Engineer, I have worked on various projects using technologies like Angular, React, Node.js.
Build two project here: Mcode[A online JAVA IDE website], FabCloud[A private cloud which includes the services: SaaS, IaaS, Paas, Staas]. These projects are developed using: Docker, Redhat, Python, Apache web server
B.TECH [Information Technology]
High School


Watch a happy customer unboxing their plants!
"The best plants and the fastest service".
"The best cacti in the world!"


Hello, I'm Ting, currently an Info Systems student, a coding hobbyist, and a gamer. I'm into art, music, coding, reading, gaming, and anything in between.


Barneys' Madison Avenue store to remain open for at least a year
(Reuters) - Barneys New York Inc’s flagship Madison Avenue outlet in Manhattan will remain open for at least another year in a slimmed-down form while the buyer of the luxury retailer’s brands negotiates with the store’s landlord.
A bankruptcy judge approved the sale of Barneys brands and other intellectual property to Authentic Brands, a firm that acquires and licenses brands, on Thursday. The deal closed on Friday, Authentic Brands said.
The store’s well-known eatery, Fred’s, will also remain open.
“We have come to terms with Authentic Brands Group, Barneys new owner, to keep the Madison Avenue store open in a smaller footprint for the next 12 months while we continue to explore longer term solutions,” Daniel Levy, president of real estate investment firm Ashkenazy Acquisition Corp, the store’s landlord, said in a statement on Friday.
Levy said the New York store generates about $20 million in annual profitability for Barneys, even with a recent raise in rent.
A cultural touchstone for generations of New Yorkers and followers of fashion, Barneys filed for bankruptcy protection in August, citing rent hikes as a factor.
Authentic Brands, which bid roughly $271 million for Barneys, said it will turn the Madison Avenue location into a pop-up store.
The firm plans to license the Barneys brand to Hudson’s Bay Co owned Saks Fifth Avenue and will open shops in Saks locations across the United States and Canada.
That will start with an attempted Barneys reboot on the fifth floor of the Saks Fifth Avenue location in Manhattan. Remaining Barneys stores are expected to close.
“Over the past several months, we have worked diligently with the court, our lenders and creditors to maximize the value of the Barneys assets and we’re pleased to have reached the conclusion of this process,” Barneys said in a statement.


Exodus 27:8
Hollow with boards shalt thou make it: as it was showed thee in the mount, so shall they make it.


REQUIREMENTS
- colored (pip install colored)
DESCRIPTION
- This is a game where you play against the dealer and try to get the higher values of cards without exceeding over the number 21. If your cards ever equal a total of 21, you automatically get blackjack (win) unless both you and the dealer get 21 then you push (tie). The user also has a cash balance that is wagered based on winning or losing, the user must keep their cash balance positive and not negative to keep playing.
IMPORTANT
- You can now visit the website - http://jordanleich.github.io/Python-Blackjack-21-Game/ for additional information!


RhoMobile Suite 5.2.2 is Available
What is new in this release:
- RhoMobile Suite 5.2.2 features a completely redesigned licensing model.
- From 5.2.2 you no longer purchase licenses to run on a specific device or that are tied to a specific application, instead licenses are purchased on a per-developer basis and integrated with the re-branded Rhomobile.com website, the Rho cloud build solution.
- Full details of the new license model are available from our licensing doc which is definitely worth a quick read before getting started with 5.2.2.
- You will need a developer account before you can...
(Read more)


Feature Model Diagrams in text and HTML
By Beman Dawes
Introduction
In their seminal book, Generative Programming, Czarnecki and Eisenecker (C&E)) describe how to build feature models [C&E 4.4] consisting of a feature diagram plus semantic, rationale, and other attributes. Feature models are then used to drive design cycles which eventually lead to manual or automatic assembly of configurations.
Feature models provide a language to describe the library variability that is often such an issue in boost.org discussions. The Whorf hypothesis that "Language shapes the way we think, and determines what we can think about" seems to apply. In discussion of library variability issues, we have been crippled by lack of a good language. With feature models, we now have a language to carry on the dialog.
The graphical feature diagrams presented by C&E are not in a suitable form for the email discussions boost.org depends upon. The hierarchical nature of feature diagrams can be represented by a simple text-based feature diagram language. A feature model can also take advantage of the hyperlinks inherent in HTML.
Grammar
The grammar for the feature diagram language is expressed in Extended Bakus-Naur Form;::= represents productions, [...] represents options, {...} represents zero or more instances, and represents | alternatives.
feature-model ::= concept-name details { feature } feature ::= feature-name [details] details ::= "(" feature-list ")" // required features | "[" feature-list "]" // optional features feature-list ::= element { "|" element } // one only | element { "+" element } // one or more | element { "," element } // all // [a+b] equivalent to [a,b] element ::= feature | details concept-name ::= name feature-name ::= name
The usual lexical conventions apply. Names are case-insensitive and consist of a leading letter, followed by letters, digits, underscores or hyphens, with no spaces allowed.
At least one instance of each name should be hyperlinked to the corresponding Feature Description.
While the grammar is intended for written communication between people, it may also be trivially machine parsed for use by automatic tools.
Descriptive information is associated with each concept or feature. According to [C&E 4.4.2] this includes:
- Semantic descriptions.
- Rationale.
- Stakeholders and client programs.
- Exemplar systems.
- Constraints and default dependency rules.
- Availability sites, binding sites, and binding mode.
- Open/Closed attribute.
What is a Feature?
A feature [C&E 4.9.1] is "anything users or client programs might want to control about a concept. Thus, during feature modeling, we document no only functional features ... but also implementation features, ..., various optimizations, alternative implementation techniques, and so on."
Example
special-container ( organization, performance, interface ) // all required organization [ ordered + indexed ] // zero or more (4 configurations) indexed [ hash-function ] // zero or one (2 configurations) performance ( fast | small | balanced ) // exactly one (3 configurations) interface ( STL-style + cursor-style ) // one or more (3 configurations)
There should be feature descriptions for
some-container, organization, ordered, indexed,
hash-function, performance, fast, small, balanced, interface,
STL-style, and cursor-style
.
The number of possible configurations is (2 + 2*2) * 3 * 3 = 54, assuming no constraints.
There are equivalent representations. For example:
special-container ( organization[ ordered+indexed[ hash-function ]], performance( fast|small|balanced ), interface( STL-style+cursor-style ) )
References
Krzysztof Czarnecki and Ulrich W. Eisenecker, Generative Programming, Addison-Wesley, 2000, ISBN 0-201-30977-7